排序算法相关

选择排序

从首元素开始，选择最小/最大的元素放入起始位置，再从剩余元素找到最小/最大放在已排序列的末尾，以此类推。

public static int[] selectionSort(int[] array) {
    if (array.length == 0)
        return array;
    for (int i = 0; i < array.length; i++) {
        int m = i;
        for (int j = i; j < array.length; j++) {
            if (array[j] < array[m]) 
                m = j; 
        }
        int temp = array[m];
        array[m] = array[i];
        array[i] = temp;
    }
    return array;
}

冒泡排序

从首元素开始，两两比较，小/大放前面，最后一个数是最大数/最小数，再次循环到除了最后一个数，依次循环。

public static int[] bubbleSort(int[] array) {
    if (array.length == 0)
        return array;
    for (int i = 0; i < array.length; i++)
        for (int j = 0; j < array.length - 1 - i; j++)
            if (array[j + 1] < array[j]) {
                int temp = array[j + 1];
                array[j + 1] = array[j];
                array[j] = temp;
            }
    return array;
}

插入排序

• 步骤1: 从第一个元素开始，该元素可以认为已经被排序；
• 步骤2: 取出下一个元素，在已经排序的元素序列中从后向前扫描；
• 步骤3:如果该元素（已排序）大于新元素，将该元素移到下一位置；
• 步骤4: 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
• 步骤5:将新元素插入到该位置后； 步骤6: 重复步骤2~5。

public static int[] insertionSort(int[] array) {
    if (array.length == 0)
        return array;
    int current;
    for (int i = 0; i < array.length - 1; i++) {
        current = array[i + 1];
        int pr = i;
        while (pr >= 0 && current < array[pr]) {
            array[pr+ 1] = array[pr];
            pr--;
        }
        array[pr + 1] = current;
    }
    return array;
}

快速排序

• 1）选取数组左边第一个关键字为标志位，并暂存至flag中(注：标志位选取的方式可用不同方式)
• 2）第一层while循环用于保证一趟比较遍历完所有关键字
• 3）第二层第一个while循环用于从右侧依次向左找小于flag的关键
• 4）第二层第二个while循环用于从左侧依次向右找大于flag的关键字
• 5）第二层的两个while循环执行后，如果l<r则进行交换
• 6）一趟比较后，将l和r共同指向的关键字放入最左侧，即flag的选取位置，并将flag值放入此位置，此时序列便以flag为界，左边均小于flag，右边均大于flag
• 7）然后再用“分治法”分别向左和向右递归执行上述步骤，直到无法拆分为止，整个序列即为有序

public static void quickSort(int[] array ,int left,int right){
    int l,r,flag,temp;
    if(left >= right){
        return;
    }
    l = left;
    r = right;
    flag = array[left];
    while (l < r){
        while (array[r] >= flag && l < r){
            r --;
        }
        while (array[l] <= flag && l < r){
            l ++;
        }
        if(l < r){
            temp = array[l];
            array[l] = array[r];
            array[r] = temp;
        }
    }
    array[left] = array[l];
    array[l] = flag;
    quickSort(array,left,l-1);
    quickSort(array,l+1,right);
}

归并排序

• 把长度为n的输入序列分成两个长度为n/2的子序列；
• 这两个子序列分别采用归并排序；
• 将两个排序好的子序列合并成一个最终的排序序列。

public int[] mergeSort(int[] nums) {
    if (nums.length < 2) {
        return nums;
    } 
    int mid = nums.length / 2;
    int[] nums1 = Arrays.copyOfRange(nums, 0, mid);
    int[] nums2 = Arrays.copyOfRange(nums, mid, nums.length);
    return merge(mergeSort(nums1), mergeSort(nums2));
}
private int[] merge(int[] nums1, int[] nums2) {
    int[] back = new int[nums1.length + nums2.length];
    for (int i = 0, m = 0, n = 0; i < back.length; i++) {
        if (m == nums1.length) {
            back[i] = nums1[m++];
        } else if (n == nums2.length) {
            back[i] = nums2[n++];
        } else if (nums1[m] < nums2[n]) {
            back[i] = nums1[m++];
        } else {
            back[i] = nums2[n++];
        }
    }
    return back;
}

堆排序

希尔排序

• 选择k，序列进行k 趟排序*；
• 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

public static void shellSort(int[] array){
    int j;
    for(int gap = array.length/2; gap>0; gap /= 2){
        //定义一个增长序列，即分割数组的增量,d1=N/2   dk=(d(k-1))/2
        for(int i = gap; i<array.length;i++){
            int tmp = array[i];
            for( j =i; j>=gap&&tmp<array[j-gap]; j -= gap){
                //将相距为Dk的元素进行排序
                array[j] = array[j-gap];
            }
            array[j] = tmp;
        }
    }
}

桶排序

转自 https://blog.csdn.net/weixin_41190227/article/details/86600821