ehlxr/hello-algo
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add C++ code for the chapter binary tree.

Browse Source
This commit is contained in:
Yudong Jin
2022-11-29 02:21:49 +08:00
parent 980eaf65e0
commit d2db8b8d60
14 changed files with 613 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
codes/cpp/chapter_searching/hashing_search.cpp
View File

@@ -40,7 +40,7 @@ int main() {
cout << "目标元素 3 的索引 = " << index << endl;
/* 哈希查找（链表） */
ListNode* head = vectorToLinkedList(nums);
ListNode* head = vecToLinkedList(nums);
// 初始化哈希表
unordered_map<int, ListNode*> map1;
while (head != nullptr) {

2
codes/cpp/chapter_searching/linear_search.cpp
View File

@@ -42,7 +42,7 @@ int main() {
cout << "目标元素 3 的索引 = " << index << endl;
/* 在链表中执行线性查找 */
ListNode* head = vectorToLinkedList(nums);
ListNode* head = vecToLinkedList(nums);
ListNode* node = linearSearch(head, target);
cout << "目标结点值 3 的对应结点对象为 " << node << endl;

2
codes/cpp/chapter_stack_and_queue/queue.cpp
View File

@@ -6,6 +6,8 @@
#include "../include/include.hpp"
/* Driver Code */
int main(){
/* 初始化队列 */
queue<int> queue;

10
codes/cpp/chapter_stack_and_queue/stack.cpp
View File

@@ -6,7 +6,9 @@
#include "../include/include.hpp"
int main(){
/* Driver Code */
int main() {
/* 初始化栈 */
stack<int> stack;
@@ -25,15 +27,15 @@ int main(){
/* 元素出栈 */
stack.pop();
cout<< "出栈元素 pop = " << top << "，出栈后 stack = ";
cout << "出栈元素 pop = " << top << "，出栈后 stack = ";
PrintUtil::printStack(stack);
/* 获取栈的长度 */
int size = stack.size();
cout<< "栈的长度 size = " << size << endl;
cout << "栈的长度 size = " << size << endl;
/* 判断是否为空 */
bool empty = stack.empty();
return 0;
}

146
codes/cpp/chapter_tree/binary_search_tree.cpp
View File

@@ -6,3 +6,149 @@
#include "../include/include.hpp"
/* 二叉搜索树 */
class BinarySearchTree {
private:
TreeNode* root;
public:
BinarySearchTree(vector<int> nums) {
sort(nums.begin(), nums.end()); // 排序数组
root = buildTree(nums, 0, nums.size() - 1); // 构建二叉搜索树
}
/* 获取二叉树根结点 */
TreeNode* getRoot() {
return root;
}
/* 构建二叉搜索树 */
TreeNode* buildTree(vector<int> nums, int i, int j) {
if (i > j) return nullptr;
// 将数组中间结点作为根结点
int mid = (i + j) / 2;
TreeNode* root = new TreeNode(nums[mid]);
// 递归建立左子树和右子树
root->left = buildTree(nums, i, mid - 1);
root->right = buildTree(nums, mid + 1, j);
return root;
}
/* 查找结点 */
TreeNode* search(int num) {
TreeNode* cur = root;
// 循环查找，越过叶结点后跳出
while (cur != nullptr) {
// 目标结点在 root 的右子树中
if (cur->val < num) cur = cur->right;
// 目标结点在 root 的左子树中
else if (cur->val > num) cur = cur->left;
// 找到目标结点，跳出循环
else break;
}
// 返回目标结点
return cur;
}
/* 插入结点 */
TreeNode* insert(int num) {
// 若树为空，直接提前返回
if (root == nullptr) return nullptr;
TreeNode *cur = root, *pre = nullptr;
// 循环查找，越过叶结点后跳出
while (cur != nullptr) {
// 找到重复结点，直接返回
if (cur->val == num) return nullptr;
pre = cur;
// 插入位置在 root 的右子树中
if (cur->val < num) cur = cur->right;
// 插入位置在 root 的左子树中
else cur = cur->left;
}
// 插入结点 val
TreeNode* node = new TreeNode(num);
if (pre->val < num) pre->right = node;
else pre->left = node;
return node;
}
/* 删除结点 */
TreeNode* remove(int num) {
// 若树为空，直接提前返回
if (root == nullptr) return nullptr;
TreeNode *cur = root, *pre = nullptr;
// 循环查找，越过叶结点后跳出
while (cur != nullptr) {
// 找到待删除结点，跳出循环
if (cur->val == num) break;
pre = cur;
// 待删除结点在 root 的右子树中
if (cur->val < num) cur = cur->right;
// 待删除结点在 root 的左子树中
else cur = cur->left;
}
// 若无待删除结点，则直接返回
if (cur == nullptr) return nullptr;
// 子结点数量 = 0 or 1
if (cur->left == nullptr || cur->right == nullptr) {
// 当子结点数量 = 0 / 1 时， child = nullptr / 该子结点
TreeNode* child = cur->left != nullptr ? cur->left : cur->right;
// 删除结点 cur
if (pre->left == cur) pre->left = child;
else pre->right = child;
}
// 子结点数量 = 2
else {
// 获取中序遍历中 cur 的下一个结点
TreeNode* nex = min(cur->right);
int tmp = nex->val;
// 递归删除结点 nex
remove(nex->val);
// 将 nex 的值复制给 cur
cur->val = tmp;
}
return cur;
}
/* 获取最小结点 */
TreeNode* min(TreeNode* root) {
if (root == nullptr) return root;
// 循环访问左子结点，直到叶结点时为最小结点，跳出
while (root->left != nullptr) {
root = root->left;
}
return root;
}
};
/* Driver Code */
int main() {
/* 初始化二叉搜索树 */
vector<int> nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
BinarySearchTree* bst = new BinarySearchTree(nums);
cout << endl << "初始化的二叉树为\n" << endl;
PrintUtil::printTree(bst->getRoot());
/* 查找结点 */
TreeNode* node = bst->search(5);
cout << endl << "查找到的结点对象为 " << node << "，结点值 = " << node->val << endl;
/* 插入结点 */
node = bst->insert(16);
cout << endl << "插入结点 16 后，二叉树为\n" << endl;
PrintUtil::printTree(bst->getRoot());
/* 删除结点 */
bst->remove(1);
cout << endl << "删除结点 1 后，二叉树为\n" << endl;
PrintUtil::printTree(bst->getRoot());
bst->remove(2);
cout << endl << "删除结点 2 后，二叉树为\n" << endl;
PrintUtil::printTree(bst->getRoot());
bst->remove(4);
cout << endl << "删除结点 4 后，二叉树为\n" << endl;
PrintUtil::printTree(bst->getRoot());
return 0;
}

32
codes/cpp/chapter_tree/binary_tree.cpp
View File

@@ -6,3 +6,35 @@
#include "../include/include.hpp"
/* Driver Code */
int main() {
/* 初始化二叉树 */
// 初始化结点
TreeNode* n1 = new TreeNode(1);
TreeNode* n2 = new TreeNode(2);
TreeNode* n3 = new TreeNode(3);
TreeNode* n4 = new TreeNode(4);
TreeNode* n5 = new TreeNode(5);
// 构建引用指向（即指针）
n1->left = n2;
n1->right = n3;
n2->left = n4;
n2->right = n5;
cout << endl << "初始化二叉树\n" << endl;
PrintUtil::printTree(n1);
/* 插入与删除结点 */
TreeNode* P = new TreeNode(0);
// 在 n1 -> n2 中间插入结点 P
n1->left = P;
P->left = n2;
cout << endl << "插入结点 P 后\n" << endl;
PrintUtil::printTree(n1);
// 删除结点 P
n1->left = n2;
cout << endl << "删除结点 P 后\n" << endl;
PrintUtil::printTree(n1);
return 0;
}

36
codes/cpp/chapter_tree/binary_tree_bfs.cpp
View File

@@ -6,3 +6,39 @@
#include "../include/include.hpp"
/* 层序遍历 */
vector<int> hierOrder(TreeNode* root) {
// 初始化队列，加入根结点
queue<TreeNode*> queue;
queue.push(root);
// 初始化一个列表，用于保存遍历序列
vector<int> vec;
while (!queue.empty()) {
TreeNode* node = queue.front();
queue.pop(); // 队列出队
vec.push_back(node->val); // 保存结点
if (node->left != NULL)
queue.push(node->left); // 左子结点入队
if (node->right != NULL)
queue.push(node->right); // 右子结点入队
}
return vec;
}
/* Driver Code */
int main() {
/* 初始化二叉树 */
// 这里借助了一个从数组直接生成二叉树的函数
TreeNode* root = vecToTree(vector<int>
{ 1, 2, 3, 4, 5, 6, 7, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX });
cout << endl << "初始化二叉树\n" << endl;
PrintUtil::printTree(root);
/* 层序遍历 */
vector<int> vec = hierOrder(root);
cout << endl << "层序遍历的结点打印序列 = ";
PrintUtil::printVector(vec);
return 0;
}

60
codes/cpp/chapter_tree/binary_tree_dfs.cpp
View File

@@ -6,3 +6,63 @@
#include "../include/include.hpp"
// 初始化列表，用于存储遍历序列
vector<int> vec;
/* 前序遍历 */
void preOrder(TreeNode* root) {
if (root == nullptr) return;
// 访问优先级：根结点 -> 左子树 -> 右子树
vec.push_back(root->val);
preOrder(root->left);
preOrder(root->right);
}
/* 中序遍历 */
void inOrder(TreeNode* root) {
if (root == nullptr) return;
// 访问优先级：左子树 -> 根结点 -> 右子树
inOrder(root->left);
vec.push_back(root->val);
inOrder(root->right);
}
/* 后序遍历 */
void postOrder(TreeNode* root) {
if (root == nullptr) return;
// 访问优先级：左子树 -> 右子树 -> 根结点
postOrder(root->left);
postOrder(root->right);
vec.push_back(root->val);
}
/* Driver Code */
int main() {
/* 初始化二叉树 */
// 这里借助了一个从数组直接生成二叉树的函数
TreeNode* root = vecToTree(vector<int>
{ 1, 2, 3, 4, 5, 6, 7, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX});
cout << endl << "初始化二叉树\n" << endl;
PrintUtil::printTree(root);
/* 前序遍历 */
vec.clear();
preOrder(root);
cout << endl << "前序遍历的结点打印序列 = ";
PrintUtil::printVector(vec);
/* 中序遍历 */
vec.clear();
inOrder(root);
cout << endl << "中序遍历的结点打印序列 = ";
PrintUtil::printVector(vec);
/* 后序遍历 */
vec.clear();
postOrder(root);
cout << endl << "后序遍历的结点打印序列 = ";
PrintUtil::printVector(vec);
return 0;
}

2
codes/cpp/include/ListNode.hpp
View File

@@ -25,7 +25,7 @@ struct ListNode {
* @param list
* @return ListNode*
*/
ListNode* vectorToLinkedList(vector<int>& list) {
ListNode* vecToLinkedList(vector<int> list) {
ListNode *dum = new ListNode(0);
ListNode *head = dum;
for (int val : list) {

23
codes/cpp/include/PrintUtil.hpp
View File

@@ -238,4 +238,27 @@ class PrintUtil {
}
cout << "[" + s.str() + "]" << '\n';
}
/**
* @brief
*
* @tparam T
* @param queue
*/
template <typename T>
static void printQueue(queue<T> &queue)
{
// Generate the string to print
ostringstream s;
bool flag = true;
while(!queue.empty()) {
if (flag) {
s << queue.front();
flag = false;
}
else s << ", " << queue.front();
queue.pop();
}
cout << "[" + s.str() + "]" << '\n';
}
};

2
codes/cpp/include/TreeNode.hpp
View File

@@ -23,7 +23,7 @@ struct TreeNode {
* @param list
* @return TreeNode*
*/
TreeNode* vectorToTree(vector<int>& list) {
TreeNode* vecToTree(vector<int> list) {
TreeNode *root = new TreeNode(list[0]);
queue<TreeNode*> que;
que.emplace(root);

1
codes/java/chapter_tree/binary_search_tree.java
View File

@@ -9,6 +9,7 @@ package chapter_tree;
import java.util.*;
import include.*;
/* 二叉搜索树 */
class BinarySearchTree {
private TreeNode root;