面试题：大（小）顶堆

堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。首先简单了解下堆结构。　

堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。如下图：

大顶堆：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]

小顶堆：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2]

 我们对堆中的结点按层进行编号，将这种逻辑结构映射到数组中就是下面这个样子

将给定无序序列构造成一个大顶堆（一般升序采用大顶堆，降序采用小顶堆)

　堆排序的基本思想是：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。

 1、大顶堆(升序)

   /**
 * 大顶堆的特点：每个结点的值都大于或等于其左右孩子结点的值，
 * 我们把大顶堆构建完毕后根节点的值一定是最大的，
 * 然后把根节点的和最后一个元素（也可以说最后一个节点）交换位置，
 * 那么末尾元素此时就是最大元素了（理解这点很重要）
 *
 * 知道了堆排序的原理下面就可以来操作了，在进行操作前先理清一下步骤
 *
 * （假设我们想要升序的排列）
 *
 * 第一步：先n个元素的无序序列，构建成大顶堆
 *
 * 第二步：将根节点与最后一个元素交换位置，（将最大元素"沉"到数组末端）
 *
 * 第三步：交换过后可能不再满足大顶堆的条件，所以需要将剩下的n-1个元素重新构建成大顶堆
 *
 * 第四步：重复第二步、第三步直到整个数组排序完成
 */
public class MaxHeap {

	public static void main(String[] args) {
		int[] a = {4,6,1,3,2,5};
		justMaxHeap(a, a.length);
		for (int j= a.length-1; j>=0; j--){
			// 末尾元素
			int temp = a[j];
			a[j] = a[0];
			a[0] = temp;
			// 新对堆进行调整
			justMaxHeap(a, j);
		}

		print(a);
	}

	private static void justMaxHeap(int[] a, int length) {
		for (int i = (length/2) -1; i>=0; i--) {
			// 判断该节点是否有右子树
			// 当length为偶数时，没有右子树
			// 根节点：a[i],左子树：a[2*i + 1],右子树：a[2(i+1)]
			if (2*(i+1) >= length) {
				if (a[2*i+1] > a[i]) {
					int temp = a[i];
					a[i] = a[2*i+1];
					a[2*i+1] = temp;
				}
			} else {
				// 判断左右子树是否有一个比当前根节点大
				if(a[i] < a[2*i+1] || a[i] < a[2*(i+1)]){
					// 比较左右子树大小，取较大值进行交换
					if(a[2*i+1] >= a[2*(i+1)]){
						int temp=a[i];
						a[i]=a[2*i+1];
						a[2*i+1]=temp;
					} else {
						int temp = a[i];
						a[i] = a[2*(i+1)];
						a[2*(i+1)] = temp;
					}
				}
			}
		}
		print(a);
	}

	private static void print(int[] a) {
		//打印
		for(int i=0;i<a.length;i++){
			System.out.print(a[i] + ",");
		}
		System.out.println();
		System.out.println("**************");
	}
}

 2、小顶堆(降序)

    public static void SortByMinHeap(int[] a,int size){
        //1.构建小顶堆
        justMinHeap(a,size);
        //2.调整堆结构+交换堆顶元素与末尾元素
        for(int j=a.length-1;j>0;j--){
            //将堆顶元素与末尾元素进行交换
            int temp=a[0];
            a[0] = a[j];
            a[j] = temp;
            justMinHeap(a,j);//重新对堆进行调整
        }

        //打印
        for(int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
    }

    public static void justMinHeap(int[] a,int size){
        for(int j=size/2-1;j>=0;j--){
            if(2*(j+1)>=size){
                if(a[2*j+1]<a[j]){
                    int temp=a[j];
                    a[j]=a[2*j+1];
                    a[2*j+1]=temp;
                }
            }else{
                if(a[2*j+1]<a[j]||a[2*(j+1)]<a[j]){
                    if(a[2*j+1]<a[2*(j+1)]){
                        int temp=a[j];
                        a[j]=a[2*j+1];
                        a[2*j+1]=temp;
                    }else{
                        int temp=a[j];
                        a[j]=a[2*(j+1)];
                        a[2*(j+1)]=temp;
                    }
                }
            }
        }
    }