package com.algorithm.charactor1;  
  
import java.util.Arrays;  
import java.util.Random;  
  
/** 
 *heap堆的学习，这个 并不是 存放数据的 堆， 
 *而是一种数据结构堆。 
 *堆的定义是一个完全被填满的二叉树（最后的树叶除外，）从左向右依次 填满 
 * 
 * 让操作快速执行的性质 叫做堆序性质 
 * 定义一个堆，使其 父节点小于等于 comparTo子节点。 
 *  
 * 堆用数组实现， 即 节点i的  左儿子节点为2i+1  右儿子节点为2i+2 
 */  
public class Heap {  
    private Integer [] array ;//表  
    private static final int DEFAULTSIZE = 7;  
    private int  size ;  
      
  
    public Heap() {  
        this(DEFAULTSIZE);  
    }  
      
    /** 
     * 插入操作，允许重复元 
     * @param key 
     */  
    void insert(Integer key){  
  
        if (size >= array.length-1) {//扩容操作  
            expand();  
        }  
          
        int index = size;  
          
        //进行上滤操作，默认放到最后一个，然后一次次上滤。 
        
        for (array[index] = key; key.compareTo(array[index/2]) <0 ; index/=2) {  
            Integer  temp = array[index/2];  
            array[index/2] = key;  
            array[index] = temp;  
        }  
        size++;  
    }  
      
    /** 
     * 删除最小的 堆顶元素  
     * 选取 左右儿子中，最小的一个元素。 
     */  
    void deleteMin(){  
        if (size ==0) {  
            return;//也可以抛异常  
        }  
        //当前堆中最小的元素，将当前堆中最后一个元素赋值给第一个索引，然后依次下滤  
        array[0] =array[--size];  
        array[size] = null;  
        int parent = 0;  
        filterDown(parent);  
          
    }  
    /** 
     * 下滤 
     * @param parent 
     * @param child 
     */  
    void filterDown(int parent){  
        int child = 2*parent+1;//初始值  
        for (; child < array.length;child = 2*parent+1 ) {  
              
            //选择 当前节点的  儿子节点的最小值  
            if (child!=size-1 && array[child].compareTo(array[child+1]) > 0 ) {  
                child++;  
            }  
              
            //父节点和子节点最小值比较  
            if (array[parent].compareTo(array[child]) > 0) {  
            	Integer temp = array[parent];  
                array[parent] = array[child];  
                array[child] =temp;  
                parent =child;  
            }else {  
                break;  
            }  
        }  
    }  
      
    /** 
     * 给定一个数组，构建堆 
     * @param buildArray 
     */  
    private void buildHeap(Integer []buildArray) {  
        array = Arrays.copyOf(buildArray, buildArray.length);//创建初始数组  
        size =  buildArray.length;//数组中 有多少值  
         for(int i = (buildArray.length)/2-1;i>=0;i--){//下标小于等于i的节点拥有子节点    
             filterDown(i);    
         }    
    }  
      
    public static void main(String[] args) {  
        Heap heap = new Heap();  
        Integer [] arr = new Integer[10];
        for (int i = 0; i < 10; i++) {
        	arr[i]=new Random().nextInt(33);
//			heap.insert(new Random().nextInt(33));
		}
        heap.buildHeap(arr);
        System.out.println(Arrays.toString(heap.array));  
//        heap.deleteMin();
//        System.out.println(Arrays.toString(heap.array));  
    }  
      
      
    private void expand() {  
        array = Arrays.copyOf(array, 2*array.length +1);  
    }  
  
    public Heap(int size) {  
        array = new Integer[size];  
    }  
  
}