1 /**
  2  * 二叉堆(最大堆)
  3  *
  4  * @author skywang
  5  * @date 2014/03/07
  6  */
  7 
  8 import java.util.ArrayList;
  9 import java.util.List;
 10 
 11 public class MaxHeap<T extends Comparable<T>> {
 12 
 13     private List<T> mHeap;    // 佇列(實際上是動態陣列ArrayList的例項)
 14 
 15
 
     public MaxHeap() {
 16         this.mHeap = new ArrayList<T>();
 17     }
 18 
 19     /* 
 20      * 最大堆的向下調整演算法
 21      *
 22      * 注：陣列實現的堆中，第N個節點的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
 23      *
 24      * 引數說明：
 25      *     start -- 被下調節點的起始位置(一般為0，表示從第1個開始)
 26      *     end   -- 截至範圍(一般為陣列中最後一個元素的索引)
 
 27      */
 28     protected void filterdown(int start, int end) {
 29         int c = start;          // 當前(current)節點的位置
 30         int l = 2*c + 1;     // 左(left)孩子的位置
 31         T tmp = mHeap.get(c);    // 當前(current)節點的大小
 32 
 33         while(l <= end) {
 34             int cmp = mHeap.get(l).compareTo(mHeap.get(l+1));
 
 35             // "l"是左孩子，"l+1"是右孩子
 36             if(l < end && cmp<0)
 37                 l++;        // 左右兩孩子中選擇較大者，即mHeap[l+1]
 38             cmp = tmp.compareTo(mHeap.get(l));
 39             if(cmp >= 0)
 40                 break;        //調整結束
 41             else {
 42                 mHeap.set(c, mHeap.get(l));
 43                 c = l;
 44                 l = 2*l + 1;   
 45             }       
 46         }   
 47         mHeap.set(c, tmp);
 48     }
 49 
 50     /*
 51      * 刪除最大堆中的data
 52      *
 53      * 返回值：
 54      *      0，成功
 55      *     -1，失敗
 56      */
 57     public int remove(T data) {
 58         // 如果"堆"已空，則返回-1
 59         if(mHeap.isEmpty() == true)
 60             return -1;
 61 
 62         // 獲取data在陣列中的索引
 63         int index = mHeap.indexOf(data);
 64         if (index==-1)
 65             return -1;
 66 
 67         int size = mHeap.size();
 68         mHeap.set(index, mHeap.get(size-1));// 用最後元素填補
 69         mHeap.remove(size - 1);                // 刪除最後的元素
 70 
 71         if (mHeap.size() > 1)
 72             filterdown(index, mHeap.size()-1);    // 從index號位置開始自上向下調整為最小堆
 73 
 74         return 0;
 75     }
 76 
 77     /*
 78      * 最大堆的向上調整演算法(從start開始向上直到0，調整堆)
 79      *
 80      * 注：陣列實現的堆中，第N個節點的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
 81      *
 82      * 引數說明：
 83      *     start -- 被上調節點的起始位置(一般為陣列中最後一個元素的索引)
 84      */
 85     protected void filterup(int start) {
 86         int c = start;            // 當前節點(current)的位置
 87         int p = (c-1)/2;        // 父(parent)結點的位置 
 88         T tmp = mHeap.get(c);        // 當前節點(current)的大小
 89 
 90         while(c > 0) {
 91             int cmp = mHeap.get(p).compareTo(tmp);
 92             if(cmp >= 0)
 93                 break;
 94             else {
 95                 mHeap.set(c, mHeap.get(p));
 96                 c = p;
 97                 p = (p-1)/2;   
 98             }       
 99         }
100         mHeap.set(c, tmp);
101     }
102       
103     /* 
104      * 將data插入到二叉堆中
105      */
106     public void insert(T data) {
107         int size = mHeap.size();
108 
109         mHeap.add(data);    // 將"陣列"插在表尾
110         filterup(size);        // 向上調整堆
111     }
112 
113     @Override
114     public String toString() {
115         StringBuilder sb = new StringBuilder();
116         for (int i=0; i<mHeap.size(); i++)
117             sb.append(mHeap.get(i) +" ");
118 
119         return sb.toString();
120     }
121  
122     public static void main(String[] args) {
123         int i;
124         int a[] = {10, 40, 30, 60, 90, 70, 20, 50, 80};
125         MaxHeap<Integer> tree=new MaxHeap<Integer>();
126 
127         System.out.printf("== 依次新增: ");
128         for(i=0; i<a.length; i++) {
129             System.out.printf("%d ", a[i]);
130             tree.insert(a[i]);
131         }
132 
133         System.out.printf("\n== 最 大 堆: %s", tree);
134 
135         i=85;
136         tree.insert(i);
137         System.out.printf("\n== 新增元素: %d", i);
138         System.out.printf("\n== 最 大 堆: %s", tree);
139 
140         i=90;
141         tree.remove(i);
142         System.out.printf("\n== 刪除元素: %d", i);
143         System.out.printf("\n== 最 大 堆: %s", tree);
144         System.out.printf("\n");
145     }
146 }