Shell排序（希尔排序）

Shell排序（希尔排序）
希尔排序(Shell Sort)是插入排序的一种。是针对直接插入排序算法的改进。该方法又称缩小增量排序，因DL．Shell于1959年提出而得名。
先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组。所有距离为dl的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量dt=1(dt<dt-l<；…<d2<d1），即所有记录放在同一组中进行直接插入排序为止。该方法实质上是一种分组插入方法。

1. 工作原理
先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组。所有距离为dl的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量dt=1(dt<dt-l<；…<d2<d1），即所有记录放在同一组中进行直接插入排序为止。该方法实质上是一种分组插入方法。
1.1 将n个元素个数列分为d1个小组，在每个小组内按直接插入法排序；
1.2 在第x步，分组个数取 d[x+1] = dx/2 {9，5，3，2，1}；相临两组之间的对应元素进行比较，如果ai>aj，则交换它们的位置；
1.3 当dK = 1的循环过程完成后，排序过程结束。


2. 时间复杂度


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


Shell排序的执行时间依赖于增量序列。
好的增量序列的共同特征：
① 最后一个增量必须为1；
② 应该尽量避免序列中的值(尤其是相邻的值)互为倍数的情况。
有人通过大量的实验，给出了较好的结果：当n较大时，比较和移动的次数约在nl.25到1.6n1.25之间。


Shell排序的时间性能优于直接插入排序
希尔排序的时间性能优于直接插入排序的原因：
①当文件初态基本有序时直接插入排序所需的比较和移动次数均较少。
②当n值较小时，n和的差别也较小，即直接插入排序的最好时间复杂度O(n)和最坏时间复杂度0()差别不大。
③在希尔排序开始时增量较大，分组较多，每组的记录数目少，故各组内直接插入较快，后来增量di逐渐缩小，分组数逐渐减少，而各组的记录数目逐渐增多，但由于已经按di-1作为距离排过序，使文件较接近于有序状态，所以新的一趟排序过程也较快。
因此，希尔排序在效率上较直接插入排序有较大的改进。


3. 算法稳定性
不稳定的排序算法
由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的。

4. 代码实现

void sort_shell(int arr[], int len)
{
	for (int d = len / 2; d > 0; d /= 2)
	{
		for (int i = d; i < len; i++)
		{
			int tmp = arr[i];
			int j = i - d;
			for (j = i - d; j >= 0 && arr[j] > tmp; j -= d)
			{
				arr[j + d] = arr[j];
			}
			arr[j + d] = tmp;
		}
	}
}

5. Shell排序算法的其他变种

/*
*D.Shell最初的算法。
*/
int shellsortSh(int arr[], int n)
{
	int op = 0;
	int h, i, j, temp;
	for (h = n / 2; h > 0; h = h / 2)
	{
		for (i = h; i < n; i++)
		{
			temp = arr[i];
			for (j = i - h; j >= 0 && arr[j] > temp; j -= h)
			{
				arr[j + h] = arr[j];
				op++;
			}
			arr[j + h] = temp;
			op++;
		}
	}
	return op;
}

/*
*Lazarus-Frank 算法，1960 年发表
*原为在必要时加1使所有增量都为奇数，现修正为减1。
*/
int shellsortLF(int arr[], int n)
{
	int op = 0;
	int h, i, j, temp;
	for (h = n / 2; h > 0; h = h / 2)
	{
		if (h % 2 == 0)
			h--;
		for (i = h; i < n; i++)
		{
			temp = arr[i];
			for (j = i - h; j >= 0 && arr[j]>temp; j -= h)
			{
				arr[j + h] = arr[j];
				op++;
			}
			arr[j + h] = temp;
			op++;
		}
	}
	return op;
}

/*
*1965年Papernov-Stasevich给出了数学证明。
*/
int shellsortHb(int arr[], int n)
{
	int op = 0;
	int h, i, j, temp;
	for (h = 1; h <= n / 4; h = h * 2 + 1);
	for (; h > 0; h = (h - 1) / 2)
	{
		/*h=1,3,7,15,31...2^i-1*/
		for (i = h; i < n; i++)
		{
			temp = arr[i];
			for (j = i - h; j >= 0 && arr[j] > temp; j -= h)
			{
				arr[j + h] = arr[j];
				op++;
			}
			arr[j + h] = temp;
			op++;
		}
	}
	return op;
}

// Papernov-Stasevich 算法，1965年发表
int shellsortPS(int arr[], int n)
{
	int op = 0;
	int h, i, j, temp;
	for (h = 2; h <= n / 4; h = h * 2 - 1);
	for (; h > 1;)
	{
		h = (h == 3) ? 1 : (h + 1) / 2;
		/*h=1,3,5,9,17,33...2^i+1*/
		for (i = h; i<n; i++)
		{
			temp = arr[i];
			for (j = i - h; j >= 0 && arr[j] > temp; j -= h)
			{
				arr[j + h] = arr[j];
				op++;
			}
			arr[j + h] = temp;
			op++;
		}
	}
	return op;
}

// Knuth 算法，他建议在 n<1000 时使用
int shellsortKn(int arr[], int n)
{
	int op = 0;
	int h, i, j, temp;
	for (h = 1; h <= n / 9; h = h * 3 + 1);
	for (; h > 0; h = h / 3)
	{
		/*h=1,4,13,40,121,364...3*h+1*/
		for (i = h; i < n; i++)
		{
			temp = arr[i];
			for (j = i - h; j >= 0 && arr[j] > temp; j -= h)
			{
				arr[j + h] = arr[j];
				op++;
			}
			arr[j + h] = temp;
			op++;
		}
	}
	return op;
}

/*
*Pratt 算法，1971 年发表
*原为h=2^arr*3^q现修正为7^arr*8^q。
*/
int shellsortPr(int arr[], int n)
{
	int op = 0;
	int h, i, j, t, temp;
	int incs[28] = {
		262144, 229376, 200704, 175616, 153664, 134456,
		117649, 32768, 28672, 25088, 21952, 19208, 16807,
		4096, 3584, 3136, 2744, 2401, 512, 448, 392, 343,
		64, 56, 49, 8, 7, 1
	};
	for (t = 0; t < 28; t++)
	{
		h = incs[t];
		for (i = h; i < n; i++)
		{
			temp = arr[i];
			for (j = i - h; j >= 0 && arr[j] > temp; j -= h)
			{
				arr[j + h] = arr[j];
				op++;
			}
			arr[j + h] = temp;
			op++;
		}
	}
	return op;
}

// Sedgewick 算法，1982 年发表
int shellsortSe82(int arr[], int n)
{
	int op = 0;
	int h, i, j, t, temp;
	for (t = 1; t*t <= n / 4; t += t);
	for (h = n / 4; t > 0; t /= 2, h = t*t - (3*t) / 2 + 1)
	{
		/*h=1,8,23,77,281,1073,4193,16577,65921,262913,1050113...4^i+3*2^(i-1)+1*/
		for (i = h; i < n; i++)
		{
			temp = arr[i];
			for (j = i - h; j >= 0 && arr[j] > temp; j -= h)
			{
				arr[j + h] = arr[j];
				op++;
			}
			arr[j + h] = temp;
			op++;
		}
	}
	return op;
}

// Gonnet 算法，发表于 1991 年
int shellsortGo(int arr[], int n)
{
	int op = 0;
	int h, i, j, temp;
	for (h = n; h > 1;)
	{
		h = (h < 5) ? 1 : (h * 5 - 1) / 11;
		for (i = h; i < n; i++)
		{
			temp = arr[i];
			for (j = i - h; j >= 0 && arr[j] > temp; j -= h)
			{
				arr[j + h] = arr[j];
				op++;
			}
			arr[j + h] = temp;
			op++;
		}
	}
	return op;
}

// Incerpj-Sedgewick 算法，1985 年发表
int shellsortIS(int arr[], int n)
{
	int op = 0;
	int h, i, j, t, temp;
	int incs[16] = {/*a1=3,a2=7,a3=16,a4=41,a5=101*/
		1391376,/*a1*a2*a3*a4*a5*/
		463792,/*a2*a3*a4*a5*/
		198768,/*a1*a3*a4*a5*/
		86961,/*a1*a2*a4*a5*/
		33936,/*a1*a2*a3*a5*/
		13776,/*a1*a2*a3*a4*/
		4592,/*a2*a3*a4*/
		1968,/*a1*a3*a4*/
		861,/*a1*a2*a4*/
		336,/*a1*a2*a3*/
		112,/*a2*a3*/
		48,/*a1*a3*/
		21,/*a1*a2*/
		7,/*a2*/
		3,/*a1*/
		1
	};
	for (t = 0; t < 16; t++)
	{
		h = incs[t];
		for (i = h; i < n; i++)
		{
			temp = arr[i];
			for (j = i - h; j >= 0 && arr[j] > temp; j -= h){
				arr[j + h] = arr[j];
				op++;
			}
			arr[j + h] = temp;
			op++;
		}
	}
	return op;
}