堆排序

堆的定义如下：

n个元素的序列{k0,k1,...,ki,…,k(n-1)}当且仅当满足下关系时，称之为堆。

"ki<=k(2i),ki<=k(2i+1);或ki>=k(2i),ki>=k(2i+1).（i=1,2,…,[n/2])"

若将和此次序列对应的一维数组（即以一维数组作此序列的存储结构）看成是一个完全二叉树，

若完全二叉树中每一个节点的值都大于或等于任意一个子节点的值（如果有的话），称之为大顶堆。

若完全二叉树中每一个节点的值都小于或等于任意一个子节点的值（如果有的话），称之为小顶堆。

由此，若序列{k0,k1,…,k(n-1)}是堆，则堆顶元素（或完全二叉树的根）必为序列中n个元素的最小值（或最大值）。

倘若给堆中每一个节点都赋予一个整数值标签，根节点被标记为0，对于每一个标记为i的节点，其左子节点（若存在的话）被标记为2*i+1，其右子节点（若存在的话）被标记为2*i+2，对于一个标记为i的非根节点，其父节点被标记为（i-1）/2。使用这个标记，我们能够将堆存储在数组中，节点存储在数据中的位置就使其标签。

堆排序示例：

规则：

1.初始化i=0，先后查看节点i的左子节点2*i+1、右子节点2*i+2，如果发现违反了堆的定义，则交换2个节点的值（编号只跟位置有关，也就是数组中的下标），置i=0

2.如果没有发现违反堆的定义，则置i=i+1，返回步骤1

3.当i==n的时候，将0号位置上的元素放置到n号位置上，置i=0，置n=n-1，返回步骤1，对位置为[0, n]范围内的元素重复上述操作

示意图如下：数组中的值依次是17,8,45,84,2,94，这次排序的最终结果是把最大的94放到了序列末尾

下面是剩下的元素的排序过程：

代码如下：

package sorts;

import java.util.Arrays;

public class  Heap<T extends Comparable<T>> // 小顶堆，也就是说小的数据在堆顶部
{
    // index starts from 0
    private int parent(int index) {
        if (index%2==0) {
            return ( index / 2 ) - 1;
        } else {
            return index / 2;
        }
    }
    
    private int lchild(int index) {
        return index * 2 + 1;
    }
    
    private int rchild(int index) {
        return index * 2 + 2;
    }
    
    
    public void heap_sort(T[] a,int n){
        if(n>0){
            init_sort(a,n);//初始化堆，找出最大的放在堆顶
            swap(a, 0, n);
            heap_sort(a, n-1); // recursively
        }
    }
    
    private void swap(T[] a, int index1, int index2) {
        T temp = a[index1];
        a[index1] = a[index2];
        a[index2] = temp;
    }

    private void init_sort(T[] a,int n){        
        int m=(n+1)/2;    
        for(int i=0;i<m;i++){
            boolean flag=min_heapify(a,n,i);
            //如果孩子之间有交换，就要重新开始
            if(flag){
                i=-1;
            }
        }
    }
    
    //返回一个标记，如果有根与孩子交换就要重新从顶根开始查找不满足最大堆树结构
    private boolean min_heapify(T a[],int n,int i){
        int l_child=lchild(i);//左孩子
        int r_child=rchild(i);//右孩子
        if(r_child>n){           //判断是否有右孩子，没有的话直接比较，小于右孩子则交换
            if(a[i].compareTo(a[l_child])<0){
                swap(a, i, l_child);
                return true;
            }else{
                return false;
            }
        }
        //在根与两个孩子之间找出最大的那个值进行交换
        if(a[i].compareTo(a[l_child])<0){
            if(a[l_child].compareTo(a[r_child])>0){
                //交换根与左孩子的值
                swap(a, i, l_child);
                return true;
            }else{
                //交换根与右孩子的值
                swap(a, i, r_child);
                return true;
            }
        }else if(a[i].compareTo(a[r_child])<0){
            //交换根与右孩子的值
            swap(a, i, r_child);
            return true;
        }
        return false;
            
    }
    public static void main(String[] args) 
    {
        Heap h = new Heap();
        Integer [] a={17,8,45,84,2,94};
        h.heap_sort(a,a.length-1);
        System.out.println(Arrays.toString(a));
    }
}