经典排序算法——希尔排序

Posted 2021-04-25 代码民工

希尔排序

✍基本思想|演示|算法代码|性能

　基本思想　

希尔排序（Shell Sort）是插入排序算法的一种改进版本，又称为缩小增量排序。

希尔排序把下标按照一定的增量（gap=n/2）进行分组，然后分别对每个组内的数据进行直接插入排序，不断缩小增量进行排序，直至gap=1时，对整组数据进行直接插入排序。

以数据8、5、2、4、1、7、6、3为例

首先对数据进行分组，间隔gap=n/2=4，同色的为同一组，如上图所示，对组内数据进行直接插入排序，如下图

以间隔gap=2进行分组，如上图所示，对组内数据进行直接插入排序，如下图

以间隔gap=1进行分组，如上图所示，其实就是对整组数据进行直接插入排序，排序完后的数据如下图

C++代码

 1#include<iostream>
 2using namespace std;
 3void ShellSort(int a[], int n)
 4{
 5    int gap = n / 2;
 6    while (gap >= 1)
 7    {
 8        for (int i = gap; i<n; i++)
 9        {
10            int j;
11            int temp = a[i];
12            for (j = i - gap; j >= 0 && a[j]>temp; j = j - gap)
13            {
14                a[j + gap] = a[j];
15            }
16            a[j + gap] = temp;
17        }
18        gap = gap / 2;
19    }
20}
21int main()
22{
23    int a[8] = { 8,5,2,4,1,7,6,3 };
24    ShellSort(a, 8);
25    for (int i = 0; i < 8; i++)
26    {
27        cout << a[i] << " ";
28    }
29
30      return 0;
31}

Python代码

 1def ShellSort(nums):
 2    gap=int(len(nums)/2)
 3    while gap>=1:
 4        i=gap
 5        while i<len(nums):
 6            temp=nums[i]
 7            j=i-gap
 8            while j>=0 and nums[j]>temp:
 9                a[j+gap]=a[j]
10                j=j-gap
11            nums[j+gap]=temp
12            i+=1
13        gap=int(gap/2)
14a=[8,5,2,4,1,7,6,3]
15ShellSort(a)
16print(a)

Java代码

 1package text;
 2
 3public class ShellSort {
 4    public void Sort(int a[]){
 5        int gap=a.length/2;
 6        int i,j,temp;
 7        while(gap>=1){
 8            for(i=gap;i<a.length;i++){
 9                temp=a[i];
10                for(j=i-gap;j>=0&&a[j]>temp;j=j-gap){
11                    a[j+gap]=a[j];
12                }
13                a[j+gap]=temp;
14            }
15            gap=gap/2;
16        }
17    }
18    public void ShowArr(int a[]){
19        for(int x:a)
20            System.out.print(x+" ");
21        System.out.println();
22    }
23
24    public static void main(String[] args) {
25        int a[]={8,5,2,4,1,7,6,3};
26        ShellSort sorter=new ShellSort();
27        sorter.Sort(a);
28        sorter.ShowArr(a);
29    }
30
31}

希尔排序是一种不稳定的排序算法，其时间复杂度与增量的选取有关，平均时间复杂度为O(N^1.3)，空间复杂度为O(1)