yetao
/
hello-algo
mirror of https://github.com/krahets/hello-algo.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Part Heap : Code Translation into C++ (my_heap.cpp) (#321)

Browse Source 
* 增加my_heap.cpp并补充对应的文档

* 修改heap.md

* Update my_heap.cpp

* Update heap.md

* Update my_heap.cpp

* Update my_heap.cpp

* Update heap.md

* Update my_heap.cpp

* Update my_heap.cpp

* Update heap.md

---------

Co-authored-by: Yudong Jin <krahets@163.com>
pull/322/head
LoneRanger 2 years ago committed by GitHub
parent e1abbcbf23
commit 0b16a9f6a9
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 92 additions and 98 deletions
Show Stats Download Patch File Download Diff File

103
codes/cpp/chapter_heap/my_heap.cpp
Unescape View File

@ -1,7 +1,7 @@
/** /**
* File: my_heap.cpp * File: my_heap.cpp
* Created Time: 2023-02-03 * Created Time: 2023-02-04
* Author: what-is-me (whatisme@outlook.jp) * Author: LoneRanger (836253168@qq.com), what-is-me (whatisme@outlook.jp)
*/ */
#include "../include/include.hpp" #include "../include/include.hpp"
@ -9,7 +9,7 @@
/* 最大堆类 */ /* 最大堆类 */
class MaxHeap { class MaxHeap {
private: private:
// 使用 vector 而非数组，这样无需考虑扩容问题 // 使用动态数组，这样无需考虑扩容问题
vector<int> maxHeap; vector<int> maxHeap;
/* 获取左子结点索引 */ /* 获取左子结点索引 */
@ -24,46 +24,38 @@ private:
/* 获取父结点索引 */ /* 获取父结点索引 */
int parent(int i) { int parent(int i) {
return (i - 1) / 2; // 向下整除 return (i - 1) / 2; // 向下取整
}
/* 交换元素 */
void swap(int i, int j) {
int a = maxHeap[i],
b = maxHeap[j],
tmp = a;
maxHeap[i] = b;
maxHeap[j] = tmp;
} }
/* 从结点 i 开始，从底至顶堆化 */ /* 从结点 i 开始，从底至顶堆化 */
void siftUp(int i) { void shifUp(int i) {
while (true) { while (true) {
// 获取结点 i 的父结点 // 获取结点 i 的父结点
int p = parent(i); int p = parent(i);
// 当“越过根结点”或“结点无需修复”时，结束堆化 // 当“越过根结点”或“结点无需修复”时，结束堆化
if (p < 0 || maxHeap[i] <= maxHeap[i]) if (p < 0 || maxHeap[i] <= maxHeap[p])
break; break;
// 交换两结点 // 交换两结点
swap(i, p); swap(maxHeap[i], maxHeap[p]);
// 循环向上堆化 // 循环向上堆化
i = p; i = p;
} }
} }
/* 从结点 i 开始，从顶至底堆化 */ /* 从结点 i 开始，从顶至底堆化 */
void siftDown(int i) { void shifDown(int i) {
while (true) { while (true) {
// 判断结点 i, l, r 中值最大的结点，记为 ma // 判断结点 i, l, r 中值最大的结点，记为 ma
int l = left(i), r = right(i), ma = i; int l = left(i), r = right(i), ma = i;
// 若结点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
if (l < size() && maxHeap[l] > maxHeap[ma]) if (l < size() && maxHeap[l] > maxHeap[ma])
ma = l; ma = l;
if (r < size() && maxHeap[r] > maxHeap[ma]) if (r < size() && maxHeap[r] > maxHeap[ma])
ma = r; ma = r;
// 若结点 i 最大或索引 l, r 越界，则无需继续堆化，跳出 // 若结点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
if (ma == i) break; if (ma == i)
// 交换两结点 break;
swap(i, ma); swap(maxHeap[i], maxHeap[ma]);
// 循环向下堆化 // 循环向下堆化
i = ma; i = ma;
} }
@ -71,7 +63,7 @@ private:
public: public:
/* 构造函数，建立空堆 */ /* 构造函数，建立空堆 */
MaxHeap() = default; MaxHeap() {}
/* 构造函数，根据输入列表建堆 */ /* 构造函数，根据输入列表建堆 */
MaxHeap(vector<int> nums) { MaxHeap(vector<int> nums) {
@ -79,7 +71,7 @@ public:
maxHeap = nums; maxHeap = nums;
// 堆化除叶结点以外的其他所有结点 // 堆化除叶结点以外的其他所有结点
for (int i = parent(size() - 1); i >= 0; i--) { for (int i = parent(size() - 1); i >= 0; i--) {
siftDown(i); shifDown(i);
} }
} }
@ -89,13 +81,13 @@ public:
} }
/* 判断堆是否为空 */ /* 判断堆是否为空 */
bool isEmpty() { bool empty() {
return size() == 0; return size() == 0;
} }
/* 访问堆顶元素 */ /* 访问堆顶元素 */
int peek() { int peek() {
return maxHeap.front(); return maxHeap[0];
} }
/* 元素入堆 */ /* 元素入堆 */
@ -103,74 +95,77 @@ public:
// 添加结点 // 添加结点
maxHeap.push_back(val); maxHeap.push_back(val);
// 从底至顶堆化 // 从底至顶堆化
siftUp(size() - 1); shifUp(size() - 1);
} }
/* 元素出堆 */ /* 元素出堆 */
int poll() { void poll() {
// 判空处理 // 判空处理
if (isEmpty()) if (empty()) {
throw out_of_range("堆已空\n"); cout << "Error:堆为空" << endl;
return;
}
// 交换根结点与最右叶结点（即交换首元素与尾元素） // 交换根结点与最右叶结点（即交换首元素与尾元素）
swap(0, size() - 1); swap(maxHeap[0], maxHeap[size() - 1]);
// 删除结点 // 删除结点
int val = maxHeap.back();
maxHeap.pop_back(); maxHeap.pop_back();
// 从顶至底堆化 // 从顶至底堆化
siftDown(0); shifDown(0);
// 返回堆顶元素
return val;
} }
/* 打印堆（二叉树） */ /* 打印堆（二叉树）*/
void print() { void print() {
cout << "堆的数组表示：" << endl; cout << "堆的数组表示：";
PrintUtil::printVector(this->maxHeap); PrintUtil::printVector(maxHeap);
cout << "堆的树状表示：" << endl; cout << "堆的树状表示：" << endl;
TreeNode *tree = vecToTree(this->maxHeap); TreeNode *root = vecToTree(maxHeap);
PrintUtil::printTree(tree); PrintUtil::printTree(root);
freeMemoryTree(tree);
} }
}; };
void testPush(MaxHeap &maxHeap, int val) {
maxHeap.push(val); // 元素入堆 void testPush(MaxHeap maxHeap, int val) {
maxHeap.push(val);
cout << "\n添加元素 " << val << " 后" << endl; cout << "\n添加元素 " << val << " 后" << endl;
maxHeap.print(); maxHeap.print();
} }
void testPoll(MaxHeap &maxHeap) { void testPop(MaxHeap maxHeap) {
int val = maxHeap.poll(); // 堆顶元素出堆 int val = maxHeap.peek();
cout << "出堆元素为 " << val << endl; maxHeap.poll();
cout << "\n出堆元素为 " << val << endl;
maxHeap.print(); maxHeap.print();
} }
/* Driver Code */
int main() { int main() {
/* 初始化大顶堆 */ /* 初始化大顶堆 */
MaxHeap maxHeap({9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2}); vector<int> vec{9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2};
MaxHeap maxheap(vec);
cout << "\n输入列表并建堆后" << endl; cout << "\n输入列表并建堆后" << endl;
maxHeap.print(); maxheap.print();
/* 获取堆顶元素 */ /* 获取堆顶元素 */
int peek = maxHeap.peek(); int peek = maxheap.peek();
cout << "\n堆顶元素为 " << peek << endl; cout << "\n堆顶元素为 " << peek << endl;
/* 元素入堆 */ /* 元素入堆 */
int val = 7; int val = 7;
maxHeap.push(val); maxheap.push(val);
cout << "\n元素 " << val << " 入堆后" << endl; cout << "\n元素 " << val << " 入堆后" << endl;
maxHeap.print(); maxheap.print();
/* 堆顶元素出堆 */ /* 堆顶元素出堆 */
peek = maxHeap.poll(); peek = maxheap.peek();
maxheap.poll();
cout << "\n堆顶元素 " << peek << " 出堆后" << endl; cout << "\n堆顶元素 " << peek << " 出堆后" << endl;
maxHeap.print(); maxheap.print();
/* 获取堆大小 */ /* 获取堆大小 */
int size = maxHeap.size(); int size = maxheap.size();
cout << "\n堆元素数量为 " << size << endl; cout << "\n堆元素数量为 " << size << endl;
/* 判断堆是否为空 */ /* 判断堆是否为空 */
bool isEmpty = maxHeap.isEmpty(); bool isEmpty = maxheap.empty();
cout << "\n堆是否为空 " << isEmpty << endl; cout << "\n堆是否为空 " << isEmpty << endl;
} }

2
codes/cpp/include/PrintUtil.hpp
Unescape View File

@ -1,7 +1,7 @@
/** /**
* File: PrintUtil.hpp * File: PrintUtil.hpp
* Created Time: 2021-12-19 * Created Time: 2021-12-19
* Author: Krahets (krahets@163.com), msk397 (machangxinq@gmail.com) * Author: Krahets (krahets@163.com), msk397 (machangxinq@gmail.com), LoneRanger(836253168@qq.com)
*/ */
#pragma once #pragma once

69
docs/chapter_heap/heap.md
Unescape View File

@ -29,11 +29,11 @@ comments: true
<div class="center-table" markdown> <div class="center-table" markdown>
| 方法 | 描述 | 时间复杂度 | | 方法 | 描述 | 时间复杂度 |
| --------- | -------------------------------------------- | ----------- | | --------- | ----------------------------------------- | ----------- |
| add() | 元素入堆 | $O(\log n)$ | | add() | 元素入堆 | $O(\log n)$ |
| poll() | 堆顶元素出堆 | $O(\log n)$ | | poll() | 堆顶元素出堆 | $O(\log n)$ |
| peek() | 访问堆顶元素（大 / 小顶堆分别为最大 / 小值） | $O(1)$ | | peek() | 访问堆顶元素（大 / 小顶堆分别为最大 / 小值） | $O(1)$ |
| size() | 获取堆的元素数量 | $O(1)$ | | size() | 获取堆的元素数量 | $O(1)$ |
| isEmpty() | 判断堆是否为空 | $O(1)$ | | isEmpty() | 判断堆是否为空 | $O(1)$ |
@ -287,7 +287,7 @@ comments: true
=== "C++" === "C++"
```cpp title="my_heap.cpp" ```cpp title="my_heap.cpp"
// 使用 vector 而非数组，这样无需考虑扩容问题 // 使用动态数组，这样无需考虑扩容问题
vector<int> maxHeap; vector<int> maxHeap;
/* 获取左子结点索引 */ /* 获取左子结点索引 */
@ -302,7 +302,7 @@ comments: true
/* 获取父结点索引 */ /* 获取父结点索引 */
int parent(int i) { int parent(int i) {
return (i - 1) / 2; // 向下整除 return (i - 1) / 2; // 向下取整
} }
``` ```
@ -418,7 +418,7 @@ comments: true
```cpp title="my_heap.cpp" ```cpp title="my_heap.cpp"
/* 访问堆顶元素 */ /* 访问堆顶元素 */
int peek() { int peek() {
return maxHeap.front(); return maxHeap[0];
} }
``` ```
@ -537,19 +537,19 @@ comments: true
// 添加结点 // 添加结点
maxHeap.push_back(val); maxHeap.push_back(val);
// 从底至顶堆化 // 从底至顶堆化
siftUp(size() - 1); shifUp(size() - 1);
} }
/* 从结点 i 开始，从底至顶堆化 */ /* 从结点 i 开始，从底至顶堆化 */
void siftUp(int i) { void shifUp(int i) {
while (true) { while (true) {
// 获取结点 i 的父结点 // 获取结点 i 的父结点
int p = parent(i); int p = parent(i);
// 当“越过根结点”或“结点无需修复”时，结束堆化 // 当“越过根结点”或“结点无需修复”时，结束堆化
if (p < 0 || maxHeap[i] <= maxHeap[i]) if (p < 0 || maxHeap[i] <= maxHeap[p])
break; break;
// 交换两结点 // 交换两结点
swap(i, p); swap(maxHeap[i], maxHeap[p]);
// 循环向上堆化 // 循环向上堆化
i = p; i = p;
} }
@ -731,39 +731,39 @@ comments: true
=== "C++" === "C++"
```cpp title="my_heap.cpp" ```cpp title="my_heap.cpp"
/* 元素出堆 */
int poll() {
// 判空处理
if (isEmpty())
throw out_of_range("堆已空\n");
// 交换根结点与最右叶结点（即交换首元素与尾元素）
swap(0, size() - 1);
// 删除结点
int val = maxHeap.back();
maxHeap.pop_back();
// 从顶至底堆化
siftDown(0);
// 返回堆顶元素
return val;
}
/* 从结点 i 开始，从顶至底堆化 */ /* 从结点 i 开始，从顶至底堆化 */
void siftDown(int i) { void shifDown(int i) {
while (true) { while (true) {
// 判断结点 i, l, r 中值最大的结点，记为 ma // 判断结点 i, l, r 中值最大的结点，记为 ma
int l = left(i), r = right(i), ma = i; int l = left(i), r = right(i), ma = i;
// 若结点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
if (l < size() && maxHeap[l] > maxHeap[ma]) if (l < size() && maxHeap[l] > maxHeap[ma])
ma = l; ma = l;
if (r < size() && maxHeap[r] > maxHeap[ma]) if (r < size() && maxHeap[r] > maxHeap[ma])
ma = r; ma = r;
// 若结点 i 最大或索引 l, r 越界，则无需继续堆化，跳出 // 若结点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
if (ma == i) break; if (ma == i)
// 交换两结点 break;
swap(i, ma); swap(maxHeap[i], maxHeap[ma]);
// 循环向下堆化 // 循环向下堆化
i = ma; i = ma;
} }
} }
/* 元素出堆 */
void poll() {
// 判空处理
if (empty()) {
cout << "Error:堆为空" << endl;
return;
}
// 交换根结点与最右叶结点（即交换首元素与尾元素）
swap(maxHeap[0], maxHeap[size() - 1]);
// 删除结点
maxHeap.pop_back();
// 从顶至底堆化
shifDown(0);
}
``` ```
=== "Python" === "Python"
@ -921,10 +921,9 @@ comments: true
maxHeap = nums; maxHeap = nums;
// 堆化除叶结点以外的其他所有结点 // 堆化除叶结点以外的其他所有结点
for (int i = parent(size() - 1); i >= 0; i--) { for (int i = parent(size() - 1); i >= 0; i--) {
siftDown(i); shifDown(i);
} }
} }
// Tip: std::make_heap() 函数可以原地建堆。
``` ```
=== "Python" === "Python"

Write Preview
Loading…
Cancel
Save