希尔排序

百科名片

  

希尔排序法

希尔排序(Shell Sort)是插入排序的一种。是针对直接插入排序算法的改进。该方法又称缩小增量排序，因DL．Shell于1959年提出而得名。

•  查看精彩图册

目录

基本思想

介绍

算法分析

稳定性

选择排序

希尔排序的JAVA实现

希尔排序的C#实现

展开

基本思想

介绍

算法分析

稳定性

选择排序

希尔排序的JAVA实现

希尔排序的C#实现

展开

编辑本段基本思想

　　先取一个小于n的整数d1作为第一个 增量，把文件的全部记录分成（n除以d1）个组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行 直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量dt=1(dt<dt-l<…<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。

　　该方法实质上是一种分组插入方法。

　　比较相隔较远距离（称为增量）的数，使得数移动时能跨过多个元素，则进行一次比较就可能消除 多个元素交换。D.L.shell于1959年在以他名字命名的 排序算法中实现了这一思想。算法先将要排序的一组数按某个增量d分成若干组，每组中记录的下标相差d.对每组中全部元素进行排序，然后再用一个较小的增量对它进行，在每组中再进行排序。当增量减到1时，整个要排序的数被分成一组，排序完成。

　　一般的初次取序列的一半为增量，以后每次减半，直到增量为1。

　　给定实例的shell排序的排序过程

　　假设待排序文件有10个记录，其关键字分别是：

　　49，38，65，97，76，13，27，49，55，04。

　　增量序列的取值依次为：

　　5，3，1

编辑本段介绍

缩小增量法

　　属于插入类排序,是将整个无序列分割成若干小的子序列分别进行 插入排序

　　排序过程：先取一个正整数d1<n，把所有序号相隔d1的 数组元素放一组，组内进行 直接插入排序；然后取d2<d1，重复上述分组和排序操作；直至di=1，即所有记录放进一个组中排序为止

　　初始：d=5

　　49 38 65 97 76 13 27 49 55 04

　　49 13

　　|-------------------|

　　38 27

　　|-------------------|

　　65 49*

　　|-------------------|

　　97 55

　　|-------------------|

　　76 04

　　|-------------------|

　　一趟结果

　　13 27 49* 55 04 49 38 65 97 76

　　d=3

　　13 27 49* 55 04 49 38 65 97 76

　　13 55 38 76

　　|------------|------------|------------|

　　27 04 65

　　|------------|------------|

　　49* 49 97

　　|------------|------------|

　　二趟结果

　　13 04 49* 38 27 49 55 65 97 76

　　d=1

　　13 04 49* 38 27 49 55 65 97 76

　　|----|----|----|----|----|----|----|----|----|

　　三趟结果

　　04 13 27 38 49 49 55 65 76 97

　　--------------------------------------------------------------------------------------------

Shell排序

　　Shell排序的算法实现:

　　1． 不设 监视哨的算法描述

　　void ShellPass(SeqList R，int d)

　　{//希尔排序中的一趟排序，d为当前 增量

　　for(i=d+1;i<=n；i++) //将R[d+1．．n]分别插入各组当前的有序区

　　if(R[ i ].key<R[i-d].key){

　　R[0]=R[i];j=i-d； //R[0]只是暂存单元，不是哨兵

　　do {//查找R的插入位置

　　R[j+d]=R[j]； //后移记录

　　j=j-d； //查找前一记录

　　}while(j>0&&R[0].key<R[j].key)；

　　R[j+d]=R[0]； //插入R到正确的位置上

　　} //endif

编辑本段算法分析

优劣

　　不需要大量的辅助空间，和 归并排序一样容易实现。希尔排序是基于 插入排序的一种算法， 在此算法基础之上增加了一个新的特性，提高了效率。希尔排序的 时间复杂度为 O(N*(logN)2)， 没有 快速排序算法快 O(N*(logN))，因此中等大小规模表现良好，对规模非常大的 数据排序不是 最优选择。但是比O(N2）复杂度的算法快得多。并且希尔排序非常容易实现，算法代码短而简单。 此外，希尔算法在最坏的情况下和平均情况下执行效率相差不是很多，与此同时快速排序在最坏 的情况下执行的效率会非常差。 专家们提倡，几乎任何排序工作在开始时都可以用希尔排序，若在实际使用中证明它不够快， 再改成快速排序这样更高级的 排序算法. 本质上讲，希尔排序算法的一种改进，减少了其复制的次数，速度要快很多。 原因是，当N值很大时 数据项每一趟排序需要的个数很少，但数据项的距离很长。 当N值减小时每一趟需要和动的数据增多，此时已经接近于它们排序后的最终位置。 正是这两种情况的结合才使希尔排序效率比插入排序高很多。

时间性能

　　1． 增量序列的选择

　　 Shell排序的执行时间依赖于增量序列。

　　好的增量序列的共同特征：

　　① 最后一个增量必须为1；

　　② 应该尽量避免序列中的值(尤其是相邻的值)互为倍数的情况。

　　有人通过大量的实验，给出了目前较好的结果：当n较大时，比较和移动的次数约在nl.25到1.6n1.25之间。

　　2．Shell排序的时间性能优于 直接插入排序

　　希尔排序的时间性能优于直接插入排序的原因：

　　①当文件初态基本有序时直接插入排序所需的比较和移动次数均较少。

　　②当n值较小时，n和n2的差别也较小，即直接插入排序的最好 时间复杂度O(n)和最坏时间复杂度0(n2)差别不大。

　　③在希尔排序开始时增量较大，分组较多，每组的记录数目少，故各组内直接插入较快，后来增量di逐渐缩小，分组数逐渐减少，而各组的记录数目逐渐增多，但由于已经按di-1作为距离排过序，使文件较接近于有序状态，所以新的一趟排序过程也较快。

　　因此，希尔排序在效率上较直接插人排序有较大的改进。

编辑本段稳定性

稳定性

　　排序前一个序列中,如果出现N个与 关键字相同的数据,那么排序后仍然按照原先序列的排列顺序排列,就说这个算法是稳定的,反之就是不稳定的。通俗地讲就是能保证排序前2个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。再简单形式化一下，如果Ai = Aj, Ai原来在Aj位置前，排序后Ai还是要在Aj位置前。

希尔分析

　　希尔排序是按照不同步长对元素进行 插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序了，步长很小，插入排序对于有序的序列效率很高。所以，希尔排序的 时间复杂度会比o(n^2)好一些。由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的。

编辑本段选择排序

　　选择排序的基本思想是：

　　对待排序的记录序列进行n-1遍的处理，第1遍处理是将L[1..n]中最小者与L[1]交换位置，第2遍处理是将L[2..n]中最小者与L[2]交换位置，......，第i遍处理是将L中最小者与L交换位置。这样，经过i遍处理之后，前i个记录的位置就已经按从小到大的顺序排列好了。

　　例1:输入序列数据按非减顺序输出.

　　程序1(pascal)如下:

　　program xzpx_1;

　　var

　　a:array[1..10000]of longint;

　　i,j,n,t:longint;

　　begin

　　readln(n);

　　for i:=1 to n do read(a[i]);

　　for i:=1 to n-1 do

　　for j:=i+1 to n do

　　if a[i]>a[j]then begin t:=a[i];a[i]:=a[j];a[j]:=t;end;

　　for i:=1 to n do write(a[i],' ');

　　end.

　　程序2(pascal)如下:

　　program xzpx_2;

　　var

　　a:array[1..10000]of longint;

　　i,j,n,t,min:longint;

　　begin

　　readln(n);

　　for i:=1 to n do read(a[i]);

　　for i:=1 to n-1 do

　　begin

　　min:=i;

　　for j:=i+1 to n do

　　if a[min]>a[j]then min:=j;

　　if min<>i then begin t:=a[min];a[min]:=a[i];a[i]:=t;end;

　　end;

　　for i:=1 to n do write(a[i],' ');

　　end.

编辑本段希尔排序的JAVA实现

　　public class Test {

　　public static int[] a = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 };

　　public static void main(String args[]) {

　　int i; // 循环计数变量

　　int Index = a.length;// 数据索引变量

　　System.out.print("排序前: ");

　　for (i = 0; i < Index - 1; i++)

　　System.out.printf("%3s ", a[i]);

　　System.out.println("");

　　ShellSort(Index - 1); //  选择排序

　　// 排序后结果

　　System.out.print("排序后: ");

　　for (i = 0; i < Index - 1; i++)

　　System.out.printf("%3s ", a[i]);

　　System.out.println("");

　　}

　　public static void ShellSort(int Index) {

　　int i, j, k; // 循环计数 变量

　　int Temp; // 暂存变量

　　boolean Change; // 数据是否改变

　　int DataLength; // 分割集合的间隔长度

　　int Pointer; // 进行处理的位置

　　DataLength = (int) Index / 2; // 初始集合间隔长度

　　while (DataLength != 0) // 数列仍可进行分割

　　{

　　// 对各个集合进行处理

　　for (j = DataLength; j < Index; j++) {

　　Change = false;

　　Temp = a[j]; // 暂存Data[j]的值,待交换值时用

　　Pointer = j - DataLength; // 计算进行处理的位置

　　// 进行集合内数值的比较与交换值

　　while (Temp < a[Pointer] && Pointer >= 0 && Pointer <= Index) {

　　a[Pointer + DataLength] = a[Pointer];

　　// 计算下一个欲进行处理的位置

　　Pointer = Pointer - DataLength;

　　Change = true;

　　if (Pointer < 0 || Pointer > Index)

　　break;

　　}

　　// 与最后的数值交换

　　a[Pointer + DataLength] = Temp;

　　if (Change) {

　　// 打印目前排序结果

　　System.out.print("排序中: ");

　　for (k = 0; k < Index; k++)

　　System.out.printf("%3s ", a[k]);

　　System.out.println("");

　　}

　　}

　　DataLength = DataLength / 2; // 计算下次分割的间隔长度

　　}

　　}

　　}

编辑本段希尔排序的C#实现

　　using System;

　　public class ShellSorter

　　{

　　public void Sort(int[] list)

　　{

　　int inc;

　　for (inc = 1; inc <= list.Length / 9; inc = 3 * inc + 1) ;

　　for (; inc > 0; inc /= 3)

　　{

　　for (int i = inc + 1; i <= list.Length; i += inc)

　　{

　　int t = list[i - 1];

　　int j = i;

　　while ((j > inc) && (list[j - inc - 1] > t))

　　{

　　list[j - 1] = list[j - inc - 1];

　　j -= inc;

　　}

　　list[j - 1] = t;

　　}

　　}

　　}

　　}

　　public class MainClass

　　{

　　public static void Main()

　　{

　　int[] iArrary = new int[] { 1, 5, 3, 6, 10, 55, 9, 2, 87, 12, 34, 75, 33, 47 };

　　ShellSorter sh = new ShellSorter();

　　sh.Sort(iArrary);

　　for (int m = 0; m <= 13; m++)

　　Console.WriteLine("{0}", iArrary[m]);

　　Console.ReadKey();

　　}

　　}

　　for (int i = k; i < len; i++)

　　{

　　if (arry[i - k] > arry[i])

　　{

　　int temp;

　　temp = arry[i - k];

　　arry[i - k] = arry[i];

　　arry[i] = temp;

　　}

　　}

　　}

　　foreach (int i in arry)

　　{

　　Console.WriteLine(i);

　　}

　　Console.ReadLine();

　　program ShellSorter;

　　type arr=array[1..n] of integer;

　　var a:arr;

　　i,n,j,t,d:integer;

　　bool:boolean;

　　begin

　　readln(n);

　　for i:=1 to n do read(a[i]);writeln;

　　d:=n;

　　while d>1 do begin d:=d div 2;

　　for j:=d+1 to n do begin t:=a[j];

　　i:=j-d;

　　while (i>0) and (a[i]>t) do

　　begin

　　a[i+d]:=a[i];

　　i:=i-d;

　　end;

　　a[i+d]:=t;

　　end;

　　end;

　　for i:=1 to n do write(a[i]:6);

　　writeln;

　　end.

编辑本段希尔排序的C实现

　　k=n/2;

　　while(k>0)

　　{

　　for(i=k;i<=n;i++)

　　{

　　t=a[i];

　　j=i-k;

　　while(j>=0&&t<a[j])

　　{

　　a[j+k]=a[j];

　　j=j-k;

　　}

　　a[j+k]=t;

　　}

　　k/=2;

　　}

　　希尔排序C的四种实现：

　　void shellsort(int *a,int n)

　　{

　　int k = n/2;

　　while(k>0)

　　{

　　for(int i = k;i< N;i++)

　　{

　　int t = a[i];

　　#if 0

　　//算法1

　　int j = i - k;

　　while(j >= 0 && t < a[j])

　　{

　　a[j + k] = a[j];

　　j = j - k;

　　}

　　#endif

　　#if 0

　　//算法2

　　int j;

　　for(j = i - k;j>=0 && t < a[j];j -= k)

　　a[j + k] = a[j];

　　a[j + k] = t;

　　#endif

　　#if 0

　　//算法3

　　int j;

　　for(j = i;j >= k && t < a[j - k];j -= k)

　　a[j] = a[j - k];

　　a[j] = t;

　　#endif

　　//算法4

　　int j = i;

　　while(j >= k && t < a[j - k])

　　{

　　a[j] = a[j-k];

　　j = j-k;

　　}

　　a[j] = t;

　　}

　　k /= 2;

　　}

　　}

　　int main()

　　{

　　int a[N]= {8,10,3,5,7,4,6,1,9,2};

　　shellsort(a,sizeof(a)/sizeof(a[0]));

　　for(int k = 0;k < N;k++)

　　printf("a[%d] = %d\n",k,a[k]);

　　return 0;

　　}

编辑本段希尔排序的C++实现

　　#include <stdio.h>

　　void shellSort(int a[], int n)

　　{

　　int d = n;

　　while(d > 1)

　　{

　　d = (d + 1) / 2;

　　for(int i = 0; i < n - d; i++)

　　{

　　if(a[i + d] < a[i])

　　{

　　int temp = a[i + d];

　　a[i + d] = a[i];

　　a[i] = temp;

　　}

　　}

　　}

　　}

　　int main(void)

　　{

　　int a[] = {49, 38, 65, 97, 76, 13, 27, 49, 55, 04};

　　int len = sizeof(a) / sizeof(int);

　　shellSort(a, len);

　　for(int i = 0; i < len; i++)

　　printf("%3d", a[i]);

　　printf("\n");

　　return 0;

　　}

　　这段程序是错的，比如a[4]={8,4,9,5},以下是正确的算法：（小心下面(-_-') ）

　　void ShellSort(int a[], int n)

　　{

　　int d, i, j, temp;

　　for(d = n/2;d >= 1;d = d/2)

　　{

　　for(i = d; i < n;i++)

　　{

　　temp = a[i];

　　for(j = i - d;(j >= 0) && (a[j] > temp);j = j-d)

　　{

　　a[j + d] = a[j];

　　}

　　a[j + d] = temp;

　　}

　　}

　　}

编辑本段希尔排序的AS3实现

　　//需要排序的 数组

　　var arr:Array=[7,5,8,4,0,9];

　　var small:int;//最小下标

　　var temp:int;

　　for (var i:int=0; i<arr.length; i++) {

　　small=i;

　　for (var j:int=i+1; j<arr.length+1; j++) {

　　if (arr[j]<arr[small]) {

　　small=j;

　　}

　　}

　　if (small!=i) {

　　temp=arr[i];

　　arr[i]=arr[small];

　　arr[small]=temp;

　　}

　　trace(arr[i]);

　　}

编辑本段希尔排序的PHP实现

　　function shell_sort(&$arr)

　　{

　　if(!is_array($arr))return;

　　$n=count($arr);

　　for ($gap = $n / 2; $gap > 0; $gap /= 2)

　　for ($i = $gap; $i < $n; ++$i)

　　for ($j = $i - $gap; $j >= 0 && $arr[$j + $gap] < $arr[$j]; $j -= $gap)

　　{

　　$temp = $arr[$j];

　　$arr[$j] = $arr[$j + $gap];

　　$arr[$j + $gap] = $temp;

　　}

　　}