选择排序：堆排序

一、概念：

完全二叉树：对于一棵顺序结构的完全二叉树而言，对于索引为k的节点，它的两个子节点的索引分别为2k+1、2k+2；反过来，对于索引为k的节点，其父节点的索引为(k-1)/2；

小顶堆：ki <= k2i+1且ki <= k2i+2（其中i=0，2，……，(n-1)/2）；

大顶堆：ki <= k2i+1且ki <= k2i+2（其中i=0，2，……，(n-1)/2）

二、思路：

三、源码：

package me.elemon.algorithm;

import java.util.Arrays;

/**
 * 排序
 * 
 * @author czj
 * @version 1.0
 * @datetime 11:24:07 PM, Mar 26, 2018
 */
public class SortTest {

	// -------------------------------------------------------------------------
	// 内部类
	// -------------------------------------------------------------------------

	/**
	 * 元数据
	 * 
	 * @author czj
	 * @version 1.0
	 * @datetime 11:19:40 AM, Mar 26, 2018
	 */
	private static class Data implements Comparable<Data> {

		private int value;
		private String flag;

		public Data(int value, String flag) {
			this.value = value;
			this.flag = flag;
		}

		@Override
		public String toString() {
			return value + flag;
		}

		@Override
		public int compareTo(Data data) {
			return this.value > data.value ? 1 : (this.value == data.value ? 0 : -1);
		}

	}

	// -------------------------------------------------------------------------
	// 排序方法
	// -------------------------------------------------------------------------

	/**
	 * 元素交换
	 * 
	 * @param datas
	 * @param i
	 * @param j
	 * @return void
	 * 
	 * @author czj
	 * @version 1.0
	 * @datetime 11:31:42 AM, Mar 26, 2018
	 */
	private static void swap(Data[] datas, int i, int j) {
		Data data = datas[i];
		datas[i] = datas[j];
		datas[j] = data;
	}

	/**
	 * 建堆（大顶堆）
	 * 
	 * @param datas
	 * @param lastIndex
	 * @return void
	 * 
	 * @author czj
	 * @version 1.0
	 * @datetime 1:31:38 PM, Mar 28, 2018
	 */
	private static void buildMaxHeap(Data[] datas, int lastIndex) {
		for (int i = (lastIndex - 1) / 2; i >= 0; i--) {
			int k = i;
			// 如果当前k节点存在子节点
			while (2 * k + 1 <= lastIndex) {
				int biggerIndex = 2 * k + 1;
				// 如果当前k节点存在右子节点
				if (biggerIndex < lastIndex) {
					if (datas[biggerIndex].compareTo(datas[biggerIndex + 1]) < 0) {
						biggerIndex++;
					}
				}

				// 如果k节点的值小于其较大子节点的值
				if (datas[k].compareTo(datas[biggerIndex]) < 0) {
					swap(datas, k, biggerIndex);
					// 保证k节点的值大于其左、右子节点的值
					k = biggerIndex;
				} else {
					break;
				}
			}
		}
	}

	/**
	 * 选择排序：堆排序
	 * 
	 * @param datas
	 * @return void
	 * 
	 * @author czj
	 * @version 1.0
	 * @datetime 11:20:57 AM, Mar 28, 2018
	 */
	public static void heapSort(Data[] datas) {
		// 循环建堆
		for (int i = 0; i < datas.length - 1; i++) {
			// 建堆
			buildMaxHeap(datas, datas.length - 1 - i);
			// 交换堆顶和最后一个元素
			swap(datas, 0, datas.length - 1 - i);

			System.out.println("[" + i + "]: " + Arrays.toString(datas));
		}
	}

	// -------------------------------------------------------------------------
	// 测试
	// -------------------------------------------------------------------------

	public static void main(String[] args) {
		Data[] datas = { 
			new Data(9, ""), new Data(79, ""), new Data(46, ""), 
			new Data(30, ""), new Data(58, ""), new Data(49, "") 
		};

		System.out.println("------------------------------------------------------------");
		System.out.println("before sort: " + Arrays.toString(datas));
		System.out.println("------------------------------------------------------------\n\n");

		// 排序
		heapSort(datas);

		System.out.println("\n\n------------------------------------------------------------");
		System.out.println("after sort: " + Arrays.toString(datas));
		System.out.println("------------------------------------------------------------");
	}

}