阅读 355

排序算法——选择排序系列及性能测试

初识选择排序

选择排序是一种和冒泡排序一样简单的排序算法。它的思想非常简单,假设数组大小为n,每次从数组的待排序部分中选出一个最小的元素,放到数组最左侧,n轮筛选后,数组就整体有序了。

图解如下

假设准备对如下数组进行选择排序

先对数组的待排序部分进行遍历,选出最小的元素为1,将1放到数组最左侧

第二轮,对剩下的部分进行遍历,选出最小的元素为2,将2放到最左侧(和4交换)

如此以来,第三轮选出的元素是3,第四轮选出的是4....经过9轮选择后,数组整体有序

它的代码实现也非常简单

	public void selectSort(int[] array) {
		for (int i = 0; i < array.length; i++) {
			int minPos = i;
			for (int j = i + 1; j < array.length; j++) {
				if (array[minPos] > array[j]) {
					minPos = j;
				}
			}
			swap(array, i, minPos);
		}
	}
复制代码

优化思路

思路一

双向选择

选择排序的优化思路比较有限,根据双向冒泡的优化经验,我们可以一轮遍历选出一个最大值和一个最小值,从而提高筛选的效率。

写成代码如下

	public void selectSortDual(int[] array) {
		int leftBorder = 0;
		int rightBorder = array.length - 1;
		while (leftBorder < rightBorder) {
			int minPos = leftBorder;
			int maxPos = leftBorder;
			for (int j = leftBorder + 1; j <= rightBorder; j++) {
				if (array[minPos] > array[j]) {
					minPos = j;
				}
				if (array[maxPos] < array[j]) {
					maxPos = j;
				}
			}
			swap(array, leftBorder, minPos);
            /* 下面的交换要注意,若恰好maxPos等于leftBorder,由于上面已经将leftBorder下标的元素交换到minPos了 */
			if (maxPos == leftBorder) {
				/* 若恰好maxPos为leftBorder,则下面对maxPos的交换要与minPos进行 */
				swap(array, rightBorder, minPos);
			} else {
				swap(array, rightBorder, maxPos);
			}
			leftBorder++;
			rightBorder--;
		}
	}
复制代码

思路二

堆排序

其实,堆排序也是选择排序的一个变种。堆排序需要先对数组进行建堆(大顶堆或小顶堆),然后每次将堆顶元素和堆尾元素进行交换,随后将堆尾元素在逻辑上从堆中剔除,对剩余部分的堆进行调整,再将堆顶元素和当前堆尾元素交换,以此类推。每一轮排序都会将堆顶元素追加到数组末端的有序序列中,而堆顶元素就是每一轮选出来的最大或最小值,所以堆排序也属于选择排序。

首先对堆进行一个简单的介绍。堆的本质就是一棵完全二叉树。而大顶堆,指的是堆顶元素(二叉树的根节点)要大于其左右子树的任意节点,而其余的每个非叶子节点的值,也要大于其左右子树的任意节点。下图即是一个大顶堆的逻辑结构图

可以看到堆顶元素9要大于其左右子节点8和7,节点8要大于其左右子节点4和3,7要大于其左右子节点5和6,4要大于其左右子节点1和2。这就使得堆顶元素是最大的元素。而二叉堆在实际使用中,常常以数组的形式进行存储,如下所示

紫色的数字表示元素在数组中的下标。堆从第一层开始,每一层从左往右编号,即是其在数组中存储的位置。容易得到如下的关系:

若堆中的一个节点在数组中的下标为n,若其有左右子节点,则

左子节点的下标为:2n + 1

右子节点的下标为:2n + 2

若其有父节点,则父节点的下标为:(n - 1) / 2

既然堆可以用数组的形式进行存储和表示,那么就可以对数组进行建堆,然后执行堆排序。堆排序的关键在于对初始数组进行建堆,以及交换了堆顶元素和堆尾元素后的调整

图解如下

假设准备对如下数组进行堆排序

先进行建堆操作(建大顶堆),根据数组,先将数组看成一个二叉树

建堆的过程如下:从下往上,先找到第一个非叶子节点(没有任何子节点的节点,上图就是8),从这个节点开始,对所有非叶子节点依次进行下沉处理(向下调整)。下沉指的是,将节点与其子节点进行比较,若节点的值小于子节点中的较大者,则交换之。处理节点8,先把节点8及其子节点看成一个堆(局部堆),调整,以使这个局部堆满足大顶堆的特性。发现节点8不需要处理。

接着往前处理,到节点2,发现它比它的子节点要小,而子节点中的较大者是9,则交换2和9

接着处理节点4,发现它小于8,则交换它和8

注意下沉处理要下沉到尽可能底部的位置,4和8交换完后,继续处理4,发现4比它的子节点6要小,则交换4和6

接着处理1,发现1小于9,则交换之

继续处理1,发现1小于7,交换之

如此以来,建堆操作完成,观察可知,现在的堆已经符合大顶堆的特性

建堆完毕后,执行如下操作:将堆顶元素和堆尾元素交换,然后将堆尾元素在逻辑上从堆中删除,将剩余元素看成一个堆,对堆顶元素进行向下调整,使其成为一个大顶堆。然后又将堆顶元素和当前堆的堆尾元素交换,把堆尾元素从堆中删除,对剩余元素继续调整.....如此,即完成排序。

图解如下

首先,建堆完毕后的数组状态如下

将堆顶元素和堆尾元素交换,即9和4交换

交换完毕后,将堆尾元素9在逻辑上从堆中删除。而剩余元素组成的堆,由于堆顶发生了变化,显然不满足大顶堆的性质,于是对新的堆顶进行向下调整

节点4比其子节点中的较大者8,要小,于是交换之

!

继续调整节点4,发现其比子节点6要小,则交换之

继续调整节点4,发现其只有一个左子节点3,且4大于3,则调整完毕(节点9已经在逻辑上从堆中移除,即堆中不再包含节点9)

剩余的元素组成的堆已符合大顶堆的性质

接着,继续将堆顶元素和当前堆的堆尾元素交换,即交换8和3

然后将节点8从堆中剔除掉,对当前堆顶元素3进行向下调整,发现只需要交换3和7,调整完毕后结果为

接着交换堆顶和堆尾,即交换7和2

调整堆

交换堆顶和堆尾

调整堆

.....以此类推,最终数组有序

由此可见,堆排序的关键在于建堆,以及对节点的向下调整

写成代码如下

	public void heapSort(int[] array) {
		/* 先进行建堆 */
		buildHeap(array);
		/* 后执行循环 */
		for (int i = array.length - 1; i >= 0 ; i--) {
			/* 将堆顶元素和当前堆尾元素交换 */
			swap(array, 0, i);
			/* 调整堆 */
			adjustDown(array, 0, i - 1);
		}
	}

	/**
	 * 对数组进行建堆
	 * **/
	private void buildHeap(int[] array) {
		/* 从数组最右侧往左,即从堆的最下面往上,找到第一个非叶子节点, 对其进行向下调整 */
		/* 第一个非叶子节点,也就是最后一个节点的父节点 */
		/* 第一个非叶子节点之前的所有节点,都是非叶子节点了,都需要依次进行向下调整 */
		int firstNonLeafNode = (array.length - 1) / 2;
		for (int i = firstNonLeafNode; i >= 0 ; i--) {
			/* 对每个非叶子节点,进行向下调整 */
			adjustDown(array, i, array.length - 1);
		}
	}

	/**
	 * 对某个节点,进行向下调整
	 * @param targetPos 待调整的节点(数组下标)
	 * @param end    堆的终止位置(数组下标)
	 * @param array 堆的数组表示
	 * **/
	private void adjustDown(int[] array, int targetPos, int end) {
		int leftSonPos;
		/* 当左儿子没有超出堆的范围时,执行循环 */
		while ((leftSonPos = 2 * targetPos + 1) <= end) {
			/* 若右儿子存在,则选出左右儿子中较大者,否则则选左儿子 */
			int maxSonPos = leftSonPos + 1 <= end ?
					array[leftSonPos] > array[leftSonPos + 1] ? leftSonPos : leftSonPos + 1
					: leftSonPos;
			if (array[maxSonPos] > array[targetPos]) {
				swap(array, maxSonPos, targetPos);
				targetPos = maxSonPos;
			} else {
				/* 子儿子没有比target大的, 则调整结束 */
				break;
			}
		}
	}
复制代码

注意,向下调整的过程,就是将需要调整的节点,下沉到合适的位置,考虑到先前插入排序时的优化,这里也可以采用单向赋值的方式,以避免频繁交换造成的性能开销。

性能测试

对选择排序系列的算法进行性能测试,结果如下

可见堆排序的性能完爆简单选择排序

扩展:堆排序的应用

Top K问题

从海量数据中筛选出前K个最大的数据

因为数据量特别大,对全部数据进行排序再取前K个数显然是不现实的,并且第K个以后的数是没有必要进行排序的,对K以后的数据进行排序显然浪费了性能。我们观察一下堆排序的性质,发现一个特点,无论大顶堆小顶堆,堆顶的元素总是最大的,或者最小的。如果一个大顶堆有K个元素,则堆顶的元素是这K个中最大的;如果一个小顶堆有K个元素,则堆顶的元素是这K个中最小的。那么假设一共有100个数据,要求找出前K个最大的数,可以这样想,我先取前K个元素,我只要知道当前这K个元素中最小的值,之后每次取一个新的元素,拿新元素和这个最小值比,若新元素小于这个最小值,说明新元素小于这所有的K个元素,则新元素不可能是前K个最大的数,直接抛弃之。若新元素比这个最小值大,那么把最小值剔除,换上这个新元素,再选出当前K个元素的最小值等待后续的比较。根据这个思路,只需要构建一个大小为K的小顶堆。先从海量数据中取前K个数,构建一个小顶堆。然后对K之后数,进行遍历,每次取一个数,和小顶堆的堆顶比较,若小于堆顶,则直接丢弃;若大于堆顶,则将该数和堆顶交换,并向下调整堆,维持其小顶堆的特征。因为只需要和堆顶这一个元素比较,并且小于堆顶的情况直接丢弃,只有大于堆顶的情况才需要调整堆,所以使得能够以较高的效率找到前K个最大的数,代码实现如下

	/**
	 * @param array 待查找的数组
	 * @param k 找到前K个最小的数
	 * **/
	public int[] findTheSmallestElements(int[] array, int k) {
		return findTheMostElements(array, k, false);
	}


	/**
	 * @param array 待查找的数组
	 * @param k 找到前K个最大的数
	 * **/
	public int[] findTheBiggestElements(int[] array, int k) {
		return findTheMostElements(array, k, true);
	}

	/**
	 * 找出前K个最大的,或者前K个最小的数
	 * @param biggest 是否是找最大的
	 * **/
	private int[] findTheMostElements(int[] array, int k, boolean biggest) {

		/* 找前K个最大的,则要建小顶堆; 找前K个最小的, 则要建大顶堆
		 * false 表示小顶堆
		 * true 表示大顶堆
		  * */
		boolean heapType = !biggest;

		/* 对前k个元素,建堆 */
		buildHeap(array,k - 1, heapType);
		/* 从第 k + 1 个元素 (下标为k) 开始遍历 */
		for (int i = k; i < array.length; i++) {
            /* 当前元素是否需要插入到前k个元素组成的堆中 */
			boolean needInsert = biggest ? array[i] > array[0] : array[i] < array[0];
			if (needInsert) {
				/* 若需要插入,则插入堆 */
				swap(array, 0, i);
				/* 调整堆,使其仍然是小顶堆/大顶堆 */
				adjustDown(array, 0, k - 1, heapType);
			}
			/* 否则,直接抛弃 */
		}
		int[] topKElements = new int[k];
        /* 取array数组的前k个元素,作为结果 */
		System.arraycopy(array, 0, topKElements, 0, k);
		return topKElements;
	}

	/**
	 * @param endPos 建堆的终止位置
	 * @param biggestTop 是否建大顶堆
	 * **/
	private void buildHeap(int[] array,int endPos, boolean biggestTop) {
		int firstNonLeafPos = (endPos - 1) / 2;
		for (int i = firstNonLeafPos; i >= 0 ; i--) {
			adjustDown(array, i, endPos, biggestTop);
		}
	}

	/**
	 * @param biggestTop 是否建大顶堆
	 * **/
	private void adjustDown(int[] array, int targetPos, int endPos, boolean biggestTop) {
		int leftSonPos;
		while ((leftSonPos = 2 * targetPos + 1) <= endPos) {
			int maxSonPos = leftSonPos, minSonPos = leftSonPos;
			if (leftSonPos + 1 <= endPos) {
				maxSonPos = array[leftSonPos] > array[leftSonPos + 1] ?
						(minSonPos = leftSonPos + 1) - 1 :
						leftSonPos + 1;
			}
			boolean needSwap = biggestTop ?
					array[maxSonPos] > array[targetPos] :
					array[minSonPos] < array[targetPos];
			int swapPos = biggestTop ? maxSonPos : minSonPos;
			if (needSwap) {
				swap(array, targetPos, swapPos);
				targetPos = swapPos;
			} else {
				break;
			}
		}
	}
复制代码

优先级队列

队列在生活中随处可见。坐地铁时排队等车,在食堂排队打饭,去银行办理业务时也要取号排队。队列的本质就是一堆人,需要执行某个动作。最简单普通的队列就是按照先来后到的顺序依次排队,依次接收服务。但在某些场景下需要对排队的人进行一些优先级的设置,比如银行办理业务时,VIP客户的排队优先级就要高于普通客户,再比如,去食堂打饭时,如果有一个人已经10天没吃饭了,马上就要饿死了,是不是应该让他优先打饭,保证他能活过来。这些场景下,普通的队列就太死板了,无法满足需求,于是就有了优先级队列。优先级队列中的元素,不是严格按照先来后到的顺序排队的,而是优先级的高的元素,总是会排到优先级低的元素的前面,优先级相同的元素,再按先来后到的顺序排队。那么堆,这一数据结构,就能够满足这样的需求,因为它总是会把最大的,或者最小的元素,放在堆顶(数组的最前面)。

一个队列有2个基本操作:入队和出队

入队:一个人加入到队列中,进行排队

出队:轮到某个人办事了,将其移出队列

用堆的结构来表示,如下。先来一个优先级为1的人,进行排队

随后,来了一个优先级为9的人

显然不满足大顶堆的性质,则对新来的9,进行调整,此时应该是向上调整,交换1和9即可

此时又来了一个6,发现仍然满足大顶堆的特性,则不做调整

若此时,进行出队,则直接取出堆顶元素,节点9接受服务,数组变成了

对应的堆的逻辑结构就变成了

发现不满足大顶堆的特性,则进行调整,交换1和6即可

每次出队,都取数组的首元素,即堆顶元素,即能保证每次出队都是当前优先级最高的元素

其核心部分的逻辑为:

  • 入队时,新加入的元素追加到数组末尾,也即堆尾,并需要对其进行向上调整,以满足大顶堆的性质。

  • 出队时,移除数组的首元素,将剩余部分元素看成一个新的堆,并重新建堆

在此就不给出具体的代码实现了,有兴趣的读者可以自行尝试