堆排序

简要介绍

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

堆的操作

在堆的数据结构中，堆中的最大值总是位于根节点（在优先队列中使用堆的话堆中的最小值位于根节点）。堆中定义以下几种操作：
最大堆调整（Max Heapify）：将堆的末端子节点作调整，使得子节点永远小于父节点
创建最大堆（Build Max Heap）：将堆中的所有数据重新排序
堆排序（HeapSort）：移除位在第一个数据的根节点，并做最大堆调整的递归运算

代码实现（Java）

package sort;

public class HaepSort {
	public static void main(String[] args) {
		int [] data = {1,9,3,5,6,7,8,4,11,95,66,56};
		for (int i = 0; i < data.length; i++) {
			System.out.print(data[i]+" ");
		}
		heapSort(data);
		System.out.println();
		for (int i = 0; i < data.length; i++) {
			System.out.print(data[i]+" ");
		}
	}

	private static void heapSort(int[] data) {
		// TODO Auto-generated method stub
		for(int i =data.length/2;i>=0;i--) {
			buildHeap(data,i,data.length);
		}
		for(int i =data.length-1;i>=0;i--) {
			swap(data,0,i);
			buildHeap(data, 0, i);
		}
	}

	private static void swap(int[] data, int i, int i2) {
		// TODO Auto-generated method stub
		int temp = data[i];
		data[i] = data[i2];
		data[i2] = temp;
	}

	private static void buildHeap(int[] data, int i, int length) {
		// TODO Auto-generated method stub
		int leftChild = leftChild(i);
		int temp =data[i];
		for(;leftChild<length;) {
			if(leftChild!=length-1&&data[leftChild]<data[leftChild+1]) {
				leftChild++;
			}
			if(temp<data[leftChild]) {
				data[i] = data[leftChild];
			}else {
				//break两个节点逗比父节点小，父节点大于儿子节点，直接停止比较，减小比较的次数
				break;
			}
			i=leftChild;
			leftChild = leftChild(i);
		}
		data[i] = temp;
	}

	//返回节点i的左儿子的index
	private static int leftChild(int i) {
		// TODO Auto-generated method stub
		return 2*i+1;
	}
}

运行结果

1 9 3 5 6 7 8 4 11 95 66 56 
1 3 4 5 6 7 8 9 11 56 66 95 

代码实现（C++）

#include <iostream>
#include <algorithm>
using namespace std;
 
void max_heapify(int arr[], int start, int end) {
    //建立父节点指标和子节点指标
    int dad = start;
    int son = dad * 2 + 1;
    while (son <= end) { //若子节点指标在范围内才做比较
        if (son + 1 <= end && arr[son] < arr[son + 1]) //先比较两个子节点大小，选择最大的
            son++;
        if (arr[dad] > arr[son]) //如果父节点大於子节点代表调整完毕，直接跳出函数
            return;
        else { //否则交换父子内容再继续子节点和孙节点比较
            swap(arr[dad], arr[son]);
            dad = son;
            son = dad * 2 + 1;
        }
    }
}
 
void heap_sort(int arr[], int len) {
    //初始化，i从最後一个父节点开始调整
    for (int i = len / 2 - 1; i >= 0; i--)
        max_heapify(arr, i, len - 1);
    //先将第一个元素和已经排好的元素前一位做交换，再从新调整(刚调整的元素之前的元素)，直到排序完毕
    for (int i = len - 1; i > 0; i--) {
        swap(arr[0], arr[i]);
        max_heapify(arr, 0, i - 1);
    }
}
 
int main() {
    int arr[] = { 3, 5, 3, 0, 8, 6, 1, 5, 8, 6, 2, 4, 9, 4, 7, 0, 1, 8, 9, 7, 3, 1, 2, 5, 9, 7, 4, 0, 2, 6 };
    int len = (int) sizeof(arr) / sizeof(*arr);
    heap_sort(arr, len);
    for (int i = 0; i < len; i++)
        cout << arr[i] << ' ';
    cout << endl;
    return 0;
}