数据结构和算法（十七）排序之选择排序

前言

     本章讨论选择排序的相关知识

方法

1.概念

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。

选择排序分为直接选择排序和堆排序

2.直接选择排序

直接选择排序(Straight Select Sorting) 也是一种简单的排序方法，它的基本思想是：第一次从R[0]~R[n-1]中选取最小值，与R[0]交换，第二次从R[1]~R[n-1]中选取最小值，与R[1]交换，....，第i次从R[i-1]~R[n-1]中选取最小值，与R[i-1]交换，.....，第n-1次从R[n-2]~R[n-1]中选取最小值，与R[n-2]交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列。

具体的排序过程为：

1. 将整个记录序列划分为有序区和无序区，初始时有序区为空，无序区含有待排序的所有记录
2. 在无序区选择关键码最小的记录，将其与无序区中的第一个元，使得有序区扩展一个记录，同时无序区减少了一个记录
3. 不断重复步骤 2，直到无序区只剩下一个记录为止

使用Java实现直接选择排序：

package cn.edu.ccut.sort;

import java.util.Arrays;

/**
 * 选择排序-直接选择排序
 * 初始序列：4,2,6,3,1,5
 * 第一次排序：[1],4,6,3,2,5
 * 第二次排序：[1,2],6,4,3,5
 * 第三次排序：[1,2,3],6,4,5
 * 第四次排序：[1,2,3,4],6,5
 * 第五次排序：[1,2,3,4,5],6
 * @author jwang
 *
 */
public class SelectSort {

	public static void main(String[] args) {
		int [] arr = {4,2,6,3,1,5};//待排序列
		System.out.println("排序前："+Arrays.toString(arr));
		selectSort(arr);
		System.out.println("排序后："+Arrays.toString(arr));
	}

	private static void selectSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {    
            int  min = i;//当前最小值索引
            for (int j = i + 1; j < arr.length; j++) {
                  if (arr[min] > arr[j]) {
                       min = j;//后序序列中找到的最小值索引
                  }
            }
            if (min != i) {//如果最小值索引不是当前元素索引，则交换
               int tmp = arr[min];
               arr[min] = arr[i];
               arr[i] = tmp;
            }             
        }
	}
}

可以发现，每一次的执行都把最小的数字移动到数组的左侧，这就是选择排序。

我们应重点将其和冒泡排序进行比较，探究其不同。

2.堆排序

不用多说，堆排序便是直接选择排序的升级版

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

在堆的数据结构中，堆中的最大值总是位于根节点（在优先队列中使用堆的话堆中的最小值位于根节点）。堆中定义以下几种操作：

• 最大堆调整（Max Heapify）：将堆的末端子节点作调整，使得子节点永远小于父节点

• 创建最大堆（Build Max Heap）：将堆中的所有数据重新排序

• 堆排序（HeapSort）：移除位在第一个数据的根节点，并做最大堆调整的递归运算

具体的算法流程：

1.将长度为n的待排序的数组进行堆有序化构造成一个大顶堆
 
2.将根节点与尾节点交换并输出此时的尾节点
 
3.将剩余的n -1个节点重新进行堆有序化
 
4.重复步骤2，步骤3直至构造成一个有序序列

代码如下：

package cn.edu.ccut.search;

public class Test {

	public static void main(String[] args) {
		int [] arr = {31,17,15,32,14,28,94,28,65};
		System.out.println("排序前：");
		traversing(arr);
		System.out.println();
		heapSort(arr);
		System.out.println("排序后：");
		traversing(arr);
	}
	
	/**
    * 选择排序-堆排序
    * @param array 待排序数组
    * @return 已排序数组
    */
    public static void heapSort(int[] array) {
        //这里元素的索引是从0开始的,所以最后一个非叶子结点array.length/2 - 1
        for (int i = array.length / 2 - 1; i >= 0; i--) {  
            adjustHeap(array, i, array.length);  //调整堆
        }
  
        // 上述逻辑，建堆结束
        // 下面，开始排序逻辑
        for (int j = array.length - 1; j > 0; j--) {
            // 元素交换,作用是去掉大顶堆
            // 把大顶堆的根元素，放到数组的最后；换句话说，就是每一次的堆调整之后，都会有一个元素到达自己的最终位置
            swap(array, 0, j);
            // 元素交换之后，毫无疑问，最后一个元素无需再考虑排序问题了。
            // 接下来我们需要排序的，就是已经去掉了部分元素的堆了，这也是为什么此方法放在循环里的原因
            // 而这里，实质上是自上而下，自左向右进行调整的
            adjustHeap(array, 0, j);
        }
    }
  
    /**
    * 整个堆排序最关键的地方
    * @param array 待组堆
    * @param i 起始结点
    * @param length 堆的长度
    */
    public static void adjustHeap(int[] array, int i, int length) {
        // 先把当前元素取出来，因为当前元素可能要一直移动
        int temp = array[i];
        for (int k = 2 * i + 1; k < length; k = 2 * k + 1) {  //2*i+1为左子树i的左子树(因为i是从0开始的),2*k+1为k的左子树
            // 让k先指向子节点中最大的节点
            if (k + 1 < length && array[k] < array[k + 1]) {  //如果有右子树,并且右子树大于左子树
                k++;
            }
            //如果发现结点(左右子结点)大于根结点，则进行值的交换
            if (array[k] > temp) {
                swap(array, i, k);
                // 如果子节点更换了，那么，以子节点为根的子树会受到影响,所以，循环对子节点所在的树继续进行判断
                i = k;  //这一步决定了下一个步骤执行到的是左子树还是右子树
            } else {  //不用交换，直接终止循环
                break;
            }
        }
    }
  
    /**
    * 交换元素
    * @param arr
    * @param a 元素的下标
    * @param b 元素的下标
    */
    public static void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

	//遍历数组
	public static void traversing(int [] arr){
		for(int num : arr){
			System.out.print(num+"\t");
		}
	}

}