Shell Sort

时间复杂度O(nlogn)

最好情况O(nlogn**2)

最坏情况O(nlogn**2)

空间复杂度O(1)

In-place

希尔排序

在插入排序的基础上进行了优化，使时间复杂度突破O(n**2)

核心思想是对整个数组进行分组，在分组内进行插排，再次分组再次插排...

直到整个数组为一组，这时候已经基本有序，进行最后一次插排

一般起始我们会把数组分为length/2个组（gap），意味着每个组有两个元素，然后gap = gap/2

直到gap = 1进行最后一次排序。

Java：

public class ShellSort {
    public int[] ClassicalShellSort(int[] a){
        if(a == null||a.length <= 1){
            return a;
        }
        for(int gap = a.length/2;gap > 0;gap = gap/2){
            for (int i = gap; i <a.length; i++) {
                int tem = a[i];
                int preIndex = i - gap;
                // 插入排序：一直后移直到找到合适的位置
                while (preIndex >= 0&&a[preIndex]>tem){
                    a[preIndex + gap] = a[preIndex];
                    preIndex -= gap;
                }
                a[preIndex + gap] = tem;
            }
        }
        return a;
    }
}

 Python:

def shell_sort(num_list):
    if num_list == None or len(num_list) <= 1:
        return num_list
    gap = len(num_list) // 2
    while gap > 0:
        for i in range(gap, len(num_list)):
            next = num_list[i]
            j = i
            while j > 0:
                if next < num_list[j - 1]:
                    num_list[j] = num_list[j - 1]
                else:
                    break
                j -= 1
            num_list[j] = next
        gap //= 2
    return num_list