Java实现五大排序算法

1、冒泡排序

里面的for循环，把当前所循环的数中的最大数，移到能表示的最后面。一次循环确当一个数。

// 升序排列
public static void bubbleSort(int[] arr) {
    
    
        boolean sorted = false;
        int unsortedNum = arr.length - 1;
        int temp = 0;
        while (!sorted) {
    
    
            sorted = true;
            for (int i = 0; i < unsortedNum; i++) {
    
    
                if (arr[i] > arr[i + 1]) {
    
    
                    sorted = false;
                    temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }
            unsortedNum = unsortedNum - 1;
        }
    }

2、选择排序

里面的for循环求出第i小值的索引，再在外面的for循环里与第i个元素交换位置。一次循环确当一个数。

// 升序排序
public static void selectSort(int[] arr) {
    
    
        for (int i = 0; i < arr.length; i++) {
    
    
            int lowestNumberIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
    
    
                if (arr[lowestNumberIndex] > arr[j]) {
    
    
                    lowestNumberIndex = j;
                }
            }

            if (lowestNumberIndex != i) {
    
    
                int temp = arr[i];
                arr[i] = arr[lowestNumberIndex];
                arr[lowestNumberIndex] = temp;
            }
        }
    }

3、插入排序

i左边的元素是排好序的，右边的包括i是无序的，所以该算法就是把i和i右边的元素一个一个的插到左边的合适的位置。一次循环确当一个数。

// 升序
public static void insertionSort(int[] arr) {
    
    
        for (int i = 1; i < arr.length; i++) {
    
    
            int temp = arr[i];
            int position = i;
            while (position > 0 && arr[position - 1] > temp) {
    
    
                arr[position] = arr[position-1];
                position--;
            }
            arr[position] = temp;
        }
    }

4、快速排序

一次分割确定一个数的位置（本代码中是把小于等于它的放在它前面，大于它的放在它后面），对数组进行层层分割，直到所有排好序

// 快速排序升序	
public static void quickSort(int[] arr, int start, int end) {
    
    
        if(start < end) {
    
    
            int pivot = partition(arr, start, end);
            quickSort(arr, start, pivot - 1);
            quickSort(arr, pivot + 1, end);
        }
    }
    
	// 分割
    public static int partition(int[] arr, int start, int end) {
    
    
        int pivot = getRandomNumber(start, end);
        swap(arr, start, pivot);
        int pointerA = start, pointerB;
        for(pointerB = start + 1; pointerB <= end; pointerB++ ) {
    
    
            if(arr[pointerB] <= arr[start]) {
    
    
                pointerA++;
                swap(arr, pointerA, pointerB);
            }
        }
        swap(arr, pointerA, start);
        return pointerA;
    }
    // 交换数组中两个数数的位置
    public static void swap(int[] arr, int a, int b) {
    
    
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
    // 获得随机数
    public static int getRandomNumber(int start, int end) {
    
    
        Random random = new Random();
        int num = random.nextInt(end - start + 1) + start;
        return num;
    }

5、二路归并排序

把一个数组分成多个区域且该区域元素只有一个，在对这些区域进行层层归并（把两个有序的区域合并成一个有序的区域）

// 二路归并排序升序
public static void mergeSort(int[] arrSource, int[] arrTarget, int start, int end) {
    
    
    if(start < end) {
    
    
        int mid = (start + end) / 2;
        mergeSort(arrSource, arrTarget, start, mid);
        mergeSort(arrSource, arrTarget, mid + 1, end);
        merge(arrSource, arrTarget, start, mid, end);
        copy(arrSource, arrTarget, start, end);
    }
 }
 // 归并
 public static void merge(int[] arrSource, int[] arrTarget, int start, int mid, int end) {
    
    
    int pointS1 = start;
    int pointS2 = mid + 1;
    int pointT = start;
    while(pointS1 <= mid && pointS2 <= end) {
    
    
        if(arrSource[pointS1] > arrSource[pointS2]) {
    
    
            arrTarget[pointT] = arrSource[pointS2];
            pointS2++;
        }else{
    
    
            arrTarget[pointT] = arrSource[pointS1];
            pointS1++;
        }
        pointT++;
    }
    while(pointS1 <= mid) {
    
    
        arrTarget[pointT] = arrSource[pointS1];
        pointS1++;
        pointT++;
    }
    while(pointS2 <= end) {
    
    
        arrTarget[pointT] = arrSource[pointS2];
        pointS2++;
        pointT++;
    }
}
// 把一个数组的元素复制到另一个数组
public static void copy(int[] arrSource, int[] arrTarget, int start, int end) {
    
    
    for(int i = start; i <= end; i++) {
    
    
        arrSource[i] = arrTarget[i];
    }
}