排序四| 选择类排序(java实现)

选择类排序

选择排序的基本思想是：每一趟从 n-i+1 (i=1,2,…,n)个元素中选取一个关键字最小的元素作为有序序列中第 i 个元素。本节在介绍简单选择排序的基础上，给出了对其进行改进的算法——树型选择排序和堆排序。

简单选择排序

简单选择排序的基本思想非常简单，即：第一趟，从 n 个元素中找出关键字最小的元素与第一个元素交换；第二趟，在从第二个元素开始的 n-1 个元素中再选出关键字最小的元素与第二个元素交换；如此，第 k 趟，则从第 k 个元素开始的 n-k+1 个元素中选出关键字最小的元素与第 k 个元素交换，直到整个序列按关键字有序。

简单选择排序示意图

public static void main(String [] args){
    int[] array = new int[]{9,4,2,6,7,3,10,33,88,1,17};
    
    int min;
	int tmp = 0;
	for (int i = 0; i < array.length; i++) {
		min = array[i];
		for (int j = i; j < array.length; j++) {
			if (array[j] < min) {
				min = array[j]; //最小值
				tmp = array[i];
				array[i] = min;
				array[j] = tmp;
			}
		}
	}

}

空间效率：显然简单选择排序只需要一个辅助空间。

时间效率：在简单选择排序中，所需移动元素的次数较少，在待排序序列已经有序的情况下，简单选择排序不需要移动元素，在最坏的情况下，即待排序序列本身是逆序时，则移动元素的次数为 3(n-1)。然而无论简单选择排序过程中移动元素的次数是多少，在任何情况下，简单选择排序都需要进行n(n-1)/2 次比较操作，因此简单选择排序的时间复杂度为Ο(n2)。

算法改进思想：从上述效率分析中可以看出，简单选择排序的主要操作是元素间的比较操作，因此改进简单选择排序应从减少元素比较次数出发。在简单选择排序中，首先从 n个元素的序列中选择关键字最小的元素需要 n-1 次比较，在 n-1 个元素中选择关键字最小的元素需要 n-2 次比较……，在此过程中每次选择关键字最小的元素都没有利用以前比较操作得到的结果。欲降低比较操作的次数，则需要把以前比较的结果记录下来，由此得到一种改进的选择类排序算法，即树型选择排序。

树型选择排序

树型选择排序也称为锦标赛排序。其基本思想是：先把待排序的n个元素两两进行比较，取出较小者，若轮空则直接进入下一轮比较；然后在⎡n/2⎤个较小者中，采用同样的方法进行比较，再选出较小者；如此反复，直到选出关键字最小的元素为止。这个过程可以使用一颗具有n个结点的完全二叉树来表示，最终选出的关键字最小的元素就是这棵二叉树的根结点。

树形选择排序示意图

//树形选择排序
public static void main(String[] args){ 
	 int[] a = {1,6,3,8,5,4,9,21,5,34,2,32};
	 int len = a.length;
	 int treeSize = 2 * len - 1;  //完全二叉树的节点数
	 int low = 0;         
	 Object[] tree = new Object[treeSize];    //临时的树存储空间
	 //由后向前填充此树，索引从0开始        
	 for(int i = len-1,j=0 ;i >= 0; --i,j++){
		 //填充叶子节点             
		 tree[treeSize-1-j] = a[i];         
	 }                  
	 for(int i = treeSize-1;i>0;i-=2){
		 //填充非终端节点            
		 tree[(i-1)/2] = ((Comparable)tree[i-1]).compareTo(tree[i]) < 0 ? tree[i-1]:tree[i];
	 }                  //不断移走最小节点       
	 int minIndex;         
	 while(low < len){             
		 Object min = tree[0];    //最小值             
		 a[low++] = (int) min;             
		 minIndex = treeSize-1;
		 //找到最小值的索引             
		 while(((Comparable)tree[minIndex]).compareTo(min)!=0){
			 minIndex--;             
		}             
		 tree[minIndex] = Integer.MAX_VALUE;  //设置一个最大值标志             
		 //找到其兄弟节点             
		 while(minIndex > 0){      //如果其还有父节点                 
			 if(minIndex % 2 == 0){   //如果是右节点                     
				 tree[(minIndex-1)/2] = ((Comparable)tree[minIndex-1]).compareTo(tree[minIndex])                          < 0 ? tree[minIndex-1]:tree[minIndex];                     
				 minIndex = (minIndex-1)/2;                 
			 }else{                   //如果是左节点                     
				 tree[minIndex/2] = ((Comparable)tree[minIndex]).compareTo(tree[minIndex+1])                          < 0 ? tree[minIndex]:tree[minIndex+1];
				 minIndex = minIndex/2;                 
			 }             
		 }                      
	 }      
}

时间效率：在树型选择排序过程中为找到关键字最小的元素一共进行了 n-1 次比较，此后每次找出一个关键字所需要的比较次数等于完全二叉树的高度 h，而具有 n 个叶子结点的完全二叉树其高度为⎡log n⎤，由此可知除最小关键字外，每选择一个次小关键字需要进行⎡log n⎤次比较，因此树型选择排序的时间复杂度 T(n) = (n-1) ⎡log n⎤ (n-1) = Ο(n log n)。

空间效率：与简单选择排序相比，虽然树型选择排序减小的时间复杂度，却使用了更多的辅助空间，在树型选择排序中共使用
了 n-1 个而外的存储空间存放以前的比较结果。

算法改进思想：树型选择排序的缺点是使用了较多的辅助空间，以及和∞进行多余比较，为弥补树型选择排序的这些缺点J.W.J.Williams 在 1964 年提出了进一步的改进方法，即堆排序。

堆排序

在介绍堆排序之前，首先介绍堆的概念。堆的定义为：n个元素的序列{k1 , k2 , … , kn}，当且仅当满足下列关系时，称之为堆。

如果将序列{k1 , k2 , … , kn}对应为一维数组，且序列中元素的下标与数组中下标一致，即数组中下标为 0 的位置不存放数据元素，此时该序列可看成是一颗完全二叉树，则堆的定义说明，在对应的完全二叉树中非终端结点的值均不大于（或不小于）其左右孩子结点值。

由此，若堆是大顶堆，则堆顶元素——完全二叉树的根——必为序列中n个元素的最大值；反之，若是小顶堆，则堆顶元素必为序列中n个元素的最小值。

设有 n 个元素，欲将其按关键字排序。可以首先将这 n 个元素按关键字建成堆，将堆顶元素输出，得到 n 个元素中关键字最大（或最小）的元素。然后，再将剩下的 n-1 个元素重新建成堆，再输出堆顶元素，得到 n 个元素中关键字次大（或次小）的元素。如此反复执行，直到最后只剩一个元素，则可以得到一个有序序列，这个排序过程称之为堆排序。

从对排序的过程中可以看到，在实现对排序时需要解决两个问题：

1. 如何将 n 个元素的序列按关键字建成堆；
2. 输出堆顶元素后，怎样调整剩余 n-1 个元素，使其按关键字成为一个新堆。

我们首先第二个问题，即输出堆顶元素后，对剩余元素重新建成堆的调整过程。 设有一个具有 m 个元素的堆，输出堆顶元素后，剩下 m-1 个元素。具体的调整方法是：

首先，将堆底元素（最后一个元素）送入堆顶，此时堆被破坏，其原因仅是根结点不满足堆的性质，而根结点的左右子树仍是堆。

然后，将根结点与左、右子女中较大（或较小）的进行交换。若与左孩子交换，则左子树堆被破坏，且仅左子树的根结点不满足堆的性质；若与右孩子交换，则右子树堆被破坏，且仅右子树的根结点不满足堆的性质。继续对不满足堆性质的子树进行上述交换操作，直到叶子结点，则堆被重建。我们称这个自根结点到叶子结点的调整过程为筛选。

由此，如果我们能够建立一个堆，那么排序的过程就是不断输出堆顶并进行筛选的过程。现在的关键问题是如何由一个元素的初始序列构造一个堆，实际上建堆的方法是逐层向上对每个非终端结点进行一次筛选即可。

筛选过程

建堆过程

从上面的分析中我们可以看到，无论是初始建堆还是进行排序，都需要完成以某个元素为根的调整操作。

public static void main(String[] args) {
	int[] array = { 19, 8, 27, 6, 35, 14, 3, 12, 1, 0, 9, 10, 7 };
	
	if (array == null || array.length <= 1) {
		return;
	}
	buildMaxHeap(array);//建立最大堆
	for (int i = array.length - 1; i >= 1; i--) {
		//最大的在0位置，那么开始沉降，这样每交换一次最大的值就丢到最后了
		exchangeElements(array, 0, i);
		//继续获取0位置最大值
		maxHeap(array, i, 0);
	}
}
//建立最大堆
private void buildMaxHeap(int[] array) {
	if (array == null || array.length <= 1) {
		return;
	}
	int half = (array.length-1) / 2;
	for (int i = half; i >= 0; i--) {
		maxHeap(array, array.length, i);
	}
}

private void maxHeap(int[] array, int heapSize, int index) {
	int left = index * 2 + 1;
	int right = index * 2 + 2;
	int largest = index;
	if (left < heapSize && array[left] > array[index]) {
		largest = left;
	}
	if (right < heapSize && array[right] > array[largest]) {
		largest = right;
	}
	if (index != largest) {
		exchangeElements(array, index, largest);
		maxHeap(array, heapSize, largest);
	}
}
public void exchangeElements(int[] array, int index1, int index2) {  
          int temp = array[index1];  
          array[index1] = array[index2];  
          array[index2] = temp;  
} 

空间效率：显然堆排序只需要一个辅助空间。

时间效率：在每次循环时，左、右子树先比较一次，然后左、右子树较大者再与被筛元素比较一次，所以对深度为H的堆，筛选算法中的关键比较次数至多为2(h-1)次。时间复杂度O（nlog2n）  空间复杂度O(1)   不稳定。