图解希尔排序(Shell Sort)

希尔排序的原理

希尔排序算法是突破时间复杂度的第一批算法之一。思想：对直接插入排序改进后可以增加效率

直接插入排序某些时候很高：

（1）记录本身就是基本有序的，只需要少量插入工作，就可完成整个集的排序

（2）记录比较少时

如何让待排序的记录个数较少呢？

 

希尔算法 

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>

void knPrint(int array[], int len)
{
	for (int i = 0; i < len; i++)
	{
		printf("%d ", array[i]);
	}
	printf("\n");
}

void swap(int array[], int i, int j)
{
	int temp = array[i];
	array[i] = array[j];
	array[j] = temp;
}

//插入排序算法 要点 1 拿出要插入的元素 2 符合条件的元素后移
void inertionSort000(int array[], int len)// O(n*n)
{
	int i = 0;
	int j = 0;
	int k = -1;
	int temp = -1;

	//{ 49, 38, 65, 97, 76, 13, 27, 48, 55, 4 };

	for (i = 1; i < len; i++)
	{
		k = i;//待插入位置
		temp = array[k];
		/
		for (j = i - 1; (j >= 0) && (array[j] > temp); j--)
		{
			array[j + 1] = array[j];	//元素后移
			k = j;						//k需要插入的位置
		}
		///
		array[k] = temp;//元素插入
	}
}
//先分组,再排序
void ShellSort(int array[], int len)
{
	int i = 0;
	int j = 0;
	int k = -1;
	int temp = -1;
	int gap = len;

	do
	{
		//业界统一实验平均最好情况 经过若干次后,收敛为1
		gap = gap / 3 + 1;	//分组间隔
		printf("------gap:%d------\n", gap);
		for (i = gap; i < len; i += gap)
		{
			k = i;
			temp = array[k];
			///
			for (j = i - gap; (j >= 0) && (array[j] > temp); j -= gap)
			{
				array[j + gap] = array[j];
				k = j;		//找到k要插入的位置
			}
			/
			array[k] = temp;//元素插入
		}
	} while (gap > 1);
}

int  main()
{
	int array[] = { 49, 38, 65, 97, 76, 13, 27, 48, 55, 4 };
	int len = sizeof(array) / sizeof(*array);
	knPrint(array, len);

	printf("------插入排序------\n");
    //inertionSort(array, len);
	knPrint(array, len);

	printf("------希尔排序------\n");
	ShellSort(array, len);
	knPrint(array, len);

	system("pause");
	return 0;
}

 

插入算法与希尔算法的比较

（1）希尔算法是在插入法的基础上进行的优化：分组。即分组的同时进行排序

（2）不断的调整增量，当增量=1时，就变成了插入法

（3）希尔算法是不稳定的

希尔算法代码中有3个循环，但为何突破了？

（1）每次问题的规模都缩减了三分之一

（2）每次分组的同时进行插入排序

 

希尔排序的复杂度分析：