排序-shell排序

在插入排序中,所有的元素都是挨个和前一个元素进行比较,并置换位置。所以交换的次数为N的平方级别。极端情况下,如果最小元素在最右侧,那么需要逐个和前面元素进行置换。如果将比较的间隔增大,那么会减少移动次数,然后逐次降低比较间隔。

于是比较的间隔的序列如下 h = 3*h+1。

代码如下:

 1 #include <iostream>
 2
 3 using namespace std;
 4
 5 void change(int *p,int pos1,int pos2);
 6 void shellSort(int *p,int length);
 7 void print(int *p,int length);
 8
 9 int main()
10 {
11     int p[] = {2,5,3,11,89,76,24,33,15};
12     shellSort(p,sizeof(p)/sizeof(int));
13     print(p,sizeof(p)/sizeof(int));
14     cout << "Hello world!" << endl;
15     return 0;
16 }
17
18 void print(int *p,int length)
19 {
20     for(int i=0;i<length;i++)
21         cout << p[i] << endl;
22 }
23
24 void shellSort(int *p,int length)
25 {
26     int h = 0;
27     while(h<length/3)
28     {
29         h=3*h+1;
30     }
31     while(h>=1)
32     {
33         for(int i=1;i<length;i++)
34         {
35             for(int j=i;j>=h&&p[j]<p[j-1];j-=h)
36             {
37                 change(p,j,j-h);
38             }
39         }
40         h = h/3;
41     }
42 }
43
44 void change(int *p,int pos1,int pos2)
45 {
46     if(pos1 == pos2)
47     {
48         return;
49     }
50     int temp=p[pos1];
51     p[pos1] = p[pos2];
52     p[pos2] = temp;
53 }

目前要理解shell 排序的性能仍然是个挑战,这个需要靠专家努力,但最重要的结论就是,运行时间不到N的平方级别。

时间: 2024-11-03 01:34:51

排序-shell排序的相关文章

希尔排序Shell sort

希尔排序Shell Sort是基于插入排序的一种改进,同样分成两部分, 第一部分,希尔排序介绍 第二部分,如何选取关键字,选取关键字是希尔排序的关键 第一块希尔排序介绍 准备待排数组[6 2 4 1 5 9] 首先需要选取关键字,例如关键是3和1(第一步分成三组,第二步分成一组),那么待排数组分成了以下三个虚拟组: [6 1]一组 [2 5]二组 [4 9]三组 看仔细啊,不是临近的两个数字分组,而是3(分成了三组)的倍数的数字分成了一组, 就是每隔3个数取一个,每隔三个再取一个,这样取出来的数

Java常见排序算法之Shell排序

在学习算法的过程中,我们难免会接触很多和排序相关的算法.总而言之,对于任何编程人员来说,基本的排序算法是必须要掌握的. 从今天开始,我们将要进行基本的排序算法的讲解.Are you ready?Let‘s go~~~ 1.排序算法的基本概念的讲解 时间复杂度:需要排序的的关键字的比较次数和相应的移动的次数. 空间复杂度:分析需要多少辅助的内存. 稳定性:如果记录两个关键字的A和B它们的值相等,经过排序后它们相对的位置没有发生交换,那么我们称这个排序算法是稳定的. 否则我们称这个排序算法是不稳定的

Shell排序和二叉树排序

Shell排序 #include<iostream> using namespace std; void Print(int *list, int len); void ShellSort(int *list, int *list2, int len, int gap); void ShellSort(int *list, int *list2, int len, int gap) { int cc = len / gap + (len%gap != 0); int l = 0; for (i

数据结构之shell排序

#SIZE  10 //直接插入排序 void insert_sort(){ int i,j; int array[SIZE+1]; array[]={0,12,23,11,55,2,34,18,20,48,22}; for(i=2;i<=SIZE;i++){ array[0]=array[i]; j=i-1; while(array[0]<array[j]){ array[j+1]=array[j]; j--; } array[j+1]=array[0]; } } //折半插入排序 void

shell排序算法

今天看<The C Programming Language>的时候看到了shell排序算法, /* shellsort: sort v[0]...v[n-1] into increasing order */ void shellsort(int v[], int n) { int gap, i, j, temp; for (gap = n/2; gap > 0; gap /= 2) for (i = gap; i < n; i++) for (j=i-gap; j>=0

shell排序

shell排序是插入排序的改进方法,但是不稳定 #include<iostream> using namespace std; void insertDxSort(int *data,int start,int end,int dx) { //以增量dx进行增量排序 int key=0; int j=0; for(int i=start+dx;i<=end;i+=dx) { key=data[i]; j=i-dx; while(j>=start&&data[j]&g

直接插入排序、折半插入排序、Shell排序、冒泡排序,选择排序

一.直接插入排序 稳定,时间复杂度:最好O(n).最差O(n^2).平均O(n^2).空间复杂度O(1) void InsertSort(int L[], int n) { int i, j,key; for (i = 1; i<n; i++) if(L[i] < L[i-1])//须要将L[i]插入到有序表L[0...i-1] { key = L[i]; for(j = i-1; j >= 0 && key < L[j]; j--)//后移 L[j+1] = L[

js实现shell排序

//shell排序配插入排序function shell_insert_sort(arr){ var gap = arr.length; do{ gap = parseInt(gap/3) + 1; console.log(gap); for(var i = gap; i < arr.length; i+= gap){ var tmp = arr[i]; for( var j = i - gap; j >= 0 && tmp < arr[j]; j -= gap){ ar

插入排序与shell排序(希尔排序)

1 .插入排序的过程如同我们平时打扑克牌取牌插入的过程,不断将取出的扑克牌插入已经排好的地方. 插入排序过程初始有序区间大小为1,取出无序区间的首元素,查找有序区间的合适位置,进行插入.不断重复上述过程,即可完成操作. 图解示例 1 //插入排序 2 //karllen @2015 3 void insertSort() 4 { 5 int i ,j ,temp; 6 for(i = 1;i<n;++i) //从第二个元素开始插入 7 { 8 temp = a[i]; //a[i]会被覆盖,临时