排序算法——希尔排序图文详解

文章目录

  • 希尔排序
    • 基本思想
    • 整体插入思想
      • 预排序
      • 结论
    • 代码实现
    • 实现代码
    • 直接插入排序与希尔排序的效率比较
        • 测试代码:
    • 时间复杂度

希尔排序

注1:本篇是基于对直接插入排序法的拓展,如果对直接插入法不了解,建议先看看直接插入排序

注2:本篇统一采用升序排序

基本思想

  • 希尔排序法又称缩小增量法。

  • 希尔排序其实是直接插入排序的改进。

  • 基本思想是先选定一个整数gap,把待排序文件中所有记录分成数组,所有距离为gap的记录分在同一组内,并对每一组内的记录进行排序。然后缩小gap,重复上述步骤,当gap == 1时,所有记录在统一组内已经排好序。

整体插入思想

  • 在直接插入排序中,我们知道最坏的情况是待排序列降序逆序的情况,如序列:8,7,6,5,4,3,2,1,这时时间复杂度为O(N2),显然效率不高
  • 而希尔排序的思想,就是先对待排序列进行预排序,使待排序列接近有序。我们知道,当待排序列接近有序时,直接插入排序法的时间复杂度接近O(N),效率很高,因此预排序过后,就使用直接插入排序法,从而提高了效率。

预排序

  • 预排序实际上也是直接插入排序,但是是将待排序列分成数组来排

  • 根据基本思想,规定间隔为gap的数为一组

  • 我们以数组{9,8,7,6,5,4,3,2,1},gap = 3为例:

    • 每gap为一组:

      排序算法——希尔排序图文详解_第1张图片

    • 对第一组排序:

      排序算法——希尔排序图文详解_第2张图片

    • 对第二组排序:

      排序算法——希尔排序图文详解_第3张图片

    • 对第三组排序:

      排序算法——希尔排序图文详解_第4张图片

  • 这时相较于最开始,待排序列更加接近于有序,此时我们不断缩小gap,不断预排序,直到最后gap == 1时最后使用一次直接插入排序(gap == 1时的直接插入排序实际上就是最原始的直接插入排序),使待排序列有序

  • 又例如:

    排序算法——希尔排序图文详解_第5张图片

结论

  • 希尔排序实际上就是多组间隔为gap的预排序,gap由大到小
  • gap越大,大的数能越快到后面,小的数能越快到前面
  • gap越大,预排序之后待排序列越不接近于有序
  • gap越小,预排序之后待排序列越接近于有序
  • 当gap == 1时,预排序实际上就是对整个序列进行直接插入排序,排完后序列即有序
  • 因此,最后一次预排序,gap必须为1.

代码实现

  • 对每间隔gap的一组数据进行排序,本质上就是直接插入排序,故不作过多讲解

    int end;
    int temp = nums[end + gap];
    while (end >= 0)
    {
        if (temp < nums[end])
        {
            nums[end + gap] = nums[end];
            end -= gap;
        }
        else
            break;
    }
    nums[end + gap] = temp;
    
  • 对多组间隔为gap的数据进行预排序

    • 以这张图为例:

      排序算法——希尔排序图文详解_第6张图片

    • 我们上面的步骤只是将间隔为pap的一组数据进行了排序,但待排序列不止一组间隔为gap的数据,因此我们要做到将所有间隔为gap的每组数据都进行排序。

    • 怎么实现呢?可能最容易想到的是分别将每组间隔为gap的数据进行排序,例如上面分别对第一组,第二组,第三组排序,但是这样做效率不高,且操作复杂。因此我们要换一种想法,即把间隔为gap的数据同时排序

    • 如图:

      排序算法——希尔排序图文详解_第7张图片

    for (int i = 0; i < numsSize - gap; i++)
    {
        int end = i;
        int temp = nums[end + gap];
        while (end >= 0)
        {
            if (temp < nums[end])
            {
                nums[end + gap] = nums[end];
                end -= gap;
            }
            else
                break;
        }
        nums[end + gap] = temp;
    }
    
  • 最后还要不断缩小gap的值,直到gap == 1

    int gap = numsSize;
    while (gap > 1)
    {
        gap /= 2;	//不断缩小gap
        /*
        	也可以写成 gap = gap / 3 + 1;
        	总之,必须要保证最后一次gap == 1
        */
    
        for (int i = 0; i < numsSize - gap; i++)
        {
            int end = i;
            int temp = nums[end + gap];
            while (end >= 0)
            {
                if (temp < nums[end])
                {
                    nums[end + gap] = nums[end];
                    end -= gap;
                }
                else
                    break;
            }
            nums[end + gap] = temp;
        }
    }
    

实现代码

void ShellSort(int* nums, int numsSize)
{
	int gap = numsSize;
	while (gap > 1)
	{
		gap /= 2;
		for (int i = 0; i < numsSize - gap; i++)
		{
			int end = i;
			int temp = nums[end + gap];
			while (end >= 0)
			{
				if (temp < nums[end])
				{
					nums[end + gap] = nums[end];
					end -= gap;
				}
				else
					break;
			}
			nums[end + gap] = temp;
		}
	}
}

直接插入排序与希尔排序的效率比较

  • 看到希尔排序有三层循环,可能有小伙伴会疑惑希尔排序为什么会比直接插入排序快,这里我们先上测试代码,直观的来感受这两个排序算法之间的差距:

测试代码:

#include
#include
#include

//直接插入排序
void InsertSort(int* nums, int numsSize)
{
	for (int i = 0; i < numsSize - 1; i++)
	{
		int end = i;
		int temp = nums[end + 1];
		while (end >= 0)
		{
			if (temp < nums[end])
			{
				nums[end + 1] = nums[end];
				end--;
			}
			else
				break;
		}
		nums[end + 1] = temp;
	}
}

//希尔排序
void ShellSort(int* nums, int numsSize)
{
	int gap = numsSize;
	while (gap > 1)
	{
		gap /= 2;
		for (int i = 0; i < numsSize - gap; i++)
		{
			int end = i;
			int temp = nums[end + gap];
			while (end >= 0)
			{
				if (temp < nums[end])
				{
					nums[end + gap] = nums[end];
					end -= gap;
				}
				else
					break;
			}
			nums[end + gap] = temp;
		}
	}
}

int main()
{
	srand((unsigned int)time(NULL));
	
   //创建两个大小为N的数组
	const int N = 100000;
	int* a1 = (int*)malloc(sizeof(int) * N);
	int* a2 = (int*)malloc(sizeof(int) * N);
	
   //为数组赋随机值
	for (int i = 0; i < N; i++)
	{
		a1[i] = rand();
		a2[i] = a1[i];
	}
	
   /*
   	clock()函数可以记录当前时间
   	begin和end的差即排序算法运行的时间
   	注:时间的单位为毫秒(ms)
   */
	int beginl = clock();
	InsertSort(a1, N);
	int end1 = clock();

	int begin2 = clock();
	ShellSort(a2, N);
	int end2 = clock();

	printf("InsertSort:%d\n", end1 - beginl);
	printf("ShellSort:%d\n", end2 - begin2);

   //释放内存
	free(a1);
	free(a2);

	return 0;

}

测试结果:

排序算法——希尔排序图文详解_第8张图片

排序算法——希尔排序图文详解_第9张图片

  • 我们可以看到,当数据个数为十万个时,直接插入排序所需要的时间是的希尔排序的100多倍
  • 当数据个数为一百万个时,直接插入排序所需要的时间时希尔排序的2000倍、
  • 可见,数据越多,希尔排序的优势就越明显,节省点时间就越多

时间复杂度

  • 从上面的测试中,我们直观的感受到了相较于直接插入排序,希尔排序的优越性,那么具体的希尔排序的时间复杂度为多少呢?

  • 我们先来看最外层的循环:

    int gap = numsSize;
    while (gap > 1)
    {
        gap /= 2;
        …………
    }
    
    • 设最外层循环运行了x次,那么2x = numsSize,x = log2N,即最外层的时间复杂度为log2N
  • 再看里面两层循环:

    for (int i = 0; i < numsSize - gap; i++)
    {
        int end = i;
        int temp = nums[end + gap];
        while (end >= 0)
        {
            if (temp < nums[end])
            {
                nums[end + gap] = nums[end];
                end -= gap;
            }
            else
                break;
        }
        nums[end + gap] = temp;
    }
    
    • 当gap很大时,尽管有两层循环,但数据之间跳跃的很大,需要排序的次数很少,因此时间复杂度为O(N),例如这种情况:

      排序算法——希尔排序图文详解_第10张图片

    • 当gap很小时,尽管有两层循环,但此时数据已经接近有序,需要排序的次数也很少,因此时间复杂度也为O(N)。

  • 综上,希尔排序的时间复杂度为O(NLog2N)

  • 也可以认为时间复杂度为O(N1.3)

你可能感兴趣的:(排序算法,排序算法,算法,数据结构,c语言)