1 /**
  2  * 二叉堆(最大堆)
  3  *
  4  * @author skywang
  5  * @date 2014/03/07
  6  */
  7 
  8 #include <stdio.h>
  9 #include <stdlib.h>
 10 
 11 #define LENGTH(a) ( (sizeof(a)) / (sizeof(a[0])) )
 12 
 13 static int m_heap[30];        // 資料
 14 static int m_capacity=30;    // 總的容量
 15 static
 
 int m_size=0;        // 實際容量(初始化為0)
 16  
 17 /* 
 18  * 返回data在二叉堆中的索引
 19  *
 20  * 返回值：
 21  *     存在 -- 返回data在陣列中的索引
 22  *     不存在 -- -1
 23  */
 24 int get_index(int data)
 25 {
 26     int i=0;
 27 
 28     for(i=0; i<m_size; i++)
 29         if (data==m_heap[i])
 30             return
 
 i;
 31 
 32     return -1;
 33 }
 34 
 35 /* 
 36  * 最大堆的向下調整演算法
 37  *
 38  * 注：陣列實現的堆中，第N個節點的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
 39  *
 40  * 引數說明：
 41  *     start -- 被下調節點的起始位置(一般為0，表示從第1個開始)
 42  *     end   -- 截至範圍(一般為陣列中最後一個元素的索引)
 43  */
 44 static void maxheap_filterdown(int start, int
 
 end)
 45 {
 46     int c = start;          // 當前(current)節點的位置
 47     int l = 2*c + 1;     // 左(left)孩子的位置
 48     int tmp = m_heap[c];    // 當前(current)節點的大小
 49 
 50     while(l <= end)
 51     {
 52         // "l"是左孩子，"l+1"是右孩子
 53         if(l < end && m_heap[l] < m_heap[l+1])
 54             l++;        // 左右兩孩子中選擇較大者，即m_heap[l+1]
 55         if(tmp >= m_heap[l])
 56             break;        //調整結束
 57         else
 58         {
 59             m_heap[c] = m_heap[l];
 60             c = l;
 61             l = 2*l + 1;   
 62         }       
 63     }   
 64     m_heap[c] = tmp;
 65 }
 66 
 67 /*
 68  * 刪除最大堆中的data
 69  *
 70  * 返回值：
 71  *      0，成功
 72  *     -1，失敗
 73  */
 74 int maxheap_remove(int data)
 75 {
 76     int index;
 77     // 如果"堆"已空，則返回-1
 78     if(m_size == 0)
 79         return -1;
 80 
 81     // 獲取data在陣列中的索引
 82     index = get_index(data); 
 83     if (index==-1)
 84         return -1;
 85 
 86     m_heap[index] = m_heap[--m_size];        // 用最後元素填補
 87     maxheap_filterdown(index, m_size-1);    // 從index位置開始自上向下調整為最大堆
 88 
 89     return 0;
 90 }
 91 
 92 /*
 93  * 最大堆的向上調整演算法(從start開始向上直到0，調整堆)
 94  *
 95  * 注：陣列實現的堆中，第N個節點的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
 96  *
 97  * 引數說明：
 98  *     start -- 被上調節點的起始位置(一般為陣列中最後一個元素的索引)
 99  */
100 static void maxheap_filterup(int start)
101 {
102     int c = start;            // 當前節點(current)的位置
103     int p = (c-1)/2;        // 父(parent)結點的位置 
104     int tmp = m_heap[c];        // 當前節點(current)的大小
105 
106     while(c > 0)
107     {
108         if(m_heap[p] >= tmp)
109             break;
110         else
111         {
112             m_heap[c] = m_heap[p];
113             c = p;
114             p = (p-1)/2;   
115         }       
116     }
117     m_heap[c] = tmp;
118 }
119   
120 /* 
121  * 將data插入到二叉堆中
122  *
123  * 返回值：
124  *     0，表示成功
125  *    -1，表示失敗
126  */
127 int maxheap_insert(int data)
128 {
129     // 如果"堆"已滿，則返回
130     if(m_size == m_capacity)
131         return -1;
132  
133     m_heap[m_size] = data;        // 將"陣列"插在表尾
134     maxheap_filterup(m_size);    // 向上調整堆
135     m_size++;                    // 堆的實際容量+1
136 
137     return 0;
138 }
139   
140 /* 
141  * 列印二叉堆
142  *
143  * 返回值：
144  *     0，表示成功
145  *    -1，表示失敗
146  */
147 void maxheap_print()
148 {
149     int i;
150     for (i=0; i<m_size; i++)
151         printf("%d ", m_heap[i]);
152 }
153     
154 void main()
155 {
156     int a[] = {10, 40, 30, 60, 90, 70, 20, 50, 80};
157     int i, len=LENGTH(a);
158 
159     printf("== 依次新增: ");
160     for(i=0; i<len; i++)
161     {
162         printf("%d ", a[i]);
163         maxheap_insert(a[i]);
164     }
165 
166     printf("\n== 最 大 堆: ");
167     maxheap_print();
168 
169     i=85;
170     maxheap_insert(i);
171     printf("\n== 新增元素: %d", i);
172     printf("\n== 最 大 堆: ");
173     maxheap_print();
174 
175     i=90;
176     maxheap_remove(i);
177     printf("\n== 刪除元素: %d", i);
178     printf("\n== 最 大 堆: ");
179     maxheap_print();
180     printf("\n");
181 }