数据结构-堆 Java实现

数据结构-堆 Java实现。 实现堆自动增长

 /**
  * 数据结构-堆。 自动增长
  *
  * @author caiyao  */
 public class Heap<T extends Comparable> {

     private Object[] node;

     private static final int DEFAULT_SIZE = 10;

     private int size = 0;

     private int capacity;

     private Type type;

     public Heap(Type type){
         this(type,DEFAULT_SIZE);
     }

     public Heap(Type type, int initCapacity){
         node = new Object[initCapacity];
         this.capacity = initCapacity;
         this.type = type;
     }

     /**
      * 插入
      * @param newNode
      */
     public void insert(T newNode){
         ensureCapacity(size + 2); // 新节点和空着的0号节点
         node[size + 1] = newNode;
         upAdjust();
         size ++;
     }
     private void upAdjust(){
         for(
                 int currentNodeIndex = size + 1;
                 (
                         currentNodeIndex > 1 && ((T)node[currentNodeIndex]).compareTo(node[currentNodeIndex / 2]) < 0 && type == Type.MIN
                 ) ||
                 (
                         currentNodeIndex > 1 && ((T)node[currentNodeIndex]).compareTo(node[currentNodeIndex / 2]) > 0 && type == Type.MAX
                 );
                 currentNodeIndex = currentNodeIndex / 2
                 ){
             Object tempValue = node[currentNodeIndex];
             node[currentNodeIndex] = node[currentNodeIndex / 2];
             node[currentNodeIndex / 2] = tempValue;
         }
     }
     private void ensureCapacity(int newSize){
         if(newSize > DEFAULT_SIZE && newSize > this.capacity){
             grow();
         }
     }
     private void grow(){
         int newSize = capacity + (capacity >> 1); // 扩大50%容量
         node = Arrays.copyOf(node,newSize);
     }
     /**
      * 返回堆顶
      * @return
      */
     public T top(){
         return (T)node[0];
     }

     /**
      * 返回堆顶并从堆中移除
      * @return
      */
     public T pop(){
         T top = (T)node[0];
         downAdjust();
         node[size] = null;
         return top;
     }
     private void downAdjust(){
         node[0] = node[size - 1];
         for(
                 int currentNode = 1;
                 ;
                 ){
                 // 小根堆 + 左子树
                 if(type == Type.MIN && currentNode * 2 <= size && ((T)node[currentNode * 2]).compareTo(node[currentNode]) < 0){
                     Object tempValue = node[currentNode];
                     node[currentNode] = node[currentNode * 2];
                     node[currentNode * 2] = tempValue;
                     currentNode = currentNode * 2;
                 }
                 // 小根堆 + 右子树
                 else if(type == Type.MIN && currentNode * 2 + 1 <= size && ((T)node[currentNode * 2 + 1]).compareTo(node[currentNode]) < 0){
                     Object tempValue = node[currentNode];
                     node[currentNode] = node[currentNode * 2 + 1];
                     node[currentNode * 2 + 1] = tempValue;
                     currentNode = currentNode * 2 + 1;
                 }
                 // 大根堆 + 左子树
                 else if(type == Type.MAX && currentNode * 2 <= size && ((T)node[currentNode * 2]).compareTo(node[currentNode]) > 0){
                     Object tempValue = node[currentNode];
                     node[currentNode] = node[currentNode * 2];
                     node[currentNode * 2] = tempValue;
                     currentNode = currentNode * 2;
                 }
                 // 大根堆 + 右子树
                 else if(type == Type.MAX && currentNode * 2 + 1 <= size && ((T)node[currentNode * 2 + 1]).compareTo(node[currentNode]) > 0){
                     Object tempValue = node[currentNode];
                     node[currentNode] = node[currentNode * 2 + 1];
                     node[currentNode * 2 + 1] = tempValue;
                     currentNode = currentNode * 2 + 1;
                 }
                 else{
                     break;
                 }
         }
     }
     /**
      * 遍历
      */
     public void traverse(){
         for(int i = 1; i <= size; i ++){
             System.out.println(node[i]);
         }
     }
     public enum Type {
         MIN,
         MAX
     }

     public static void main(String[] args){
         Heap demo = new Heap<Integer>(Type.MIN);
         demo.insert(1);
         demo.insert(10);
         demo.insert(8);
         demo.insert(18);
         demo.insert(2);
         demo.insert(6);
         demo.insert(9);
         demo.insert(0);
         demo.insert(0);
         demo.insert(0);
         demo.insert(0);
         demo.insert(0);
         demo.traverse();
     }
 }