二叉堆（C++实现）
作者：互联网
堆简介:
堆（heap），是作为数据结构中的堆来讨论，而并非内存结构中的堆，堆本身可以被看作满足一些特定条件的树，其满足的性质如下：
1.堆必定是一颗完全树；
2.堆中任意节点的值总是不大于或不小于其子节点的值。
二叉堆:
二叉堆是一颗完全二叉树或者近似完全二叉树，根据其由上而下以大至小或者以小至大可以分为最大堆或者最小堆
通常我们使用数组来实现二叉堆， 当用数组来实现时，其父节点与子节点存在一定的位置关系，有两种不同的存储差异：即将堆的首元素存于数组的第零个位置还是第一个位置
*第一个元素在数组中索引为0时，其父节点与子节点关系如下：
(01) 索引为i的左孩子的索引是 (2*i+1);
(02) 索引为i的左孩子的索引是 (2*i+2);
(03) 索引为i的父结点的索引是 floor((i-1)/2);
*第一个元素在数组中索引为1时，其父节点与子节点关系如下：
(01) 索引为i的左孩子的索引是 (2*i);
(02) 索引为i的左孩子的索引是 (2*i+1);
(03) 索引为i的父结点的索引是 floor(i/2);
关于二叉堆的C++实现（包括最大堆与最小堆实现）：
最大堆实现：
1 /**
2 * 二叉堆(最大堆)
3 *
4 * @author skywang
5 * @date 2014/03/07
6 */
7
8 #include <iomanip>
9 #include <iostream>
10 using namespace std;
11
12 template <class T>
13 class MaxHeap{
14 private:
15 T *mHeap; // 数据
16 int mCapacity; // 总的容量
17 int mSize; // 实际容量
18
19 private:
20 // 最大堆的向下调整算法
21 void filterdown(int start, int end);
22 // 最大堆的向上调整算法(从start开始向上直到0，调整堆)
23 void filterup(int start);
24 public:
25 MaxHeap();
26 MaxHeap(int capacity);
27 ~MaxHeap();
28
29 // 返回data在二叉堆中的索引
30 int getIndex(T data);
31 // 删除最大堆中的data
32 int remove(T data);
33 // 将data插入到二叉堆中
34 int insert(T data);
35 // 打印二叉堆
36 void print();
37 };
38
39 /*
40 * 构造函数
41 */
42 template <class T>
43 MaxHeap<T>::MaxHeap()
44 {
45 new (this)MaxHeap(30);
46 }
47
48 template <class T>
49 MaxHeap<T>::MaxHeap(int capacity)
50 {
51 mSize = 0;
52 mCapacity = capacity;
53 mHeap = new T[mCapacity];
54 }
55 /*
56 * 析构函数
57 */
58 template <class T>
59 MaxHeap<T>::~MaxHeap()
60 {
61 mSize = 0;
62 mCapacity = 0;
63 delete[] mHeap;
64 }
65
66 /*
67 * 返回data在二叉堆中的索引
68 *
69 * 返回值：
70 * 存在 -- 返回data在数组中的索引
71 * 不存在 -- -1
72 */
73 template <class T>
74 int MaxHeap<T>::getIndex(T data)
75 {
76 for(int i=0; i<mSize; i++)
77 if (data==mHeap[i])
78 return i;
79
80 return -1;
81 }
82
83 /*
84 * 最大堆的向下调整算法
85 *
86 * 注：数组实现的堆中，第N个节点的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
87 *
88 * 参数说明：
89 * start -- 被下调节点的起始位置(一般为0，表示从第1个开始)
90 * end -- 截至范围(一般为数组中最后一个元素的索引)
91 */
92 template <class T>
93 void MaxHeap<T>::filterdown(int start, int end)
94 {
95 int c = start; // 当前(current)节点的位置
96 int l = 2*c + 1; // 左(left)孩子的位置
97 T tmp = mHeap[c]; // 当前(current)节点的大小
98
99 while(l <= end)
100 {
101 // "l"是左孩子，"l+1"是右孩子
102 if(l < end && mHeap[l] < mHeap[l+1])
103 l++; // 左右两孩子中选择较大者，即mHeap[l+1]
104 if(tmp >= mHeap[l])
105 break; //调整结束
106 else
107 {
108 mHeap[c] = mHeap[l];
109 c = l;
110 l = 2*l + 1;
111 }
112 }
113 mHeap[c] = tmp;
114 }
115
116 /*
117 * 删除最大堆中的data
118 *
119 * 返回值：
120 * 0，成功
121 * -1，失败
122 */
123 template <class T>
124 int MaxHeap<T>::remove(T data)
125 {
126 int index;
127 // 如果"堆"已空，则返回-1
128 if(mSize == 0)
129 return -1;
130
131 // 获取data在数组中的索引
132 index = getIndex(data);
133 if (index==-1)
134 return -1;
135
136 mHeap[index] = mHeap[--mSize]; // 用最后元素填补
137 filterdown(index, mSize-1); // 从index位置开始自上向下调整为最大堆
138
139 return 0;
140 }
141
142 /*
143 * 最大堆的向上调整算法(从start开始向上直到0，调整堆)
144 *
145 * 注：数组实现的堆中，第N个节点的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
146 *
147 * 参数说明：
148 * start -- 被上调节点的起始位置(一般为数组中最后一个元素的索引)
149 */
150 template <class T>
151 void MaxHeap<T>::filterup(int start)
152 {
153 int c = start; // 当前节点(current)的位置
154 int p = (c-1)/2; // 父(parent)结点的位置
155 T tmp = mHeap[c]; // 当前节点(current)的大小
156
157 while(c > 0)
158 {
159 if(mHeap[p] >= tmp)
160 break;
161 else
162 {
163 mHeap[c] = mHeap[p];
164 c = p;
165 p = (p-1)/2;
166 }
167 }
168 mHeap[c] = tmp;
169 }
170
171 /*
172 * 将data插入到二叉堆中
173 *
174 * 返回值：
175 * 0，表示成功
176 * -1，表示失败
177 */
178 template <class T>
179 int MaxHeap<T>::insert(T data)
180 {
181 // 如果"堆"已满，则返回
182 if(mSize == mCapacity)
183 return -1;
184
185 mHeap[mSize] = data; // 将"数组"插在表尾
186 filterup(mSize); // 向上调整堆
187 mSize++; // 堆的实际容量+1
188
189 return 0;
190 }
191
192 /*
193 * 打印二叉堆
194 *
195 * 返回值：
196 * 0，表示成功
197 * -1，表示失败
198 */
199 template <class T>
200 void MaxHeap<T>::print()
201 {
202 for (int i=0; i<mSize; i++)
203 cout << mHeap[i] << " ";
204 }
205
206 int main()
207 {
208 int a[] = {10, 40, 30, 60, 90, 70, 20, 50, 80};
209 int i, len=(sizeof(a)) / (sizeof(a[0])) ;
210 MaxHeap<int>* tree=new MaxHeap<int>();
211
212 cout << "== 依次添加: ";
213 for(i=0; i<len; i++)
214 {
215 cout << a[i] <<" ";
216 tree->insert(a[i]);
217 }
218
219 cout << "\n== 最 大 堆: ";
220 tree->print();
221
222 i=85;
223 tree->insert(i);
224 cout << "\n== 添加元素: " << i;
225 cout << "\n== 最 大 堆: ";
226 tree->print();
227
228 i=90;
229 tree->remove(i);
230 cout << "\n== 删除元素: " << i;
231 cout << "\n== 最 大 堆: ";
232 tree->print();
233 cout << endl;
234
235 return 0;
236 }
最小堆实现：
1 /**
2 * 二叉堆(最小堆)
3 *
4 * @author skywang
5 * @date 2014/03/07
6 */
7
8 #include <iomanip>
9 #include <iostream>
10 using namespace std;
11
12 template <class T>
13 class MinHeap{
14 private:
15 T *mHeap; // 数据
16 int mCapacity; // 总的容量
17 int mSize; // 实际容量
18
19 private:
20 // 最小堆的向下调整算法
21 void filterdown(int start, int end);
22 // 最小堆的向上调整算法(从start开始向上直到0，调整堆)
23 void filterup(int start);
24 public:
25 MinHeap();
26 MinHeap(int capacity);
27 ~MinHeap();
28
29 // 返回data在二叉堆中的索引
30 int getIndex(T data);
31 // 删除最小堆中的data
32 int remove(T data);
33 // 将data插入到二叉堆中
34 int insert(T data);
35 // 打印二叉堆
36 void print();
37 };
38
39 /*
40 * 构造函数
41 */
42 template <class T>
43 MinHeap<T>::MinHeap()
44 {
45 new (this)MinHeap(30);
46 }
47
48 template <class T>
49 MinHeap<T>::MinHeap(int capacity)
50 {
51 mSize = 0;
52 mCapacity = capacity;
53 mHeap = new T[mCapacity];
54 }
55 /*
56 * 析构函数
57 */
58 template <class T>
59 MinHeap<T>::~MinHeap()
60 {
61 mSize = 0;
62 mCapacity = 0;
63 delete[] mHeap;
64 }
65
66 /*
67 * 返回data在二叉堆中的索引
68 *
69 * 返回值：
70 * 存在 -- 返回data在数组中的索引
71 * 不存在 -- -1
72 */
73 template <class T>
74 int MinHeap<T>::getIndex(T data)
75 {
76 for(int i=0; i<mSize; i++)
77 if (data==mHeap[i])
78 return i;
79
80 return -1;
81 }
82
83 /*
84 * 最小堆的向下调整算法
85 *
86 * 注：数组实现的堆中，第N个节点的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
87 *
88 * 参数说明：
89 * start -- 被下调节点的起始位置(一般为0，表示从第1个开始)
90 * end -- 截至范围(一般为数组中最后一个元素的索引)
91 */
92 template <class T>
93 void MinHeap<T>::filterdown(int start, int end)
94 {
95 int c = start; // 当前(current)节点的位置
96 int l = 2*c + 1; // 左(left)孩子的位置
97 T tmp = mHeap[c]; // 当前(current)节点的大小
98
99 while(l <= end)
100 {
101 // "l"是左孩子，"l+1"是右孩子
102 if(l < end && mHeap[l] > mHeap[l+1])
103 l++; // 左右两孩子中选择较小者，即mHeap[l+1]
104 if(tmp <= mHeap[l])
105 break; //调整结束
106 else
107 {
108 mHeap[c] = mHeap[l];
109 c = l;
110 l = 2*l + 1;
111 }
112 }
113 mHeap[c] = tmp;
114 }
115
116 /*
117 * 删除最小堆中的data
118 *
119 * 返回值：
120 * 0，成功
121 * -1，失败
122 */
123 template <class T>
124 int MinHeap<T>::remove(T data)
125 {
126 int index;
127 // 如果"堆"已空，则返回-1
128 if(mSize == 0)
129 return -1;
130
131 // 获取data在数组中的索引
132 index = getIndex(data);
133 if (index==-1)
134 return -1;
135
136 mHeap[index] = mHeap[--mSize]; // 用最后元素填补
137 filterdown(index, mSize-1); // 从index号位置开始自上向下调整为最小堆
138
139 return 0;
140 }
141
142 /*
143 * 最小堆的向上调整算法(从start开始向上直到0，调整堆)
144 *
145 * 注：数组实现的堆中，第N个节点的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
146 *
147 * 参数说明：
148 * start -- 被上调节点的起始位置(一般为数组中最后一个元素的索引)
149 */
150 template <class T>
151 void MinHeap<T>::filterup(int start)
152 {
153 int c = start; // 当前节点(current)的位置
154 int p = (c-1)/2; // 父(parent)结点的位置
155 T tmp = mHeap[c]; // 当前节点(current)的大小
156
157 while(c > 0)
158 {
159 if(mHeap[p] <= tmp)
160 break;
161 else
162 {
163 mHeap[c] = mHeap[p];
164 c = p;
165 p = (p-1)/2;
166 }
167 }
168 mHeap[c] = tmp;
169 }
170
171 /*
172 * 将data插入到二叉堆中
173 *
174 * 返回值：
175 * 0，表示成功
176 * -1，表示失败
177 */
178 template <class T>
179 int MinHeap<T>::insert(T data)
180 {
181 // 如果"堆"已满，则返回
182 if(mSize == mCapacity)
183 return -1;
184
185 mHeap[mSize] = data; // 将"数组"插在表尾
186 filterup(mSize); // 向上调整堆
187 mSize++; // 堆的实际容量+1
188
189 return 0;
190 }
191
192 /*
193 * 打印二叉堆
194 *
195 * 返回值：
196 * 0，表示成功
197 * -1，表示失败
198 */
199 template <class T>
200 void MinHeap<T>::print()
201 {
202 for (int i=0; i<mSize; i++)
203 cout << mHeap[i] << " ";
204 }
205
206 int main()
207 {
208 int a[] = {80, 40, 30, 60, 90, 70, 10, 50, 20};
209 int i, len=(sizeof(a)) / (sizeof(a[0])) ;
210 MinHeap<int>* tree=new MinHeap<int>();
211
212 cout << "== 依次添加: ";
213 for(i=0; i<len; i++)
214 {
215 cout << a[i] <<" ";
216 tree->insert(a[i]);
217 }
218
219 cout << "\n== 最 小 堆: ";
220 tree->print();
221
222 i=15;
223 tree->insert(i);
224 cout << "\n== 添加元素: " << i;
225 cout << "\n== 最 小 堆: ";
226 tree->print();
227
228 i=10;
229 tree->remove(i);
230 cout << "\n== 删除元素: " << i;
231 cout << "\n== 最 小 堆: ";
232 tree->print();
233 cout << endl;
234
235 return 0;
236 }
标签：索引,实现,MaxHeap,C++,二叉,int,mSize,data,mHeap 来源： https://www.cnblogs.com/randouchant/p/binary_heap.html