快速排序、希尔排序、归并排序（详细解释）_希尔排序和归并排序哪个快-CSDN博客

package com.kfm.it.Array;

import java.util.Arrays;

public class Arrayquilk {

    public static void main(String[] args) {
        int[] arr = {2, 1, 3, 4, 5, 6};

        quilk(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }

    public static void quilk(int[] arr, int start, int end) {
        if (start>=end){
            return;
        }
        int base = arr[start];
        int left = start;
        int right = end;

        while (left<right){
            while (left<right && base<=arr[right]){
                right--;
            }
            while (left<right && base>=arr[left]){
                left++;
            }
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
        }
        arr[start] = arr[left];
        arr[left] = base;

        quilk(arr,start,left-1);
        quilk(arr,left+1,end);
    }
}

二、希尔排序

希尔排序是按照其设计者希尔的名字命名的。希尔排序也是一种插入排序，它是插入排序经过改进之后的一个更高效的版本。

1、步骤

（1）先选定一个整数gap（gap是间隔、差距的意思）作为增量，一般情况下是将 length/2 作为增量，然后将所有距离为gap的元素分为一组，并对每一组进行插入排序

（2）缩小增量，让gap = gap/2 然后重复第1步，直到gap等于1停止

2、举例

有数组如下，使用希尔排序该数组

3、代码

package com.kfm.it.Rank;

import java.util.Arrays;

public class Shellsort {
    public static void main(String[] args) {
        int [] arr = {2,5,2,3,5,6};
        int[] ints = shellSort(arr);
        System.out.println(Arrays.toString(ints));
    }
    public static int[] shellSort(int[] arr) {
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < arr.length; i++) {
                for (int j = i - gap; j >= 0; j -= gap) {
                    if (arr[j] > arr[j + gap]) {
                        int temp = arr[j];
                        arr[j] = arr[j + gap];
                        arr[j + gap] = temp;
                    }
                }
            }
        }
        return arr;
    }
}

4、算法分析

稳定性：不稳定

时间复杂度：最佳：O(nlog²n)

最差：O(nlog²n)

平均：O(nlogn)

空间复杂度：O(1)

三、归并排序

1945年，约翰·冯·诺依曼（John von Neumann）发明了归并排序，这是典型的分治算法的应用。

1、定义

归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法，该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。

2、算法思路

归并排序算法有两个基本的操作，一个是分，也就是把原数组划分成两个子数组的过程。另一个是治，它将两个有序数组合并成一个更大的有序数组。

将待排序的线性表不断地切分成若干个子表，直到每个子表只包含一个元素，这时，可以认为只包含一个元素的子表是有序表。
将子表两两合并，每合并一次，就会产生一个新的且更长的有序表，重复这一步骤，直到最后只剩下一个子表，这个子表就是排好序的线性表。

3、代码

package com.kfm.it.Rank;

import java.util.Arrays;

public class Dui {
    public static void main(String[] args) {
        int[] array = {8,4,5,7,1,3,6,2};
        int[] ints = MergeSort(array);
        System.out.println(Arrays.toString(ints));
    }
    public static int[] MergeSort(int[] array) {
        if (array.length < 2) return array;
        int mid = array.length / 2;
        int[] left = Arrays.copyOfRange(array, 0, mid);
        int[] right = Arrays.copyOfRange(array, mid, array.length);
        return merge(MergeSort(left), MergeSort(right));

    }
    public static int[] merge(int[] left, int[] right) {
        int[] result = new int[left.length + right.length];
        for (int index = 0, i = 0, j = 0; index < result.length; index++) {
            if (i >= left.length)
                result[index] = right[j++];
            else if (j >= right.length)
                result[index] = left[i++];
            else if (left[i] > right[j])
                result[index] = right[j++];
            else
                result[index] = left[i++];
        }
        return result;
    }
}