堆排序——java

堆排序：
时间复杂度：O（n*log2（n））
空间复杂度：O（1）
不稳定
核心代码：

import java.util.Arrays;/** * 堆排序 * @author jin */public class Heap {    /**     * 创建大顶堆     * @param array     * @param lastIndex     */    public static void createMaxHeap(int[] array, int lastIndex) {        for (int i = (lastIndex - 1) / 2; i >= 0; i--) {            int fatherIndex = i;            while (fatherIndex * 2 + 1 <= lastIndex) { // 如果当前父节点有子节点的话                int biggerIndex = fatherIndex * 2 + 1;                if (biggerIndex < lastIndex) {                    if (array[biggerIndex] < array[biggerIndex + 1]) {                        biggerIndex++;                    }                }                if (array[biggerIndex] > array[fatherIndex]) {                    swap(array, fatherIndex, biggerIndex);                } else {                    break;                }            }        }    }    /**     * 数组中元素进行交换     * @param array     * @param i     * @param j     */    public static void swap(int[] array, int i, int j) {        int tmp = array[i];        array[i] = array[j];        array[j] = tmp;    }    /**     * main方法     */    public static void main(String[] args) {        int[] a = { 1, 2, 56, 3, 55, 2, 66, 9, 0, 7 };        for (int i = 0; i < a.length - 1; i++) {            createMaxHeap(a, a.length - 1 - i);            swap(a, 0, a.length - 1 - i);        }        System.out.println(Arrays.toString(a));    }}

堆排序，有两个步骤：
（1）先建一个大顶堆，
（2）然后堆顶与堆的最后一个元素进行交换。
步骤：
（1）建大顶堆：
大顶堆：所有的父节点的数都比子节点的数大。
大顶堆是通过数组进行存储的 ，例如：

在内存中的存储方式为：

求某一子节点的父节点的索引：
（子节点索引-1）/2取整
建堆时，先从最后一个数开始，最后一个索引为lastIndex，其父节点为fatherIndex=（lastIndex-1）/2；如果该父节点有子节点的话，那么左节点为leftIndex=fatherIndex*2+1；
如果建大顶堆，也是从最后一个数开始，不过求子节点时，先假设左节点为最大的数biggerIndex=fatherIndex*2+1；如果biggerIndex

for(int i=(lastIndex-1)/2;i>=0;i--){//从后往前建立    int fatherIndex=i;    while(fatherIndex*2+1<=lastIndex){//如果当前父节点有子节点的话        int biggerIndex=fatherIndex*2+1;//为左节点        if(biggerIndex<lastIndex){            if(a[biggerIndex]<a[biggerIndex+1]){                biggerIndex++;//此时最大的数变为右节点            }        }        if(a[biggerIndex]>a[fatherIndex]){//交换这两个索引的值的位置        //这里用到了位运算，详细的以后会写            a[fatherIndex]=a[biggerIndex]^a[fatherIndex];            a[biggerIndex]=a[biggerIndex]^a[fatherIndex];            a[fatherIndex]=a[biggerIndex]^a[fatherIndex];        }else{            break;        }    }}

（2）然后堆顶与堆的最后一个元素进行交换。
这里就开始进行排序了，交换完成后，就实现了从小到大的排列。