希尔排序

一）算法介绍

希尔排序是一种缩小增量的排序算法，也是插入排序的升级版，属于不稳定排序。

基本操作：希尔排序是按增量分组，对每一组数据再进行插入排序，随着增量逐渐减少，每组的关键词越来越多，当增量为1时，数据整合成一组，算法便终止了。

不稳定排序：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；

 

二）算法原理

基本原理：

第一步：先把数据分成两组、再对两组数据进行插入排序，将已排序的数据合并。

第二步：再次把数据分成4组，再对4组数据分别进行插入排序，将已排序数据合并。

第三步：不断重复进行对数据分组、再插入排序，再把数据合并这三个步骤，直到数据已排序完成。

 

算法步骤图解：

源数据：int[] nums = {9, 1, 2, 5, 7, 4, 8, 6, 3, 5};

第一遍排序：

先把源数据分成2组，每5个元素为1组，分别为[9, 1, 2, 5, 7]和[4, 8, 6, 3, 5]，对两组进行插入排序。

[9, 1, 2, 5, 7]、[4, 8, 6, 3, 5]结果为：[4, 1, 2, 3, 5]、[9, 8, 6, 5, 7]

合并排序结果为：[4, 1, 2, 3, 5, 9, 8, 6, 5, 7]

 

第二遍排序：

再次把数据分成每2个1组，分别为[4, 1]、[2, 3]、[5, 9]、[8, 6]、[5, 7]，对每组进行插入排序。

[4, 1]、[2, 3]结果为：[2, 1]、[4, 3]

[4, 3]、[5, 9]结果为：[4, 3]、[5, 9]

[5, 9]、[8, 6]结果为：[5, 6]、[8, 9]

[8, 9]、[5, 7]结果为：[5, 7]、[8, 9]

合并排序结果为：[2, 1, 4, 3, 5, 6, 5, 7, 8, 9]

 

第三遍排序：

再次把数据分每1个1组，分别为[2]、[1]、[4]、[3]、[5]、[6]、[5]、[7]、[8]、[9]，对每组进行插入排序。

[2]、[1]结果为：[1]、[2]

[2]、[4]结果为：[2]、[4]

[4]、[3]结果为：[3]、[4]

[4]、[5]结果为：[4]、[5]

[5]、[6]结果为：[5]、[6]

[6]、[5]结果为：[5]、[6]

[6]、[7]结果为：[6]、[7]

[7]、[8]结果为：[7]、[8]

[8]、[9]结果为：[8]、[9]

合并排序(最终)结果为：[1, 2, 3, 4, 5, 5, 6, 7, 8, 9]

 

算法排序效果图：

 

算法复杂度：

最差情况：T(n) = O(Nlog2N)

最好情况：T(n) = O(Nlog2N)

O(log2N)的含义：将一个数据集分成两半，然后将分开的每一半再分成两半，依此类推。

O(Nlog2N)的含义：将一个数据集分成两半，然后将分开的每一半再分成两半，依此类推，在此过程中同时遍历比较每一半数据。

 

三）算法源码

步骤简介：先对数据进行分组，每一次分成gap组，再对gap组数据进行插入排序，再把排序好的数据合并，一直重复这几个步骤，直到排序完成。

public static int[] hillRankingSort(int[] nums) {
	if (nums == null) {
		return null;
	}
		
	int len = nums.length;
	int number, gap = len / 2; // 把数组分成gap组
	while (gap > 0) {
		for (int i = gap; i < len; i++) { // 进行插入排序
			number = nums[i];
			int index = i - gap;
			while (index >= 0 && nums[index] > number) {
				nums[index + gap] = nums[index];
				index -= gap;
			}
			nums[index + gap] = number;
		}
		gap /= 2; // 对数组再次重新分组
	}
		
	return nums;
}

 

识别二维码关注个人微信公众号

本章完结，待续，欢迎转载！
 
本文说明：该文章属于原创，如需转载，请标明文章转载来源！