From fe4af37290ad7216d1f51262698bd7aa1dae0c11 Mon Sep 17 00:00:00 2001 From: qualifier1024 <102360259+qualifier1024@users.noreply.github.com> Date: Mon, 28 Nov 2022 09:04:43 +0800 Subject: [PATCH 01/67] Update stack.cpp MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit array.cpp修改了格式问题 --- codes/cpp/chapter_stack_and_queue/stack.cpp | 34 +++++++++++++++++++-- 1 file changed, 32 insertions(+), 2 deletions(-) diff --git a/codes/cpp/chapter_stack_and_queue/stack.cpp b/codes/cpp/chapter_stack_and_queue/stack.cpp index 03cac3c5a..bac778c11 100644 --- a/codes/cpp/chapter_stack_and_queue/stack.cpp +++ b/codes/cpp/chapter_stack_and_queue/stack.cpp @@ -1,8 +1,38 @@ /* * File: stack.cpp - * Created Time: 2022-11-25 - * Author: Krahets (krahets@163.com) + * Created Time: 2022-11-28 + * Author: qualifier1024 (2539244001@qq.com) */ #include "../include/include.hpp" +int main(){ + /* 初始化栈 */ + stack stack; + + /* 元素入栈 */ + stack.push(1); + stack.push(3); + stack.push(2); + stack.push(5); + stack.push(4); + cout << "栈 stack = "; + PrintUtil::printStack(stack); + + /* 访问栈顶元素 */ + int top = stack.top(); + cout << "栈顶元素 top = " << top << endl; + + /* 元素出栈 */ + stack.pop(); + cout<< "出栈元素 pop = " << top << "，出栈后 stack = "; + PrintUtil::printStack(stack); + + /* 获取栈的长度 */ + int size = stack.size(); + cout<< "栈的长度 size = " << size << endl; + + /* 判断是否为空 */ + bool empty = stack.empty(); + return 0; +} From 26f9d6363e4621f1df1be4b1a40e1497885a3e13 Mon Sep 17 00:00:00 2001 From: qualifier1024 <102360259+qualifier1024@users.noreply.github.com> Date: Mon, 28 Nov 2022 09:32:05 +0800 Subject: [PATCH 02/67] Update PrintUtil.hpp MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 补充了stack打印方法，形式为"top->num1, num2]" 我不确定这么做是否规范 --- codes/cpp/include/PrintUtil.hpp | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/codes/cpp/include/PrintUtil.hpp b/codes/cpp/include/PrintUtil.hpp index b85da88ef..703c7b8fa 100644 --- a/codes/cpp/include/PrintUtil.hpp +++ b/codes/cpp/include/PrintUtil.hpp @@ -210,4 +210,34 @@ class PrintUtil { printTree(root->left, trunk, false); } + /** + * @brief Get the Stack String object + * + * @tparam T + * @param stack + * @return string + */ + template + static string getStackString(stack stack) { + ostringstream s; + if(!stack.empty()){ + s << stack.top(); + stack.pop(); + } + while(!stack.empty()){ + s << ", " << stack.top(); + stack.pop(); + } + return "top->" + s.str() + "]"; + } + /** + * @brief Print a stack + * + * @tparam T + * @param stack + */ + template + static void printStack(stack &stack) { + cout << getStackString(stack) << '\n'; + } }; From 06424ef0235d6fa469c39bb2ddc0c435a0f0f057 Mon Sep 17 00:00:00 2001 From: qualifier1024 <102360259+qualifier1024@users.noreply.github.com> Date: Mon, 28 Nov 2022 10:15:18 +0800 Subject: [PATCH 03/67] Update linkedlist_stack.cpp MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 仿写的链表栈 --- .../linkedlist_stack.cpp | 36 +++++++++++++++++-- 1 file changed, 34 insertions(+), 2 deletions(-) diff --git a/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp b/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp index b4fba44b0..489d2f3bb 100644 --- a/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp +++ b/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp @@ -1,8 +1,40 @@ /* * File: linkedlist_stack.cpp - * Created Time: 2022-11-25 - * Author: Krahets (krahets@163.com) + * Created Time: 2022-11-28 + * Author: qualifier1024 (2539244001@qq.com) */ #include "../include/include.hpp" +#include +/* 基于链表实现的栈 */ +class LinkedListStack { + list lst; +public: + LinkedListStack() { + // 初始化空链表 + lst.clear(); + } + /* 获取栈的长度 */ + int size() { + return lst.size(); + } + /* 判断栈是否为空 */ + bool isEmpty() { + return lst.empty(); + } + /* 入栈 */ + void push(int num) { + lst.push_back(num); + } + /* 出栈 */ + int pop() { + int oldTop = lst.back(); + lst.pop_back(); + return oldTop; + } + /* 访问栈顶元素 */ + int top() { + return lst.back(); + } +}; From 8b72cf5b35d3f6220de046a155d27d230633ddc3 Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Mon, 28 Nov 2022 20:22:21 +0800 Subject: [PATCH 04/67] Update stack.cpp --- codes/cpp/chapter_stack_and_queue/stack.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/codes/cpp/chapter_stack_and_queue/stack.cpp b/codes/cpp/chapter_stack_and_queue/stack.cpp index bac778c11..52d0b7730 100644 --- a/codes/cpp/chapter_stack_and_queue/stack.cpp +++ b/codes/cpp/chapter_stack_and_queue/stack.cpp @@ -34,5 +34,6 @@ int main(){ /* 判断是否为空 */ bool empty = stack.empty(); + return 0; } From a8afc963b6f6a9b6998b84d998226a6aeb7ffc4c Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Mon, 28 Nov 2022 20:51:12 +0800 Subject: [PATCH 05/67] Update PrintUtil.hpp Reverse the stack before printing. --- codes/cpp/include/PrintUtil.hpp | 44 ++++++++++++++++----------------- 1 file changed, 21 insertions(+), 23 deletions(-) diff --git a/codes/cpp/include/PrintUtil.hpp b/codes/cpp/include/PrintUtil.hpp index 703c7b8fa..f326f78d1 100644 --- a/codes/cpp/include/PrintUtil.hpp +++ b/codes/cpp/include/PrintUtil.hpp @@ -210,34 +210,32 @@ class PrintUtil { printTree(root->left, trunk, false); } - /** - * @brief Get the Stack String object - * - * @tparam T - * @param stack - * @return string - */ - template - static string getStackString(stack stack) { - ostringstream s; - if(!stack.empty()){ - s << stack.top(); - stack.pop(); - } - while(!stack.empty()){ - s << ", " << stack.top(); - stack.pop(); - } - return "top->" + s.str() + "]"; - } + /** * @brief Print a stack * * @tparam T - * @param stack + * @param stk */ template - static void printStack(stack &stack) { - cout << getStackString(stack) << '\n'; + static void printStack(stack &stk) { + // Reverse the input stack + stack tmp; + while(!stk.empty()) { + tmp.push(stk.top()); + stk.pop(); + } + // Generate the string to print + ostringstream s; + bool flag = true; + while(!tmp.empty()) { + if (flag) { + s << tmp.top(); + flag = false; + } + else s << ", " << tmp.top(); + tmp.pop(); + } + cout << "[" + s.str() + "]" << '\n'; } }; From 894d0dd64db214fc199594942c7c3c892faea540 Mon Sep 17 00:00:00 2001 From: qualifier1024 <102360259+qualifier1024@users.noreply.github.com> Date: Mon, 28 Nov 2022 21:07:55 +0800 Subject: [PATCH 06/67] Update queue.cpp MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 译自大佬的Java代码，更改了部分表述 --- codes/cpp/chapter_stack_and_queue/queue.cpp | 35 +++++++++++++++++++-- 1 file changed, 33 insertions(+), 2 deletions(-) diff --git a/codes/cpp/chapter_stack_and_queue/queue.cpp b/codes/cpp/chapter_stack_and_queue/queue.cpp index d76fca65d..c529a7c00 100644 --- a/codes/cpp/chapter_stack_and_queue/queue.cpp +++ b/codes/cpp/chapter_stack_and_queue/queue.cpp @@ -1,8 +1,39 @@ /* * File: queue.cpp - * Created Time: 2022-11-25 - * Author: Krahets (krahets@163.com) + * Created Time: 2022-11-28 + * Author: qualifier1024 (2539244001@qq.com) */ #include "../include/include.hpp" +int main(){ + /* 初始化队列 */ + queue queue; + + /* 元素入队 */ + queue.push(1); + queue.push(3); + queue.push(2); + queue.push(5); + queue.push(4); + cout << "队列 queue = "; + PrintUtil::printQueue(queue); + + /* 访问队首元素 */ + int front = queue.front(); + cout << "队首元素 front = " << front << endl; + + /* 元素出队 */ + queue.pop(); + cout << "出队元素 front = " << front << "，出队后 queue = "; + PrintUtil::printQueue(queue); + + /* 获取队列的长度 */ + int size = queue.size(); + cout << "队列长度 size = " << size << endl; + + /* 判断队列是否为空 */ + bool isEmpty = queue.empty(); + + return 0; +} From c18affcea39a282af835631eebaf6db95f5820ca Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Mon, 28 Nov 2022 21:08:10 +0800 Subject: [PATCH 07/67] Update linkedlist_stack.cpp Add test code. --- .../linkedlist_stack.cpp | 64 ++++++++++++++++--- 1 file changed, 54 insertions(+), 10 deletions(-) diff --git a/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp b/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp index 489d2f3bb..3fbfd0bd4 100644 --- a/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp +++ b/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp @@ -5,36 +5,80 @@ */ #include "../include/include.hpp" -#include /* 基于链表实现的栈 */ class LinkedListStack { - list lst; +private: + list list; public: LinkedListStack() { // 初始化空链表 - lst.clear(); + list.clear(); } /* 获取栈的长度 */ int size() { - return lst.size(); + return list.size(); } /* 判断栈是否为空 */ - bool isEmpty() { - return lst.empty(); + bool empty() { + return list.empty(); } /* 入栈 */ void push(int num) { - lst.push_back(num); + list.push_back(num); } /* 出栈 */ int pop() { - int oldTop = lst.back(); - lst.pop_back(); + int oldTop = list.back(); + list.pop_back(); return oldTop; } /* 访问栈顶元素 */ int top() { - return lst.back(); + return list.back(); + } + + /* 将 List 转化为 Array 并返回 */ + vector toVector() { + vector vec; + for (int num : list) { + vec.push_back(num); + } + return vec; } }; + + +/* Driver Code */ +int main() { + /* 初始化栈 */ + LinkedListStack* stack = new LinkedListStack(); + + /* 元素入栈 */ + stack->push(1); + stack->push(3); + stack->push(2); + stack->push(5); + stack->push(4); + cout << "栈 stack = "; + vector vec = stack->toVector(); + PrintUtil::printVector(vec); + + /* 访问栈顶元素 */ + int top = stack->top(); + cout << "栈顶元素 top = " << top << endl; + + /* 元素出栈 */ + int pop = stack->pop(); + cout << "出栈元素 pop = " << pop << "，出栈后 stack = "; + vec = stack->toVector(); + PrintUtil::printVector(vec); + + /* 获取栈的长度 */ + int size = stack->size(); + cout << "栈的长度 size = " << size << endl; + + /* 判断是否为空 */ + bool empty = stack->empty(); + cout << "栈是否为空 = " << empty << endl; +} From 30a115082b134c5301f179fa053bc5602dfa9b53 Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Mon, 28 Nov 2022 21:10:29 +0800 Subject: [PATCH 08/67] Update linkedlist_stack.cpp Remove constructor --- codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp | 4 ---- 1 file changed, 4 deletions(-) diff --git a/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp b/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp index 3fbfd0bd4..15eec8071 100644 --- a/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp +++ b/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp @@ -11,10 +11,6 @@ class LinkedListStack { private: list list; public: - LinkedListStack() { - // 初始化空链表 - list.clear(); - } /* 获取栈的长度 */ int size() { return list.size(); From f772e28acb68e717613c403d886e2f940099dc10 Mon Sep 17 00:00:00 2001 From: qualifier1024 <102360259+qualifier1024@users.noreply.github.com> Date: Mon, 28 Nov 2022 22:23:27 +0800 Subject: [PATCH 09/67] Update array_stack.cpp MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 仿照linkedlist_stack实现的array_stack,补上了测试代码 --- .../chapter_stack_and_queue/array_stack.cpp | 70 ++++++++++++++++++- 1 file changed, 68 insertions(+), 2 deletions(-) diff --git a/codes/cpp/chapter_stack_and_queue/array_stack.cpp b/codes/cpp/chapter_stack_and_queue/array_stack.cpp index e0112eda6..444376c6d 100644 --- a/codes/cpp/chapter_stack_and_queue/array_stack.cpp +++ b/codes/cpp/chapter_stack_and_queue/array_stack.cpp @@ -1,8 +1,74 @@ /* * File: array_stack.cpp - * Created Time: 2022-11-25 - * Author: Krahets (krahets@163.com) + * Created Time: 2022-11-28 + * Author: qualifier1024 (2539244001@qq.com) */ #include "../include/include.hpp" +/* 基于数组实现的栈 */ +class ArrayStack { +public: + vector vec; + + /* 获取栈的长度 */ + int size() { + return vec.size(); + } + + /* 判断栈是否为空 */ + bool empty() { + return vec.empty(); + } + + /* 入栈 */ + void push(int num) { + vec.push_back(num); + } + + /* 出栈 */ + int pop() { + int oldTop = vec.back(); + vec.pop_back(); + return oldTop; + } + + /* 访问栈顶元素 */ + int top() { + return vec.back(); + } +}; + +/* Driver Code */ +int main() { + /* 初始化栈 */ + ArrayStack* stack = new ArrayStack(); + + /* 元素入栈 */ + stack->push(1); + stack->push(3); + stack->push(2); + stack->push(5); + stack->push(4); + cout << "栈 stack = "; + PrintUtil::printVector(stack->vec); + + /* 访问栈顶元素 */ + int top = stack->top(); + cout << "栈顶元素 top = " << top << endl; + + /* 元素出栈 */ + int pop = stack->pop(); + cout << "出栈元素 pop = " << pop << "，出栈后 stack = "; + PrintUtil::printVector(stack->vec); + + /* 获取栈的长度 */ + int size = stack->size(); + cout << "栈的长度 size = " << size << endl; + + /* 判断是否为空 */ + bool empty = stack->empty(); + cout << "栈是否为空 = " << empty << endl; + + return 0; +} From 56ef5a71cdaf65eb50dded32992a2248ed803038 Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Tue, 29 Nov 2022 00:26:18 +0800 Subject: [PATCH 10/67] Update array_stack.cpp Make `vec` a private member. --- .../chapter_stack_and_queue/array_stack.cpp | 26 ++++++++++++------- 1 file changed, 17 insertions(+), 9 deletions(-) diff --git a/codes/cpp/chapter_stack_and_queue/array_stack.cpp b/codes/cpp/chapter_stack_and_queue/array_stack.cpp index 444376c6d..8b08e1763 100644 --- a/codes/cpp/chapter_stack_and_queue/array_stack.cpp +++ b/codes/cpp/chapter_stack_and_queue/array_stack.cpp @@ -8,37 +8,43 @@ /* 基于数组实现的栈 */ class ArrayStack { -public: +private: vector vec; - +public: /* 获取栈的长度 */ int size() { return vec.size(); } - + /* 判断栈是否为空 */ bool empty() { return vec.empty(); } - + /* 入栈 */ void push(int num) { vec.push_back(num); } - + /* 出栈 */ int pop() { int oldTop = vec.back(); vec.pop_back(); return oldTop; } - + /* 访问栈顶元素 */ int top() { return vec.back(); } + + /* 返回 Vector */ + vector toVector() { + return vec; + } }; + /* Driver Code */ int main() { /* 初始化栈 */ @@ -51,7 +57,8 @@ int main() { stack->push(5); stack->push(4); cout << "栈 stack = "; - PrintUtil::printVector(stack->vec); + vector vec = stack->toVector(); + PrintUtil::printVector(vec); /* 访问栈顶元素 */ int top = stack->top(); @@ -60,7 +67,8 @@ int main() { /* 元素出栈 */ int pop = stack->pop(); cout << "出栈元素 pop = " << pop << "，出栈后 stack = "; - PrintUtil::printVector(stack->vec); + vec = stack->toVector(); + PrintUtil::printVector(vec); /* 获取栈的长度 */ int size = stack->size(); @@ -69,6 +77,6 @@ int main() { /* 判断是否为空 */ bool empty = stack->empty(); cout << "栈是否为空 = " << empty << endl; - + return 0; } From 980eaf65e0908ec275aac7ff4a44fe3f58cb321a Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Tue, 29 Nov 2022 00:37:07 +0800 Subject: [PATCH 11/67] Add a lib in include.hpp --- codes/cpp/include/include.hpp | 1 + 1 file changed, 1 insertion(+) diff --git a/codes/cpp/include/include.hpp b/codes/cpp/include/include.hpp index 66404a1c9..28eab2cdf 100644 --- a/codes/cpp/include/include.hpp +++ b/codes/cpp/include/include.hpp @@ -9,6 +9,7 @@ #include #include #include +#include #include #include #include From d2db8b8d60ebbd9f7ea2b86da8bd7c1658b8777d Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Tue, 29 Nov 2022 02:21:49 +0800 Subject: [PATCH 12/67] Add C++ code for the chapter binary tree. --- .../cpp/chapter_searching/hashing_search.cpp | 2 +- codes/cpp/chapter_searching/linear_search.cpp | 2 +- codes/cpp/chapter_stack_and_queue/queue.cpp | 2 + codes/cpp/chapter_stack_and_queue/stack.cpp | 10 +- codes/cpp/chapter_tree/binary_search_tree.cpp | 146 ++++++++++++++ codes/cpp/chapter_tree/binary_tree.cpp | 32 ++++ codes/cpp/chapter_tree/binary_tree_bfs.cpp | 36 ++++ codes/cpp/chapter_tree/binary_tree_dfs.cpp | 60 ++++++ codes/cpp/include/ListNode.hpp | 2 +- codes/cpp/include/PrintUtil.hpp | 23 +++ codes/cpp/include/TreeNode.hpp | 2 +- .../java/chapter_tree/binary_search_tree.java | 1 + docs/chapter_tree/binary_search_tree.md | 134 ++++++++++++- docs/chapter_tree/binary_tree.md | 178 +++++++++++++++++- 14 files changed, 613 insertions(+), 17 deletions(-) diff --git a/codes/cpp/chapter_searching/hashing_search.cpp b/codes/cpp/chapter_searching/hashing_search.cpp index ee37a18b9..674376ff0 100644 --- a/codes/cpp/chapter_searching/hashing_search.cpp +++ b/codes/cpp/chapter_searching/hashing_search.cpp @@ -40,7 +40,7 @@ int main() { cout << "目标元素 3 的索引 = " << index << endl; /* 哈希查找（链表） */ - ListNode* head = vectorToLinkedList(nums); + ListNode* head = vecToLinkedList(nums); // 初始化哈希表 unordered_map map1; while (head != nullptr) { diff --git a/codes/cpp/chapter_searching/linear_search.cpp b/codes/cpp/chapter_searching/linear_search.cpp index c2de81694..e1f2a567b 100644 --- a/codes/cpp/chapter_searching/linear_search.cpp +++ b/codes/cpp/chapter_searching/linear_search.cpp @@ -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; diff --git a/codes/cpp/chapter_stack_and_queue/queue.cpp b/codes/cpp/chapter_stack_and_queue/queue.cpp index c529a7c00..ccaefb1ef 100644 --- a/codes/cpp/chapter_stack_and_queue/queue.cpp +++ b/codes/cpp/chapter_stack_and_queue/queue.cpp @@ -6,6 +6,8 @@ #include "../include/include.hpp" + +/* Driver Code */ int main(){ /* 初始化队列 */ queue queue; diff --git a/codes/cpp/chapter_stack_and_queue/stack.cpp b/codes/cpp/chapter_stack_and_queue/stack.cpp index 52d0b7730..91cff9400 100644 --- a/codes/cpp/chapter_stack_and_queue/stack.cpp +++ b/codes/cpp/chapter_stack_and_queue/stack.cpp @@ -6,7 +6,9 @@ #include "../include/include.hpp" -int main(){ + +/* Driver Code */ +int main() { /* 初始化栈 */ stack 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; } diff --git a/codes/cpp/chapter_tree/binary_search_tree.cpp b/codes/cpp/chapter_tree/binary_search_tree.cpp index 601f89a61..246bdbaa1 100644 --- a/codes/cpp/chapter_tree/binary_search_tree.cpp +++ b/codes/cpp/chapter_tree/binary_search_tree.cpp @@ -6,3 +6,149 @@ #include "../include/include.hpp" +/* 二叉搜索树 */ +class BinarySearchTree { +private: + TreeNode* root; + +public: + BinarySearchTree(vector nums) { + sort(nums.begin(), nums.end()); // 排序数组 + root = buildTree(nums, 0, nums.size() - 1); // 构建二叉搜索树 + } + + /* 获取二叉树根结点 */ + TreeNode* getRoot() { + return root; + } + + /* 构建二叉搜索树 */ + TreeNode* buildTree(vector 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 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; +} diff --git a/codes/cpp/chapter_tree/binary_tree.cpp b/codes/cpp/chapter_tree/binary_tree.cpp index 8235cf912..3258d9cfc 100644 --- a/codes/cpp/chapter_tree/binary_tree.cpp +++ b/codes/cpp/chapter_tree/binary_tree.cpp @@ -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; +} diff --git a/codes/cpp/chapter_tree/binary_tree_bfs.cpp b/codes/cpp/chapter_tree/binary_tree_bfs.cpp index 9fd2faf7d..ce0072b37 100644 --- a/codes/cpp/chapter_tree/binary_tree_bfs.cpp +++ b/codes/cpp/chapter_tree/binary_tree_bfs.cpp @@ -6,3 +6,39 @@ #include "../include/include.hpp" +/* 层序遍历 */ +vector hierOrder(TreeNode* root) { + // 初始化队列，加入根结点 + queue queue; + queue.push(root); + // 初始化一个列表，用于保存遍历序列 + vector 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 + { 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 vec = hierOrder(root); + cout << endl << "层序遍历的结点打印序列 = "; + PrintUtil::printVector(vec); + + return 0; +} diff --git a/codes/cpp/chapter_tree/binary_tree_dfs.cpp b/codes/cpp/chapter_tree/binary_tree_dfs.cpp index e38c4ada7..08a0a331e 100644 --- a/codes/cpp/chapter_tree/binary_tree_dfs.cpp +++ b/codes/cpp/chapter_tree/binary_tree_dfs.cpp @@ -6,3 +6,63 @@ #include "../include/include.hpp" +// 初始化列表，用于存储遍历序列 +vector 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 + { 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; +} diff --git a/codes/cpp/include/ListNode.hpp b/codes/cpp/include/ListNode.hpp index 47beb36a2..bd91f2558 100644 --- a/codes/cpp/include/ListNode.hpp +++ b/codes/cpp/include/ListNode.hpp @@ -25,7 +25,7 @@ struct ListNode { * @param list * @return ListNode* */ -ListNode* vectorToLinkedList(vector& list) { +ListNode* vecToLinkedList(vector list) { ListNode *dum = new ListNode(0); ListNode *head = dum; for (int val : list) { diff --git a/codes/cpp/include/PrintUtil.hpp b/codes/cpp/include/PrintUtil.hpp index f326f78d1..06f2f63ff 100644 --- a/codes/cpp/include/PrintUtil.hpp +++ b/codes/cpp/include/PrintUtil.hpp @@ -238,4 +238,27 @@ class PrintUtil { } cout << "[" + s.str() + "]" << '\n'; } + + /** + * @brief + * + * @tparam T + * @param queue + */ + template + static void printQueue(queue &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'; + } }; diff --git a/codes/cpp/include/TreeNode.hpp b/codes/cpp/include/TreeNode.hpp index 7c8f1708d..614d7992b 100644 --- a/codes/cpp/include/TreeNode.hpp +++ b/codes/cpp/include/TreeNode.hpp @@ -23,7 +23,7 @@ struct TreeNode { * @param list * @return TreeNode* */ -TreeNode* vectorToTree(vector& list) { +TreeNode* vecToTree(vector list) { TreeNode *root = new TreeNode(list[0]); queue que; que.emplace(root); diff --git a/codes/java/chapter_tree/binary_search_tree.java b/codes/java/chapter_tree/binary_search_tree.java index f39f3d1c7..0770c567d 100644 --- a/codes/java/chapter_tree/binary_search_tree.java +++ b/codes/java/chapter_tree/binary_search_tree.java @@ -9,6 +9,7 @@ package chapter_tree; import java.util.*; import include.*; +/* 二叉搜索树 */ class BinarySearchTree { private TreeNode root; diff --git a/docs/chapter_tree/binary_search_tree.md b/docs/chapter_tree/binary_search_tree.md index 07e547f0a..8b0f9ba0d 100644 --- a/docs/chapter_tree/binary_search_tree.md +++ b/docs/chapter_tree/binary_search_tree.md @@ -59,12 +59,43 @@ comments: true } ``` +=== "C++" + + ```cpp title="binary_search_tree.cpp" + /* 查找结点 */ + 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; + } + ``` + +=== "Python" + + ```python title="binary_search_tree.py" + + ``` + +=== "Go" + + ```go title="binary_search_tree.go" + + ``` + ### 插入结点 给定一个待插入元素 `num` ，为了保持二叉搜索树 “左子树 < 根结点 < 右子树” 的性质，插入操作分为两步： 1. **查找插入位置：** 与查找操作类似，我们从根结点出发，根据当前结点值和 `num` 的大小关系循环向下搜索，直到越过叶结点（遍历到 $\text{null}$ ）时跳出循环； - 2. **在该位置插入结点：** 初始化结点 `num` ，将该结点放到 $\text{null}$ 的位置 ； 二叉搜索树不允许存在重复结点，否则将会违背其定义。因此若待插入结点在树中已经存在，则不执行插入，直接返回即可。 @@ -97,6 +128,44 @@ comments: true } ``` +=== "C++" + + ```cpp title="binary_search_tree.cpp" + /* 插入结点 */ + 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; + } + ``` + +=== "Python" + + ```python title="binary_search_tree.py" + + ``` + +=== "Go" + + ```go title="binary_search_tree.go" + + ``` + 为了插入结点，需要借助 **辅助结点 `prev`** 保存上一轮循环的结点，这样在遍历到 $\text{null}$ 时，我们也可以获取到其父结点，从而完成结点插入操作。 与查找结点相同，插入结点使用 $O(\log n)$ 时间。 @@ -188,6 +257,69 @@ comments: true } ``` +=== "C++" + + ```cpp title="binary_search_tree.cpp" + /* 删除结点 */ + 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; + } + ``` + +=== "Python" + + ```python title="binary_search_tree.py" + + ``` + +=== "Go" + + ```go title="binary_search_tree.go" + + ``` + ## 二叉搜索树的优势 假设给定 $n$ 个数字，最常用的存储方式是「数组」，那么对于这串乱序的数字，常见操作的效率为： diff --git a/docs/chapter_tree/binary_tree.md b/docs/chapter_tree/binary_tree.md index e96e3b8a7..422b259e5 100644 --- a/docs/chapter_tree/binary_tree.md +++ b/docs/chapter_tree/binary_tree.md @@ -18,6 +18,35 @@ comments: true } ``` +=== "C++" + + ```cpp + /* 链表结点结构体 */ + struct TreeNode { + int val; // 结点值 + TreeNode *left; // 左子结点指针 + TreeNode *right; // 右子结点指针 + TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} + }; + ``` + +=== "Python" + + ```python + """ 链表结点类 """ + class TreeNode: + def __init__(self, val=0, left=None, right=None): + self.val = val # 结点值 + self.left = left # 左子结点指针 + self.right = right # 右子结点指针 + ``` + +=== "Go" + + ```go + + ``` + 结点的两个指针分别指向「左子结点 Left Child Node」和「右子结点 Right Child Node」，并且称该结点为两个子结点的「父结点 Parent Node」。给定二叉树某结点，将左子结点以下的树称为该结点的「左子树 Left Subtree」，右子树同理。 ![binary_tree_definition](binary_tree.assets/binary_tree_definition.png) @@ -84,20 +113,75 @@ comments: true n2.right = n5; ``` +=== "C++" + + ```cpp title="binary_tree.cpp" + /* 初始化二叉树 */ + // 初始化结点 + 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; + ``` + +=== "Python" + + ```python title="binary_tree.py" + + ``` + +=== "Go" + + ```go title="binary_tree.go" + + ``` + **插入与删除结点。** 与链表类似，插入与删除结点都可以通过修改指针实现。 ![binary_tree_add_remove](binary_tree.assets/binary_tree_add_remove.png)

Fig. 在二叉树中插入与删除结点

-```java title="binary_tree.java" -TreeNode P = new TreeNode(0); -// 在 n1 -> n2 中间插入结点 P -n1.left = P; -P.left = n2; -// 删除结点 P -n1.left = n2; -``` +=== "Java" + + ```java title="binary_tree.java" + TreeNode P = new TreeNode(0); + // 在 n1 -> n2 中间插入结点 P + n1.left = P; + P.left = n2; + // 删除结点 P + n1.left = n2; + ``` + +=== "C++" + + ```cpp title="binary_tree.cpp" + /* 插入与删除结点 */ + TreeNode* P = new TreeNode(0); + // 在 n1 -> n2 中间插入结点 P + n1->left = P; + P->left = n2; + // 删除结点 P + n1->left = n2; + ``` + +=== "Python" + + ```python title="binary_tree.py" + + ``` + +=== "Go" + + ```go title="binary_tree.go" + + ``` !!! note @@ -140,6 +224,41 @@ n1.left = n2; } ``` +=== "C++" + + ```cpp title="binary_tree_bfs.cpp" + /* 层序遍历 */ + vector hierOrder(TreeNode* root) { + // 初始化队列，加入根结点 + queue queue; + queue.push(root); + // 初始化一个列表，用于保存遍历序列 + vector 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; + } + ``` + +=== "Python" + + ```python title="binary_tree_bfs.py" + + ``` + +=== "Go" + + ```go title="binary_tree_bfs.go" + + ``` + ### 前序、中序、后序遍历 相对地，前、中、后序遍历皆属于「深度优先遍历 Depth-First Traversal」，其体现着一种 “先走到尽头，再回头继续” 的回溯遍历方式。 @@ -191,6 +310,49 @@ n1.left = n2; } ``` +=== "C++" + + ```cpp title="binary_tree_dfs.cpp" + /* 前序遍历 */ + 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); + } + ``` + +=== "Python" + + ```python title="binary_tree_dfs.py" + + ``` + +=== "Go" + + ```go title="binary_tree_dfs.go" + + ``` + !!! note 使用循环一样可以实现前、中、后序遍历，但代码相对繁琐，有兴趣的同学可以自行实现。 From cce8201e2b4a69e8781112ed3430419a79280e46 Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Tue, 29 Nov 2022 03:19:08 +0800 Subject: [PATCH 13/67] Add a comment file header. --- docs/chapter_stack_and_queue/deque.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/docs/chapter_stack_and_queue/deque.md b/docs/chapter_stack_and_queue/deque.md index 6a05c3c19..eef13e7f5 100644 --- a/docs/chapter_stack_and_queue/deque.md +++ b/docs/chapter_stack_and_queue/deque.md @@ -1,3 +1,7 @@ +--- +comments: true +--- + # 双向队列 对于队列，我们只能在头部删除或在尾部添加元素，而「双向队列 Deque」更加灵活，在其头部和尾部都能执行元素添加或删除操作。 From 3fc3475af4878edb7e7feae7d11b63756f057930 Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Tue, 29 Nov 2022 03:21:02 +0800 Subject: [PATCH 14/67] NULL to nullptr --- codes/cpp/chapter_tree/binary_tree_bfs.cpp | 4 ++-- docs/chapter_tree/binary_tree.md | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/codes/cpp/chapter_tree/binary_tree_bfs.cpp b/codes/cpp/chapter_tree/binary_tree_bfs.cpp index ce0072b37..eeec2a18e 100644 --- a/codes/cpp/chapter_tree/binary_tree_bfs.cpp +++ b/codes/cpp/chapter_tree/binary_tree_bfs.cpp @@ -17,9 +17,9 @@ vector hierOrder(TreeNode* root) { TreeNode* node = queue.front(); queue.pop(); // 队列出队 vec.push_back(node->val); // 保存结点 - if (node->left != NULL) + if (node->left != nullptr) queue.push(node->left); // 左子结点入队 - if (node->right != NULL) + if (node->right != nullptr) queue.push(node->right); // 右子结点入队 } return vec; diff --git a/docs/chapter_tree/binary_tree.md b/docs/chapter_tree/binary_tree.md index 422b259e5..58034b18e 100644 --- a/docs/chapter_tree/binary_tree.md +++ b/docs/chapter_tree/binary_tree.md @@ -238,9 +238,9 @@ comments: true TreeNode* node = queue.front(); queue.pop(); // 队列出队 vec.push_back(node->val); // 保存结点 - if (node->left != NULL) + if (node->left != nullptr) queue.push(node->left); // 左子结点入队 - if (node->right != NULL) + if (node->right != nullptr) queue.push(node->right); // 右子结点入队 } return vec; From 193f67f99e5073e8093bdf84223fb0c3868c729f Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Tue, 29 Nov 2022 03:26:50 +0800 Subject: [PATCH 15/67] Update binary search --- docs/chapter_searching/binary_search.md | 29 ++++++++++++++++++++----- 1 file changed, 23 insertions(+), 6 deletions(-) diff --git a/docs/chapter_searching/binary_search.md b/docs/chapter_searching/binary_search.md index 80709cdc3..59b7598bc 100644 --- a/docs/chapter_searching/binary_search.md +++ b/docs/chapter_searching/binary_search.md @@ -169,12 +169,29 @@ $$ 当数组长度很大时，加法 $i + j$ 的结果有可能会超出 `int` 类型的取值范围。在此情况下，我们需要换一种计算中点的写法。 -```java -// (i + j) 有可能超出 int 的取值范围 -int m = (i + j) / 2; -// 更换为此写法则不会越界 -int m = i + (j - i) / 2; -``` +=== "Java" + + ```java + // (i + j) 有可能超出 int 的取值范围 + int m = (i + j) / 2; + // 更换为此写法则不会越界 + int m = i + (j - i) / 2; + ``` +=== "C++" + + ```cpp + // (i + j) 有可能超出 int 的取值范围 + int m = (i + j) / 2; + // 更换为此写法则不会越界 + int m = i + (j - i) / 2; + ``` + +=== "Python" + + ```py + # Python 中的数字理论上可以无限大（取决于内存） + # 因此无需考虑大数越界问题 + ``` ## 复杂度分析 From d9e4b21e4f13899eed557b9961e786b395d67de4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=BD=AD=E7=90=9B?= <66410605+pengchzn@users.noreply.github.com> Date: Tue, 29 Nov 2022 10:15:45 +0800 Subject: [PATCH 16/67] Update stack.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 197行处，“站栈顶”笔误 --- docs/chapter_stack_and_queue/stack.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/chapter_stack_and_queue/stack.md b/docs/chapter_stack_and_queue/stack.md index f02e8a0f0..aa0b3128f 100644 --- a/docs/chapter_stack_and_queue/stack.md +++ b/docs/chapter_stack_and_queue/stack.md @@ -194,4 +194,4 @@ comments: true - **浏览器中的后退与前进、软件中的撤销与反撤销。** 每当我们打开新的网页，浏览器就讲上一个网页执行入栈，这样我们就可以通过「后退」操作来回到上一页面，后退操作实际上是在执行出栈。如果要同时支持后退和前进，那么则需要两个栈来配合实现。 -- **程序内存管理。** 每当调用函数时，系统就会站栈顶添加一个栈帧，用来记录函数的上下文信息。在递归函数中，向下递推会不断执行入栈，向上回溯阶段时出栈。 +- **程序内存管理。** 每当调用函数时，系统就会在栈顶添加一个栈帧，用来记录函数的上下文信息。在递归函数中，向下递推会不断执行入栈，向上回溯阶段时出栈。 From 67409cdb12dd39b27b8f358b95ab44ba1af4097f Mon Sep 17 00:00:00 2001 From: reanon <793584285@qq.com> Date: Tue, 29 Nov 2022 00:48:01 +0800 Subject: [PATCH 17/67] fix(tree): amend tree in golang --- codes/go/chapter_tree/binary_search_tree.go | 3 ++- codes/go/chapter_tree/binary_tree_bfs.go | 1 + codes/go/chapter_tree/binary_tree_test.go | 3 ++- 3 files changed, 5 insertions(+), 2 deletions(-) diff --git a/codes/go/chapter_tree/binary_search_tree.go b/codes/go/chapter_tree/binary_search_tree.go index 26eb94d73..ac14e798d 100644 --- a/codes/go/chapter_tree/binary_search_tree.go +++ b/codes/go/chapter_tree/binary_search_tree.go @@ -5,8 +5,9 @@ package chapter_tree import ( - . "github.com/krahets/hello-algo/pkg" "sort" + + . "github.com/krahets/hello-algo/pkg" ) type BinarySearchTree struct { diff --git a/codes/go/chapter_tree/binary_tree_bfs.go b/codes/go/chapter_tree/binary_tree_bfs.go index d04102f99..5c07a96bc 100644 --- a/codes/go/chapter_tree/binary_tree_bfs.go +++ b/codes/go/chapter_tree/binary_tree_bfs.go @@ -6,6 +6,7 @@ package chapter_tree import ( "container/list" + . "github.com/krahets/hello-algo/pkg" ) diff --git a/codes/go/chapter_tree/binary_tree_test.go b/codes/go/chapter_tree/binary_tree_test.go index 2c05076db..03a85539a 100644 --- a/codes/go/chapter_tree/binary_tree_test.go +++ b/codes/go/chapter_tree/binary_tree_test.go @@ -5,8 +5,9 @@ package chapter_tree import ( - . "github.com/krahets/hello-algo/pkg" "testing" + + . "github.com/krahets/hello-algo/pkg" ) func TestBinaryTree(t *testing.T) { From 27e4402ecaf452904a0525ad253def305852e364 Mon Sep 17 00:00:00 2001 From: reanon <793584285@qq.com> Date: Tue, 29 Nov 2022 01:09:12 +0800 Subject: [PATCH 18/67] feat(stack): implement stack in golang code --- .../go/chapter_stack_and_queue/array_stack.go | 73 +++++++++++++++ .../linkedlist_stack.go | 79 ++++++++++++++++ codes/go/chapter_stack_and_queue/stack.go | 18 ++++ .../go/chapter_stack_and_queue/stack_test.go | 93 +++++++++++++++++++ 4 files changed, 263 insertions(+) create mode 100644 codes/go/chapter_stack_and_queue/array_stack.go create mode 100644 codes/go/chapter_stack_and_queue/linkedlist_stack.go create mode 100644 codes/go/chapter_stack_and_queue/stack.go create mode 100644 codes/go/chapter_stack_and_queue/stack_test.go diff --git a/codes/go/chapter_stack_and_queue/array_stack.go b/codes/go/chapter_stack_and_queue/array_stack.go new file mode 100644 index 000000000..f3a8a287d --- /dev/null +++ b/codes/go/chapter_stack_and_queue/array_stack.go @@ -0,0 +1,73 @@ +// File: array_stack.go +// Created Time: 2022-11-26 +// Author: Reanon (793584285@qq.com) + +package chapter_stack_and_queue + +import ( + "fmt" + "strconv" + "strings" +) + +// ArrayStack 基于数组实现的栈 +type ArrayStack struct { + data []int // 数据 +} + +func NewArrayStack() *ArrayStack { + return &ArrayStack{ + // 设置栈的长度为 0，容量为 16 + data: make([]int, 0, 16), + } +} + +// Size 栈的长度 +func (s *ArrayStack) Size() int { + return len(s.data) +} + +// IsEmpty 栈是否为空 +func (s *ArrayStack) IsEmpty() bool { + return s.Size() == 0 +} + +// Push 入栈 +func (s *ArrayStack) Push(v int) { + // 切片会自动扩容 + s.data = append(s.data, v) +} + +func (s *ArrayStack) Pop() any { + // 弹出栈前，先判断是否为空 + if s.IsEmpty() { + return nil + } + val := s.Peek() + s.data = s.data[:len(s.data)-1] + return val +} + +func (s *ArrayStack) Peek() any { + if s.IsEmpty() { + return nil + } + val := s.data[len(s.data)-1] + return val +} + +func (s *ArrayStack) Print() { + fmt.Println(s.toString()) +} + +func (s *ArrayStack) toString() string { + var builder strings.Builder + if s.IsEmpty() { + return "empty stack" + } + for i := len(s.data) - 1; i > 0; i-- { + builder.WriteString(strconv.Itoa(s.data[i]) + " -> ") + } + builder.WriteString(strconv.Itoa(s.data[0])) + return builder.String() +} diff --git a/codes/go/chapter_stack_and_queue/linkedlist_stack.go b/codes/go/chapter_stack_and_queue/linkedlist_stack.go new file mode 100644 index 000000000..88fe4dc79 --- /dev/null +++ b/codes/go/chapter_stack_and_queue/linkedlist_stack.go @@ -0,0 +1,79 @@ +// File: linkedlist_stack.go +// Created Time: 2022-11-28 +// Author: Reanon (793584285@qq.com) + +package chapter_stack_and_queue + +import ( + "container/list" + "fmt" + "strings" +) + +// LinkedListStack 基于链表实现的栈, 使用内置包 list 来实现栈 +type LinkedListStack struct { + list *list.List +} + +// NewLinkedListStack 初始化链表 +func NewLinkedListStack() *LinkedListStack { + return &LinkedListStack{ + list: list.New(), + } +} + +// Push 入栈 +func (s *LinkedListStack) Push(value any) { + s.list.PushBack(value) +} + +// Pop 出栈 +func (s *LinkedListStack) Pop() any { + if s.IsEmpty() { + return nil + } + e := s.list.Back() + s.list.Remove(e) + return e.Value +} + +// Peek 访问栈顶元素 +func (s *LinkedListStack) Peek() any { + if s.IsEmpty() { + return nil + } + e := s.list.Back() + return e.Value +} + +// Size 获取栈的长度 +func (s *LinkedListStack) Size() int { + return s.list.Len() +} + +// IsEmpty 判断栈是否为空 +func (s *LinkedListStack) IsEmpty() bool { + return s.list.Len() == 0 +} + +func (s *LinkedListStack) Print() { + fmt.Println(s.toString()) +} + +func (s *LinkedListStack) toString() any { + var builder strings.Builder + if s.IsEmpty() { + fmt.Println("empty stack") + return nil + } + e := s.list.Back() + // 强转为 string, 会影响效率 + str := fmt.Sprintf("%v", e.Value) + for e.Prev() != nil { + builder.WriteString(str + " -> ") + e = e.Prev() + str = fmt.Sprintf("%v", e.Value) + } + builder.WriteString(str) + return builder.String() +} diff --git a/codes/go/chapter_stack_and_queue/stack.go b/codes/go/chapter_stack_and_queue/stack.go new file mode 100644 index 000000000..721522415 --- /dev/null +++ b/codes/go/chapter_stack_and_queue/stack.go @@ -0,0 +1,18 @@ +// File: stack.go +// Created Time: 2022-11-26 +// Author: Reanon (793584285@qq.com) + +package chapter_stack_and_queue + +type Stack interface { + // Push 元素入栈 + Push(num int) + // Peek 访问栈顶元素 + Peek() int + // Pop 元素出栈 + Pop() int + // Size 栈的长度 + Size() int + // IsEmpty 栈是否为空 + IsEmpty() bool +} diff --git a/codes/go/chapter_stack_and_queue/stack_test.go b/codes/go/chapter_stack_and_queue/stack_test.go new file mode 100644 index 000000000..b3cd3da49 --- /dev/null +++ b/codes/go/chapter_stack_and_queue/stack_test.go @@ -0,0 +1,93 @@ +// File: stack_test.go +// Created Time: 2022-11-28 +// Author: Reanon (793584285@qq.com) + +package chapter_stack_and_queue + +import "testing" + +func TestStack(t *testing.T) { + // 初始化栈 + stack := NewLinkedListStack() + + // 元素入栈 + stack.Push(1) + stack.Push(2) + stack.Push(3) + stack.Push(4) + stack.Push(5) + t.Log("栈 stack = ", stack.toString()) + + // 访问栈顶元素 + peek := stack.Peek() + t.Log("栈顶元素 peek = ", peek) + + // 元素出栈 + pop := stack.Pop() + t.Log("出栈元素 pop = ", pop, ", 出栈后 stack =", stack.toString()) + + // 获取栈的长度 + size := stack.Size() + t.Log("栈的长度 size = ", size) + + // 判断是否为空 + isEmpty := stack.IsEmpty() + t.Log("栈是否为空 = ", isEmpty) +} + +func TestArrayStack(t *testing.T) { + // 初始化栈 + stack := NewArrayStack() + + // 元素入栈 + stack.Push(1) + stack.Push(2) + stack.Push(3) + stack.Push(4) + stack.Push(5) + t.Log("栈 stack = ", stack.toString()) + + // 访问栈顶元素 + peek := stack.Peek() + t.Log("栈顶元素 peek = ", peek) + + // 元素出栈 + pop := stack.Pop() + t.Log("出栈元素 pop = ", pop, ", 出栈后 stack =", stack.toString()) + + // 获取栈的长度 + size := stack.Size() + t.Log("栈的长度 size = ", size) + + // 判断是否为空 + isEmpty := stack.IsEmpty() + t.Log("栈是否为空 = ", isEmpty) +} + +func TestLinkedListStack(t *testing.T) { + +} + +// BenchmarkStack 65.02 ns/op in Mac M1 Pro +func BenchmarkStack(b *testing.B) { + stack := NewLinkedListStack() + // use b.N for looping + for i := 0; i < b.N; i++ { + stack.Push(777) + } + for i := 0; i < b.N; i++ { + stack.Pop() + } +} + +// BenchmarkArrayStack 8 ns/op in Mac M1 Pro +func BenchmarkArrayStack(b *testing.B) { + stack := NewArrayStack() + // use b.N for looping + for i := 0; i < b.N; i++ { + stack.Push(777) + } + for i := 0; i < b.N; i++ { + stack.Pop() + } +} From 76a7e0b2325b66b4749394da03de95f673824e00 Mon Sep 17 00:00:00 2001 From: reanon <793584285@qq.com> Date: Tue, 29 Nov 2022 01:10:22 +0800 Subject: [PATCH 19/67] feat(queue): implement queue in golang code --- .../go/chapter_stack_and_queue/array_queue.go | 92 +++++++++++++++++++ .../linkedlist_queue.go | 79 ++++++++++++++++ codes/go/chapter_stack_and_queue/queue.go | 18 ++++ .../go/chapter_stack_and_queue/queue_test.go | 91 ++++++++++++++++++ 4 files changed, 280 insertions(+) create mode 100644 codes/go/chapter_stack_and_queue/array_queue.go create mode 100644 codes/go/chapter_stack_and_queue/linkedlist_queue.go create mode 100644 codes/go/chapter_stack_and_queue/queue.go create mode 100644 codes/go/chapter_stack_and_queue/queue_test.go diff --git a/codes/go/chapter_stack_and_queue/array_queue.go b/codes/go/chapter_stack_and_queue/array_queue.go new file mode 100644 index 000000000..f771ea214 --- /dev/null +++ b/codes/go/chapter_stack_and_queue/array_queue.go @@ -0,0 +1,92 @@ +// File: array_queue.go +// Created Time: 2022-11-28 +// Author: Reanon (793584285@qq.com) + +package chapter_stack_and_queue + +import ( + "fmt" + "strings" +) + +// ArrayQueue 基于环形数组实现的队列, 不支持扩容 +type ArrayQueue struct { + data []any // 用于存储队列元素的数组 + capacity int // 队列容量（即最多容量的元素个数） + head int // 头指针，指向队首 + tail int // 尾指针，指向队尾 + 1 +} + +// NewArrayQueue 基于环形数组实现的队列 +func NewArrayQueue(capacity int) *ArrayQueue { + return &ArrayQueue{ + data: make([]any, capacity), + capacity: capacity, + head: 0, + tail: 0, + } +} + +// Size 获取队列的长度 +func (q *ArrayQueue) Size() int { + size := (q.capacity + q.tail - q.head) % q.capacity + return size +} + +// IsEmpty 判断队列是否为空 +func (q *ArrayQueue) IsEmpty() bool { + return q.tail-q.head == 0 +} + +// Offer 入队 +func (q *ArrayQueue) Offer(v any) { + // 当 tail == capacity 表示队列已满 + if q.Size() == q.capacity { + return + } + // 尾结点后添加 + q.data[q.tail] = v + // 尾指针向后移动一位，越过尾部后返回到数组头部 + q.tail = (q.tail + 1) % q.capacity +} + +// Poll 出队 +func (q *ArrayQueue) Poll() any { + if q.IsEmpty() { + return nil + } + v := q.data[q.head] + // 队头指针向后移动，越过尾部后返回到数组头部 + q.head = (q.head + 1) % q.capacity + return v +} + +// Peek 访问队首元素 +func (q *ArrayQueue) Peek() any { + if q.IsEmpty() { + return nil + } + v := q.data[q.head] + return v +} + +func (q *ArrayQueue) Print() { + fmt.Println(q.toString()) +} + +// toString 通过字符串的方式输出 +func (q *ArrayQueue) toString() string { + // 为空时 + if q.IsEmpty() { + return "empty items" + } + var builder strings.Builder + size := q.Size() + str := fmt.Sprintf("%+v", q.data[q.head]) + for i := 1; i < size; i++ { + builder.WriteString(str + " -> ") + str = fmt.Sprintf("%+v", q.data[(i+q.head)%q.capacity]) + } + builder.WriteString(str) + return builder.String() +} diff --git a/codes/go/chapter_stack_and_queue/linkedlist_queue.go b/codes/go/chapter_stack_and_queue/linkedlist_queue.go new file mode 100644 index 000000000..6c71f6f7e --- /dev/null +++ b/codes/go/chapter_stack_and_queue/linkedlist_queue.go @@ -0,0 +1,79 @@ +// File: linkedlist_queue.go +// Created Time: 2022-11-28 +// Author: Reanon (793584285@qq.com) + +package chapter_stack_and_queue + +import ( + "container/list" + "fmt" + "strings" +) + +// LinkedListQueue 基于链表实现的栈, 使用内置包 list 来实现栈 +type LinkedListQueue struct { + list *list.List +} + +// NewLinkedListQueue 初始化链表 +func NewLinkedListQueue() *LinkedListQueue { + return &LinkedListQueue{ + list: list.New(), + } +} + +// Offer 入队 +func (s *LinkedListQueue) Offer(value any) { + s.list.PushBack(value) +} + +// Poll 出队 +func (s *LinkedListQueue) Poll() any { + if s.IsEmpty() { + return nil + } + e := s.list.Front() + s.list.Remove(e) + return e.Value +} + +// Peek 访问队首元素 +func (s *LinkedListQueue) Peek() any { + if s.IsEmpty() { + return nil + } + e := s.list.Front() + return e.Value +} + +// Size 获取队列的长度 +func (s *LinkedListQueue) Size() int { + return s.list.Len() +} + +// IsEmpty 判断队列是否为空 +func (s *LinkedListQueue) IsEmpty() bool { + return s.list.Len() == 0 +} + +func (s *LinkedListQueue) Print() { + fmt.Println(s.toString()) +} + +func (s *LinkedListQueue) toString() any { + var builder strings.Builder + if s.IsEmpty() { + fmt.Println("empty stack") + return nil + } + e := s.list.Front() + // 强转为 string, 会影响效率 + str := fmt.Sprintf("%v", e.Value) + for e.Next() != nil { + builder.WriteString(str + " -> ") + e = e.Next() + str = fmt.Sprintf("%v", e.Value) + } + builder.WriteString(str) + return builder.String() +} diff --git a/codes/go/chapter_stack_and_queue/queue.go b/codes/go/chapter_stack_and_queue/queue.go new file mode 100644 index 000000000..c8f16c83a --- /dev/null +++ b/codes/go/chapter_stack_and_queue/queue.go @@ -0,0 +1,18 @@ +// File: queue.go +// Created Time: 2022-11-29 +// Author: Reanon (793584285@qq.com) + +package chapter_stack_and_queue + +type Queue interface { + // Offer 元素入队 + Offer(num int) + // Peek 访问首元素 + Peek() int + // Poll 元素出队 + Poll() int + // Size 获取队列长度 + Size() int + // IsEmpty 队列是否为空 + IsEmpty() bool +} diff --git a/codes/go/chapter_stack_and_queue/queue_test.go b/codes/go/chapter_stack_and_queue/queue_test.go new file mode 100644 index 000000000..f4734a52c --- /dev/null +++ b/codes/go/chapter_stack_and_queue/queue_test.go @@ -0,0 +1,91 @@ +// File: queue_test.go +// Created Time: 2022-11-28 +// Author: Reanon (793584285@qq.com) + +package chapter_stack_and_queue + +import "testing" + +func TestArrayQueue(t *testing.T) { + // 初始化队 + capacity := 10 + queue := NewArrayQueue(capacity) + + // 元素入队 + queue.Offer(1) + queue.Offer(2) + queue.Offer(3) + queue.Offer(4) + queue.Offer(5) + t.Log("队列 queue = ", queue.toString()) + + // 访问队首元素 + peek := queue.Peek() + t.Log("队首元素 peek = ", peek) + + // 元素出队 + pop := queue.Poll() + t.Log("出队元素 pop = ", pop, ", 出队后 queue =", queue.toString()) + + // 获取队的长度 + size := queue.Size() + t.Log("队的长度 size = ", size) + + // 判断是否为空 + isEmpty := queue.IsEmpty() + t.Log("队是否为空 = ", isEmpty) +} + +func TestLinkedListQueue(t *testing.T) { + // 初始化队 + queue := NewLinkedListQueue() + + // 元素入队 + queue.Offer(1) + queue.Offer(2) + queue.Offer(3) + queue.Offer(4) + queue.Offer(5) + t.Log("队列 queue = ", queue.toString()) + + // 访问队首元素 + peek := queue.Peek() + t.Log("队首元素 peek = ", peek) + + // 元素出队 + pop := queue.Poll() + t.Log("出队元素 pop = ", pop, ", 出队后 queue =", queue.toString()) + + // 获取队的长度 + size := queue.Size() + t.Log("队的长度 size = ", size) + + // 判断是否为空 + isEmpty := queue.IsEmpty() + t.Log("队是否为空 = ", isEmpty) +} + +// BenchmarkArrayQueue 8 ns/op in Mac M1 Pro +func BenchmarkArrayQueue(b *testing.B) { + capacity := 1000 + stack := NewArrayQueue(capacity) + // use b.N for looping + for i := 0; i < b.N; i++ { + stack.Offer(777) + } + for i := 0; i < b.N; i++ { + stack.Poll() + } +} + +// BenchmarkLinkedQueue 62.66 ns/op in Mac M1 Pro +func BenchmarkLinkedQueue(b *testing.B) { + stack := NewLinkedListQueue() + // use b.N for looping + for i := 0; i < b.N; i++ { + stack.Offer(777) + } + for i := 0; i < b.N; i++ { + stack.Poll() + } +} From bed8b07b0b3c9c27198ff9e89c297883a7f4d4ff Mon Sep 17 00:00:00 2001 From: reanon <793584285@qq.com> Date: Tue, 29 Nov 2022 01:10:51 +0800 Subject: [PATCH 20/67] feat(deeue): implement deque in golang code --- codes/go/chapter_stack_and_queue/deque.go | 27 +++++++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 codes/go/chapter_stack_and_queue/deque.go diff --git a/codes/go/chapter_stack_and_queue/deque.go b/codes/go/chapter_stack_and_queue/deque.go new file mode 100644 index 000000000..fb419a6b2 --- /dev/null +++ b/codes/go/chapter_stack_and_queue/deque.go @@ -0,0 +1,27 @@ +// File: deque.go +// Created Time: 2022-11-29 +// Author: Reanon (793584285@qq.com) + +package chapter_stack_and_queue + +type Deque interface { + // OfferFirst 元素入队 + OfferFirst(num int) + // OfferLast 元素入队 + OfferLast(num int) + + // PeekFirst 访问首元素 + PeekFirst() int + // PeekLast 访问尾元素 + PeekLast() int + + // PollFirst 元素出队 + PollFirst() int + // PollLast 元素出队 + PollLast() int + + // Size 获取队列长度 + Size() int + // IsEmpty 队列是否为空 + IsEmpty() bool +} From d32f15feb14a19e2f1fc0c125795ef87e8cdfc6a Mon Sep 17 00:00:00 2001 From: reanon <793584285@qq.com> Date: Tue, 29 Nov 2022 01:17:07 +0800 Subject: [PATCH 21/67] fix(testcase): modify testcase --- .../go/chapter_stack_and_queue/stack_test.go | 78 +++++++++---------- 1 file changed, 37 insertions(+), 41 deletions(-) diff --git a/codes/go/chapter_stack_and_queue/stack_test.go b/codes/go/chapter_stack_and_queue/stack_test.go index b3cd3da49..b546d553f 100644 --- a/codes/go/chapter_stack_and_queue/stack_test.go +++ b/codes/go/chapter_stack_and_queue/stack_test.go @@ -6,35 +6,6 @@ package chapter_stack_and_queue import "testing" -func TestStack(t *testing.T) { - // 初始化栈 - stack := NewLinkedListStack() - - // 元素入栈 - stack.Push(1) - stack.Push(2) - stack.Push(3) - stack.Push(4) - stack.Push(5) - t.Log("栈 stack = ", stack.toString()) - - // 访问栈顶元素 - peek := stack.Peek() - t.Log("栈顶元素 peek = ", peek) - - // 元素出栈 - pop := stack.Pop() - t.Log("出栈元素 pop = ", pop, ", 出栈后 stack =", stack.toString()) - - // 获取栈的长度 - size := stack.Size() - t.Log("栈的长度 size = ", size) - - // 判断是否为空 - isEmpty := stack.IsEmpty() - t.Log("栈是否为空 = ", isEmpty) -} - func TestArrayStack(t *testing.T) { // 初始化栈 stack := NewArrayStack() @@ -65,19 +36,32 @@ func TestArrayStack(t *testing.T) { } func TestLinkedListStack(t *testing.T) { - -} - -// BenchmarkStack 65.02 ns/op in Mac M1 Pro -func BenchmarkStack(b *testing.B) { + // 初始化栈 stack := NewLinkedListStack() - // use b.N for looping - for i := 0; i < b.N; i++ { - stack.Push(777) - } - for i := 0; i < b.N; i++ { - stack.Pop() - } + + // 元素入栈 + stack.Push(1) + stack.Push(2) + stack.Push(3) + stack.Push(4) + stack.Push(5) + t.Log("栈 stack = ", stack.toString()) + + // 访问栈顶元素 + peek := stack.Peek() + t.Log("栈顶元素 peek = ", peek) + + // 元素出栈 + pop := stack.Pop() + t.Log("出栈元素 pop = ", pop, ", 出栈后 stack =", stack.toString()) + + // 获取栈的长度 + size := stack.Size() + t.Log("栈的长度 size = ", size) + + // 判断是否为空 + isEmpty := stack.IsEmpty() + t.Log("栈是否为空 = ", isEmpty) } // BenchmarkArrayStack 8 ns/op in Mac M1 Pro @@ -91,3 +75,15 @@ func BenchmarkArrayStack(b *testing.B) { stack.Pop() } } + +// BenchmarkLinkedListStack 65.02 ns/op in Mac M1 Pro +func BenchmarkLinkedListStack(b *testing.B) { + stack := NewLinkedListStack() + // use b.N for looping + for i := 0; i < b.N; i++ { + stack.Push(777) + } + for i := 0; i < b.N; i++ { + stack.Pop() + } +} From 19469aecbfbd2422a1da0452551f2e99ff3002d9 Mon Sep 17 00:00:00 2001 From: reanon <793584285@qq.com> Date: Tue, 29 Nov 2022 10:42:09 +0800 Subject: [PATCH 22/67] fix(go): modify interface of stack, queue and deque --- codes/go/chapter_stack_and_queue/deque.go | 17 ++++++++--------- .../chapter_stack_and_queue/linkedlist_queue.go | 5 ++--- .../chapter_stack_and_queue/linkedlist_stack.go | 5 ++--- codes/go/chapter_stack_and_queue/queue.go | 8 +++++--- codes/go/chapter_stack_and_queue/queue_test.go | 9 ++++++--- codes/go/chapter_stack_and_queue/stack.go | 6 ++++-- codes/go/chapter_stack_and_queue/stack_test.go | 9 +++++---- 7 files changed, 32 insertions(+), 27 deletions(-) diff --git a/codes/go/chapter_stack_and_queue/deque.go b/codes/go/chapter_stack_and_queue/deque.go index fb419a6b2..3ac070e1a 100644 --- a/codes/go/chapter_stack_and_queue/deque.go +++ b/codes/go/chapter_stack_and_queue/deque.go @@ -6,22 +6,21 @@ package chapter_stack_and_queue type Deque interface { // OfferFirst 元素入队 - OfferFirst(num int) + OfferFirst(num any) // OfferLast 元素入队 - OfferLast(num int) - + OfferLast(num any) // PeekFirst 访问首元素 - PeekFirst() int + PeekFirst() any // PeekLast 访问尾元素 - PeekLast() int - + PeekLast() any // PollFirst 元素出队 - PollFirst() int + PollFirst() any // PollLast 元素出队 - PollLast() int - + PollLast() any // Size 获取队列长度 Size() int // IsEmpty 队列是否为空 IsEmpty() bool + // toString 队列输出为字符串 + toString() string } diff --git a/codes/go/chapter_stack_and_queue/linkedlist_queue.go b/codes/go/chapter_stack_and_queue/linkedlist_queue.go index 6c71f6f7e..5b62ac311 100644 --- a/codes/go/chapter_stack_and_queue/linkedlist_queue.go +++ b/codes/go/chapter_stack_and_queue/linkedlist_queue.go @@ -10,7 +10,7 @@ import ( "strings" ) -// LinkedListQueue 基于链表实现的栈, 使用内置包 list 来实现栈 +// LinkedListQueue 基于链表实现的队列, 使用内置包 list 来实现栈 type LinkedListQueue struct { list *list.List } @@ -60,11 +60,10 @@ func (s *LinkedListQueue) Print() { fmt.Println(s.toString()) } -func (s *LinkedListQueue) toString() any { +func (s *LinkedListQueue) toString() string { var builder strings.Builder if s.IsEmpty() { fmt.Println("empty stack") - return nil } e := s.list.Front() // 强转为 string, 会影响效率 diff --git a/codes/go/chapter_stack_and_queue/linkedlist_stack.go b/codes/go/chapter_stack_and_queue/linkedlist_stack.go index 88fe4dc79..24f46acb5 100644 --- a/codes/go/chapter_stack_and_queue/linkedlist_stack.go +++ b/codes/go/chapter_stack_and_queue/linkedlist_stack.go @@ -23,7 +23,7 @@ func NewLinkedListStack() *LinkedListStack { } // Push 入栈 -func (s *LinkedListStack) Push(value any) { +func (s *LinkedListStack) Push(value int) { s.list.PushBack(value) } @@ -60,11 +60,10 @@ func (s *LinkedListStack) Print() { fmt.Println(s.toString()) } -func (s *LinkedListStack) toString() any { +func (s *LinkedListStack) toString() string { var builder strings.Builder if s.IsEmpty() { fmt.Println("empty stack") - return nil } e := s.list.Back() // 强转为 string, 会影响效率 diff --git a/codes/go/chapter_stack_and_queue/queue.go b/codes/go/chapter_stack_and_queue/queue.go index c8f16c83a..03b97e5a6 100644 --- a/codes/go/chapter_stack_and_queue/queue.go +++ b/codes/go/chapter_stack_and_queue/queue.go @@ -6,13 +6,15 @@ package chapter_stack_and_queue type Queue interface { // Offer 元素入队 - Offer(num int) + Offer(num any) // Peek 访问首元素 - Peek() int + Peek() any // Poll 元素出队 - Poll() int + Poll() any // Size 获取队列长度 Size() int // IsEmpty 队列是否为空 IsEmpty() bool + // toString 队列输出为字符串 + toString() string } diff --git a/codes/go/chapter_stack_and_queue/queue_test.go b/codes/go/chapter_stack_and_queue/queue_test.go index f4734a52c..996b0bcdb 100644 --- a/codes/go/chapter_stack_and_queue/queue_test.go +++ b/codes/go/chapter_stack_and_queue/queue_test.go @@ -7,9 +7,11 @@ package chapter_stack_and_queue import "testing" func TestArrayQueue(t *testing.T) { - // 初始化队 + + // 初始化队列，使用队列的通用接口 + var queue Queue capacity := 10 - queue := NewArrayQueue(capacity) + queue = NewArrayQueue(capacity) // 元素入队 queue.Offer(1) @@ -38,7 +40,8 @@ func TestArrayQueue(t *testing.T) { func TestLinkedListQueue(t *testing.T) { // 初始化队 - queue := NewLinkedListQueue() + var queue Queue + queue = NewLinkedListQueue() // 元素入队 queue.Offer(1) diff --git a/codes/go/chapter_stack_and_queue/stack.go b/codes/go/chapter_stack_and_queue/stack.go index 721522415..779538784 100644 --- a/codes/go/chapter_stack_and_queue/stack.go +++ b/codes/go/chapter_stack_and_queue/stack.go @@ -8,11 +8,13 @@ type Stack interface { // Push 元素入栈 Push(num int) // Peek 访问栈顶元素 - Peek() int + Peek() any // Pop 元素出栈 - Pop() int + Pop() any // Size 栈的长度 Size() int // IsEmpty 栈是否为空 IsEmpty() bool + // toString 栈输出为字符串 + toString() string } diff --git a/codes/go/chapter_stack_and_queue/stack_test.go b/codes/go/chapter_stack_and_queue/stack_test.go index b546d553f..95c6d2410 100644 --- a/codes/go/chapter_stack_and_queue/stack_test.go +++ b/codes/go/chapter_stack_and_queue/stack_test.go @@ -7,8 +7,9 @@ package chapter_stack_and_queue import "testing" func TestArrayStack(t *testing.T) { - // 初始化栈 - stack := NewArrayStack() + // 初始化栈, 使用接口承接 + var stack Stack + stack = NewArrayStack() // 元素入栈 stack.Push(1) @@ -37,8 +38,8 @@ func TestArrayStack(t *testing.T) { func TestLinkedListStack(t *testing.T) { // 初始化栈 - stack := NewLinkedListStack() - + var stack Stack + stack = NewLinkedListStack() // 元素入栈 stack.Push(1) stack.Push(2) From a554590fa81b75ce156121aae74619d1a998d430 Mon Sep 17 00:00:00 2001 From: reanon <793584285@qq.com> Date: Tue, 29 Nov 2022 10:43:47 +0800 Subject: [PATCH 23/67] feat(deque): add implementation of deque --- .../go/chapter_stack_and_queue/deque_test.go | 53 +++++++++ .../linkedlist_deque.go | 102 ++++++++++++++++++ .../go/chapter_stack_and_queue/queue_test.go | 1 - 3 files changed, 155 insertions(+), 1 deletion(-) create mode 100644 codes/go/chapter_stack_and_queue/deque_test.go create mode 100644 codes/go/chapter_stack_and_queue/linkedlist_deque.go diff --git a/codes/go/chapter_stack_and_queue/deque_test.go b/codes/go/chapter_stack_and_queue/deque_test.go new file mode 100644 index 000000000..c0eaf089e --- /dev/null +++ b/codes/go/chapter_stack_and_queue/deque_test.go @@ -0,0 +1,53 @@ +// File: deque_test.go +// Created Time: 2022-11-29 +// Author: Reanon (793584285@qq.com) + +package chapter_stack_and_queue + +import "testing" + +func TestLinkedListDeque(t *testing.T) { + // 初始化队列 + var deque Deque + deque = NewLinkedListDeque() + + // 元素入队 + deque.OfferLast(2) + deque.OfferLast(5) + deque.OfferLast(4) + deque.OfferFirst(3) + deque.OfferFirst(1) + t.Log("队列 deque = ", deque.toString()) + + // 访问队首元素 + peekFirst := deque.PeekFirst() + t.Log("队首元素 peek = ", peekFirst) + peekLast := deque.PeekLast() + t.Log("队尾元素 peek = ", peekLast) + + // 元素出队 + pollFirst := deque.PollFirst() + t.Log("队首出队元素 pollFirst = ", pollFirst, "，队首出队后 deque = ", deque.toString()) + pollLast := deque.PollLast() + t.Log("队尾出队元素 pollLast = ", pollLast, "，队尾出队后 deque = ", deque.toString()) + + // 获取队的长度 + size := deque.Size() + t.Log("队的长度 size = ", size) + + // 判断是否为空 + isEmpty := deque.IsEmpty() + t.Log("队是否为空 = ", isEmpty) +} + +// BenchmarkArrayQueue 67.92 ns/op in Mac M1 Pro +func BenchmarkLinkedListDeque(b *testing.B) { + stack := NewLinkedListDeque() + // use b.N for looping + for i := 0; i < b.N; i++ { + stack.OfferLast(777) + } + for i := 0; i < b.N; i++ { + stack.PollFirst() + } +} diff --git a/codes/go/chapter_stack_and_queue/linkedlist_deque.go b/codes/go/chapter_stack_and_queue/linkedlist_deque.go new file mode 100644 index 000000000..62a614910 --- /dev/null +++ b/codes/go/chapter_stack_and_queue/linkedlist_deque.go @@ -0,0 +1,102 @@ +// File: linkedlist_deque.go +// Created Time: 2022-11-29 +// Author: Reanon (793584285@qq.com) + +package chapter_stack_and_queue + +import ( + "container/list" + "fmt" + "strings" +) + +// LinkedListDeque 基于链表实现的双端队列, 使用内置包 list 来实现栈 +type LinkedListDeque struct { + list *list.List +} + +// NewLinkedListDeque 初始化双端队列 +func NewLinkedListDeque() *LinkedListDeque { + return &LinkedListDeque{ + list: list.New(), + } +} + +// OfferFirst 元素入队 +func (s *LinkedListDeque) OfferFirst(value any) { + s.list.PushFront(value) +} + +// OfferLast 元素入队 +func (s *LinkedListDeque) OfferLast(value any) { + s.list.PushBack(value) +} + +// PollFirst 元素出队 +func (s *LinkedListDeque) PollFirst() any { + if s.IsEmpty() { + return nil + } + e := s.list.Front() + s.list.Remove(e) + return e.Value +} + +// PollLast 元素出队 +func (s *LinkedListDeque) PollLast() any { + if s.IsEmpty() { + return nil + } + e := s.list.Back() + s.list.Remove(e) + return e.Value +} + +// PeekFirst 访问首元素 +func (s *LinkedListDeque) PeekFirst() any { + if s.IsEmpty() { + return nil + } + e := s.list.Front() + return e.Value +} + +// PeekLast 访问尾元素 +func (s *LinkedListDeque) PeekLast() any { + if s.IsEmpty() { + return nil + } + e := s.list.Back() + return e.Value +} + +// Size 获取队列的长度 +func (s *LinkedListDeque) Size() int { + return s.list.Len() +} + +// IsEmpty 判断队列是否为空 +func (s *LinkedListDeque) IsEmpty() bool { + return s.list.Len() == 0 +} + +func (s *LinkedListDeque) Print() { + fmt.Println(s.toString()) +} + +func (s *LinkedListDeque) toString() string { + var builder strings.Builder + if s.IsEmpty() { + fmt.Println("empty stack") + } + e := s.list.Front() + // 强转为 string, 会影响效率 + str := fmt.Sprintf("%v", e.Value) + for e.Next() != nil { + builder.WriteString(str + " -> ") + e = e.Next() + str = fmt.Sprintf("%v", e.Value) + } + builder.WriteString(str) + return builder.String() +} diff --git a/codes/go/chapter_stack_and_queue/queue_test.go b/codes/go/chapter_stack_and_queue/queue_test.go index 996b0bcdb..e8c74ecba 100644 --- a/codes/go/chapter_stack_and_queue/queue_test.go +++ b/codes/go/chapter_stack_and_queue/queue_test.go @@ -7,7 +7,6 @@ package chapter_stack_and_queue import "testing" func TestArrayQueue(t *testing.T) { - // 初始化队列，使用队列的通用接口 var queue Queue capacity := 10 From b47f54886e609c17518053487272ac6d17ed4c0f Mon Sep 17 00:00:00 2001 From: pengchzn Date: Tue, 29 Nov 2022 13:58:23 +0800 Subject: [PATCH 24/67] =?UTF-8?q?=E6=A0=88=E7=9A=84python=E4=BB=A3?= =?UTF-8?q?=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../chapter_stack_and_queue/array_stack.py | 73 +++++++++++++++- .../linkedlist_stack.py | 83 ++++++++++++++++++- codes/python/chapter_stack_and_queue/stack.py | 31 ++++++- 3 files changed, 184 insertions(+), 3 deletions(-) diff --git a/codes/python/chapter_stack_and_queue/array_stack.py b/codes/python/chapter_stack_and_queue/array_stack.py index 0853efa26..0867651f7 100644 --- a/codes/python/chapter_stack_and_queue/array_stack.py +++ b/codes/python/chapter_stack_and_queue/array_stack.py @@ -4,7 +4,78 @@ Created Time: 2022-11-25 Author: Krahets (krahets@163.com) ''' -import sys, os.path as osp +import os.path as osp +import sys + sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__)))) from include import * +""" 基于数组实现的栈 """ + + +class ArrayStack: + def __init__(self): + self._stack = [] + self._size = 0 + + """ 获取栈的长度 """ + + def size(self): + return self._size + + """ 判断栈是否为空 """ + + def isEmpty(self): + return self._stack == [] + + """ 入栈 """ + + def push(self, item): + self._stack.append(item) + self._size += 1 + + """ 出栈 """ + + def pop(self): + pop = self._stack.pop() + self._size -= 1 + return pop + + """ 访问栈顶元素 """ + + def peek(self): + return self._stack[-1] + + """ 访问索引 index 处元素 """ + + def get(self, index): + return self._stack[index] + + +if __name__ == "__main__": + """ 初始化栈 """ + stack = ArrayStack() + + """ 元素入栈 """ + stack.push(1) + stack.push(3) + stack.push(2) + stack.push(5) + stack.push(4) + print("栈 stack = ", stack._stack) + + """ 访问栈顶元素 """ + peek = stack.peek() + print("栈顶元素 peek = ", peek) + + """ 元素出栈 """ + pop = stack.pop() + print("出栈元素 pop = ", pop) + print("出栈后 stack = ", stack._stack) + + """ 获取栈的长度 """ + size = stack.size() + print("栈的长度 size = ", size) + + """ 判断是否为空 """ + isEmpty = (stack == []) diff --git a/codes/python/chapter_stack_and_queue/linkedlist_stack.py b/codes/python/chapter_stack_and_queue/linkedlist_stack.py index 252b2c727..eed307fb0 100644 --- a/codes/python/chapter_stack_and_queue/linkedlist_stack.py +++ b/codes/python/chapter_stack_and_queue/linkedlist_stack.py @@ -4,7 +4,88 @@ Created Time: 2022-11-25 Author: Krahets (krahets@163.com) ''' -import sys, os.path as osp +import os.path as osp +import sys + sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__)))) from include import * +""" 基于链表实现的栈 """ + + +class LinkedListStack: + def __init__(self): + self.head = None + + """ 获取栈的长度 """ + + def size(self): + cnt = 0 + temp = self.head + while temp is not None: + temp = temp.next + cnt += 1 + return cnt + + """ 判断栈是否为空 """ + + def is_empty(self): + if not self.head.val and not self.head.next: + return True + return False + + """ 入栈 """ + + def push(self, val): + temp = ListNode(val) + temp.next = self.head + self.head = temp + + """ 出栈 """ + + def pop(self): + pop = self.head.val + self.head = self.head.next + return pop + + """ 访问栈顶元素 """ + + def peek(self): + return self.head.val + + def to_array(self): + stack = [] + temp = self.head + while temp: + stack.insert(0, temp.val) + temp = temp.next + return stack + + +if __name__ == "__main__": + """ 初始化栈 """ + stack = LinkedListStack() + + """ 元素入栈 """ + stack.push(1) + stack.push(3) + stack.push(2) + stack.push(5) + stack.push(4) + print("栈 stack = ", stack.to_array()) + + """ 访问栈顶元素 """ + peek = stack.peek() + print("栈顶元素 peek = ", peek) + + """ 元素出栈 """ + pop = stack.pop() + print("出栈元素 pop = ", pop) + print("出栈后 stack = ", stack.to_array()) + + """ 获取栈的长度 """ + size = stack.size() + print("栈的长度 size = ", size) + + """ 判断是否为空 """ + isEmpty = (stack == []) diff --git a/codes/python/chapter_stack_and_queue/stack.py b/codes/python/chapter_stack_and_queue/stack.py index 334160088..c512198ec 100644 --- a/codes/python/chapter_stack_and_queue/stack.py +++ b/codes/python/chapter_stack_and_queue/stack.py @@ -4,7 +4,36 @@ Created Time: 2022-11-25 Author: Krahets (krahets@163.com) ''' -import sys, os.path as osp +import os.path as osp +import sys + sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__)))) from include import * +if __name__ == "__main__": + """ 初始化栈 """ + stack = [] + + """ 元素入栈 """ + stack.append(1) + stack.append(3) + stack.append(2) + stack.append(5) + stack.append(4) + print("栈 stack = ", stack) + + """ 访问栈顶元素 """ + peek = stack[-1] + print("栈顶元素 peek = ", peek) + + """ 元素出栈 """ + pop = stack.pop() + print("出栈元素 pop = ", pop) + print("出栈后 stack = ", stack) + + """ 获取栈的长度 """ + size = len(stack) + print("栈的长度 size = ", size) + + """ 判断是否为空 """ + isEmpty = (stack == []) From f8d44be73ddd45d28a205c74b0f73375df8f86a7 Mon Sep 17 00:00:00 2001 From: pengchzn Date: Tue, 29 Nov 2022 21:42:59 +0800 Subject: [PATCH 25/67] =?UTF-8?q?=E6=A0=88=E7=9A=84python=E4=BB=A3?= =?UTF-8?q?=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- codes/python/chapter_stack_and_queue/array_stack.py | 12 ++---------- .../chapter_stack_and_queue/linkedlist_stack.py | 11 ++--------- codes/python/chapter_stack_and_queue/stack.py | 4 ++-- 3 files changed, 6 insertions(+), 21 deletions(-) diff --git a/codes/python/chapter_stack_and_queue/array_stack.py b/codes/python/chapter_stack_and_queue/array_stack.py index 0867651f7..d9243d512 100644 --- a/codes/python/chapter_stack_and_queue/array_stack.py +++ b/codes/python/chapter_stack_and_queue/array_stack.py @@ -1,7 +1,7 @@ ''' File: array_stack.py -Created Time: 2022-11-25 -Author: Krahets (krahets@163.com) +Created Time: 2022-11-29 +Author: Peng Chen (pengchzn@gmail.com) ''' import os.path as osp @@ -11,43 +11,35 @@ sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__)))) from include import * """ 基于数组实现的栈 """ - - class ArrayStack: def __init__(self): self._stack = [] self._size = 0 """ 获取栈的长度 """ - def size(self): return self._size """ 判断栈是否为空 """ - def isEmpty(self): return self._stack == [] """ 入栈 """ - def push(self, item): self._stack.append(item) self._size += 1 """ 出栈 """ - def pop(self): pop = self._stack.pop() self._size -= 1 return pop """ 访问栈顶元素 """ - def peek(self): return self._stack[-1] """ 访问索引 index 处元素 """ - def get(self, index): return self._stack[index] diff --git a/codes/python/chapter_stack_and_queue/linkedlist_stack.py b/codes/python/chapter_stack_and_queue/linkedlist_stack.py index eed307fb0..d28f37705 100644 --- a/codes/python/chapter_stack_and_queue/linkedlist_stack.py +++ b/codes/python/chapter_stack_and_queue/linkedlist_stack.py @@ -1,7 +1,7 @@ ''' File: linkedlist_stack.py -Created Time: 2022-11-25 -Author: Krahets (krahets@163.com) +Created Time: 2022-11-29 +Author: Peng Chen (pengchzn@gmail.com) ''' import os.path as osp @@ -11,14 +11,11 @@ sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__)))) from include import * """ 基于链表实现的栈 """ - - class LinkedListStack: def __init__(self): self.head = None """ 获取栈的长度 """ - def size(self): cnt = 0 temp = self.head @@ -28,28 +25,24 @@ class LinkedListStack: return cnt """ 判断栈是否为空 """ - def is_empty(self): if not self.head.val and not self.head.next: return True return False """ 入栈 """ - def push(self, val): temp = ListNode(val) temp.next = self.head self.head = temp """ 出栈 """ - def pop(self): pop = self.head.val self.head = self.head.next return pop """ 访问栈顶元素 """ - def peek(self): return self.head.val diff --git a/codes/python/chapter_stack_and_queue/stack.py b/codes/python/chapter_stack_and_queue/stack.py index c512198ec..30028d096 100644 --- a/codes/python/chapter_stack_and_queue/stack.py +++ b/codes/python/chapter_stack_and_queue/stack.py @@ -1,7 +1,7 @@ ''' File: stack.py -Created Time: 2022-11-25 -Author: Krahets (krahets@163.com) +Created Time: 2022-11-29 +Author: Peng Chen (pengchzn@gmail.com) ''' import os.path as osp From 60cb2ffc975fbfff0bfa91046ccc9917348281a6 Mon Sep 17 00:00:00 2001 From: pengchzn Date: Tue, 29 Nov 2022 22:58:16 +0800 Subject: [PATCH 26/67] =?UTF-8?q?=E6=A0=88=E7=9A=84python=E4=BB=A3?= =?UTF-8?q?=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- codes/python/chapter_stack_and_queue/array_stack.py | 4 ++-- codes/python/chapter_stack_and_queue/linkedlist_stack.py | 5 +++-- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/codes/python/chapter_stack_and_queue/array_stack.py b/codes/python/chapter_stack_and_queue/array_stack.py index d9243d512..58a73556a 100644 --- a/codes/python/chapter_stack_and_queue/array_stack.py +++ b/codes/python/chapter_stack_and_queue/array_stack.py @@ -21,7 +21,7 @@ class ArrayStack: return self._size """ 判断栈是否为空 """ - def isEmpty(self): + def is_empty(self): return self._stack == [] """ 入栈 """ @@ -70,4 +70,4 @@ if __name__ == "__main__": print("栈的长度 size = ", size) """ 判断是否为空 """ - isEmpty = (stack == []) + isEmpty = stack.is_empty() diff --git a/codes/python/chapter_stack_and_queue/linkedlist_stack.py b/codes/python/chapter_stack_and_queue/linkedlist_stack.py index d28f37705..88029474d 100644 --- a/codes/python/chapter_stack_and_queue/linkedlist_stack.py +++ b/codes/python/chapter_stack_and_queue/linkedlist_stack.py @@ -50,8 +50,9 @@ class LinkedListStack: stack = [] temp = self.head while temp: - stack.insert(0, temp.val) + stack.append(temp.val) temp = temp.next + stack = stack[::-1] return stack @@ -81,4 +82,4 @@ if __name__ == "__main__": print("栈的长度 size = ", size) """ 判断是否为空 """ - isEmpty = (stack == []) + isEmpty = stack.is_empty() From b1b50944360a8a4c3d0d71571820e7d025ca2881 Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Tue, 29 Nov 2022 23:11:54 +0800 Subject: [PATCH 27/67] Update linkedlist_stack.py --- codes/python/chapter_stack_and_queue/linkedlist_stack.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/codes/python/chapter_stack_and_queue/linkedlist_stack.py b/codes/python/chapter_stack_and_queue/linkedlist_stack.py index 88029474d..19ffdc39a 100644 --- a/codes/python/chapter_stack_and_queue/linkedlist_stack.py +++ b/codes/python/chapter_stack_and_queue/linkedlist_stack.py @@ -52,7 +52,7 @@ class LinkedListStack: while temp: stack.append(temp.val) temp = temp.next - stack = stack[::-1] + stack.reverse() return stack From dc3c45c32695ebb743dc8c94b39926a68fac7108 Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Tue, 29 Nov 2022 23:13:39 +0800 Subject: [PATCH 28/67] Update Readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 42ea072b8..24391cfb9 100644 --- a/README.md +++ b/README.md @@ -62,4 +62,4 @@ ## License -The texts, codes, images, photos, and videos in this repository is licensed under [CC BY-NC-SA-4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/). +The texts, codes, images, photos, and videos in this repository are licensed under [CC BY-NC-SA-4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/). From 53cc651af2ac03f69f7b68d21fbecbbda747cf85 Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Tue, 29 Nov 2022 23:35:51 +0800 Subject: [PATCH 29/67] Update python code of stack. --- .../chapter_stack_and_queue/array_stack.py | 37 ++++++----- .../linkedlist_stack.py | 64 +++++++++---------- codes/python/chapter_stack_and_queue/stack.py | 19 +++--- 3 files changed, 60 insertions(+), 60 deletions(-) diff --git a/codes/python/chapter_stack_and_queue/array_stack.py b/codes/python/chapter_stack_and_queue/array_stack.py index 58a73556a..ad899d905 100644 --- a/codes/python/chapter_stack_and_queue/array_stack.py +++ b/codes/python/chapter_stack_and_queue/array_stack.py @@ -4,46 +4,45 @@ Created Time: 2022-11-29 Author: Peng Chen (pengchzn@gmail.com) ''' -import os.path as osp -import sys - +import sys, os.path as osp sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__)))) from include import * """ 基于数组实现的栈 """ class ArrayStack: def __init__(self): - self._stack = [] - self._size = 0 + self.__stack = [] """ 获取栈的长度 """ def size(self): - return self._size + return len(self.__stack) """ 判断栈是否为空 """ def is_empty(self): - return self._stack == [] + return self.__stack == [] """ 入栈 """ def push(self, item): - self._stack.append(item) - self._size += 1 + self.__stack.append(item) """ 出栈 """ def pop(self): - pop = self._stack.pop() - self._size -= 1 - return pop + return self.__stack.pop() """ 访问栈顶元素 """ def peek(self): - return self._stack[-1] + return self.__stack[-1] """ 访问索引 index 处元素 """ def get(self, index): - return self._stack[index] + return self.__stack[index] + + """ 返回列表用于打印 """ + def toList(self): + return self.__stack +""" Driver Code """ if __name__ == "__main__": """ 初始化栈 """ stack = ArrayStack() @@ -54,20 +53,20 @@ if __name__ == "__main__": stack.push(2) stack.push(5) stack.push(4) - print("栈 stack = ", stack._stack) + print("栈 stack =", stack.toList()) """ 访问栈顶元素 """ peek = stack.peek() - print("栈顶元素 peek = ", peek) + print("栈顶元素 peek =", peek) """ 元素出栈 """ pop = stack.pop() - print("出栈元素 pop = ", pop) - print("出栈后 stack = ", stack._stack) + print("出栈元素 pop =", pop) + print("出栈后 stack =", stack.toList()) """ 获取栈的长度 """ size = stack.size() - print("栈的长度 size = ", size) + print("栈的长度 size =", size) """ 判断是否为空 """ isEmpty = stack.is_empty() diff --git a/codes/python/chapter_stack_and_queue/linkedlist_stack.py b/codes/python/chapter_stack_and_queue/linkedlist_stack.py index 19ffdc39a..dce1e3586 100644 --- a/codes/python/chapter_stack_and_queue/linkedlist_stack.py +++ b/codes/python/chapter_stack_and_queue/linkedlist_stack.py @@ -4,58 +4,58 @@ Created Time: 2022-11-29 Author: Peng Chen (pengchzn@gmail.com) ''' -import os.path as osp -import sys - +import sys, os.path as osp sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__)))) from include import * """ 基于链表实现的栈 """ class LinkedListStack: def __init__(self): - self.head = None + self.__head = None + self.__size = 0 """ 获取栈的长度 """ def size(self): - cnt = 0 - temp = self.head - while temp is not None: - temp = temp.next - cnt += 1 - return cnt + return self.__size """ 判断栈是否为空 """ def is_empty(self): - if not self.head.val and not self.head.next: - return True - return False + return not self.__head """ 入栈 """ def push(self, val): - temp = ListNode(val) - temp.next = self.head - self.head = temp + node = ListNode(val) + node.next = self.__head + self.__head = node + self.__size += 1 """ 出栈 """ def pop(self): - pop = self.head.val - self.head = self.head.next + # 判空处理 + if not self.__head: return None + pop = self.__head.val + self.__head = self.__head.next + self.__size -= 1 return pop """ 访问栈顶元素 """ def peek(self): - return self.head.val + # 判空处理 + if not self.__head: return None + return self.__head.val - def to_array(self): - stack = [] - temp = self.head - while temp: - stack.append(temp.val) - temp = temp.next - stack.reverse() - return stack + """ 转化为列表用于打印 """ + def to_list(self): + arr = [] + node = self.__head + while node: + arr.append(node.val) + node = node.next + arr.reverse() + return arr +""" Driver Code """ if __name__ == "__main__": """ 初始化栈 """ stack = LinkedListStack() @@ -66,20 +66,20 @@ if __name__ == "__main__": stack.push(2) stack.push(5) stack.push(4) - print("栈 stack = ", stack.to_array()) + print("栈 stack =", stack.to_list()) """ 访问栈顶元素 """ peek = stack.peek() - print("栈顶元素 peek = ", peek) + print("栈顶元素 peek =", peek) """ 元素出栈 """ pop = stack.pop() - print("出栈元素 pop = ", pop) - print("出栈后 stack = ", stack.to_array()) + print("出栈元素 pop =", pop) + print("出栈后 stack =", stack.to_list()) """ 获取栈的长度 """ size = stack.size() - print("栈的长度 size = ", size) + print("栈的长度 size =", size) """ 判断是否为空 """ isEmpty = stack.is_empty() diff --git a/codes/python/chapter_stack_and_queue/stack.py b/codes/python/chapter_stack_and_queue/stack.py index 30028d096..80e7fcc2b 100644 --- a/codes/python/chapter_stack_and_queue/stack.py +++ b/codes/python/chapter_stack_and_queue/stack.py @@ -4,14 +4,15 @@ Created Time: 2022-11-29 Author: Peng Chen (pengchzn@gmail.com) ''' -import os.path as osp -import sys - +import sys, os.path as osp sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__)))) from include import * + +""" Driver Code """ if __name__ == "__main__": """ 初始化栈 """ + # Python 没有内置的栈类，可以把 list 当作栈来使用 stack = [] """ 元素入栈 """ @@ -20,20 +21,20 @@ if __name__ == "__main__": stack.append(2) stack.append(5) stack.append(4) - print("栈 stack = ", stack) + print("栈 stack =", stack) """ 访问栈顶元素 """ peek = stack[-1] - print("栈顶元素 peek = ", peek) + print("栈顶元素 peek =", peek) """ 元素出栈 """ pop = stack.pop() - print("出栈元素 pop = ", pop) - print("出栈后 stack = ", stack) + print("出栈元素 pop =", pop) + print("出栈后 stack =", stack) """ 获取栈的长度 """ size = len(stack) - print("栈的长度 size = ", size) + print("栈的长度 size =", size) """ 判断是否为空 """ - isEmpty = (stack == []) + isEmpty = len(stack) == 0 From 8669e064144236e44ba81369d6ae8542b46686ac Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Wed, 30 Nov 2022 02:27:26 +0800 Subject: [PATCH 30/67] Update stack and queue. --- .../chapter_array_and_linkedlist/my_list.cpp | 8 +- .../chapter_stack_and_queue/array_queue.cpp | 116 ++++++++ .../chapter_stack_and_queue/array_stack.cpp | 28 +- codes/cpp/chapter_stack_and_queue/deque.cpp | 39 +++ .../linkedlist_queue.cpp | 94 +++++++ .../linkedlist_stack.cpp | 53 ++-- codes/cpp/chapter_stack_and_queue/queue.cpp | 3 +- codes/cpp/chapter_stack_and_queue/stack.cpp | 1 + codes/cpp/include/PrintUtil.hpp | 22 +- .../chapter_stack_and_queue/array_queue.java | 10 +- .../chapter_stack_and_queue/array_stack.java | 17 +- codes/java/chapter_stack_and_queue/deque.java | 11 +- .../linkedlist_queue.java | 1 + .../linkedlist_stack.java | 37 ++- codes/java/chapter_stack_and_queue/queue.java | 1 + codes/java/chapter_stack_and_queue/stack.java | 18 +- .../chapter_array_and_linkedlist/my_list.py | 50 ++-- .../chapter_stack_and_queue/array_stack.py | 9 +- .../linkedlist_stack.py | 23 +- codes/python/chapter_stack_and_queue/stack.py | 3 +- docs/chapter_array_and_linkedlist/list.md | 56 ++-- docs/chapter_stack_and_queue/deque.md | 25 +- docs/chapter_stack_and_queue/queue.md | 8 +- docs/chapter_stack_and_queue/stack.md | 258 ++++++++++++++++-- 24 files changed, 705 insertions(+), 186 deletions(-) diff --git a/codes/cpp/chapter_array_and_linkedlist/my_list.cpp b/codes/cpp/chapter_array_and_linkedlist/my_list.cpp index 5c530ddef..48d0cdb96 100644 --- a/codes/cpp/chapter_array_and_linkedlist/my_list.cpp +++ b/codes/cpp/chapter_array_and_linkedlist/my_list.cpp @@ -34,14 +34,14 @@ public: int get(int index) { // 索引如果越界则抛出异常，下同 if (index >= size()) - throw std::out_of_range ("索引越界"); + throw out_of_range("索引越界"); return nums[index]; } /* 更新元素 */ void set(int index, int num) { if (index >= size()) - throw std::out_of_range ("索引越界"); + throw out_of_range("索引越界"); nums[index] = num; } @@ -58,7 +58,7 @@ public: /* 中间插入元素 */ void insert(int index, int num) { if (index >= size()) - throw std::out_of_range ("索引越界"); + throw out_of_range("索引越界"); // 元素数量超出容量时，触发扩容机制 if (size() == capacity()) extendCapacity(); @@ -74,7 +74,7 @@ public: /* 删除元素 */ void remove(int index) { if (index >= size()) - throw std::out_of_range ("索引越界"); + throw out_of_range("索引越界"); // 索引 i 之后的元素都向前移动一位 for (int j = index; j < size() - 1; j++) { nums[j] = nums[j + 1]; diff --git a/codes/cpp/chapter_stack_and_queue/array_queue.cpp b/codes/cpp/chapter_stack_and_queue/array_queue.cpp index ac10cd566..0aea80b02 100644 --- a/codes/cpp/chapter_stack_and_queue/array_queue.cpp +++ b/codes/cpp/chapter_stack_and_queue/array_queue.cpp @@ -6,3 +6,119 @@ #include "../include/include.hpp" +/* 基于环形数组实现的队列 */ +class ArrayQueue { +private: + vector nums; // 用于存储队列元素的数组 + int front = 0; // 头指针，指向队首 + int rear = 0; // 尾指针，指向队尾 + 1 + +public: + ArrayQueue(int capacity) { + // 初始化数组 + nums.resize(capacity); + } + + /* 获取队列的容量 */ + int capacity() { + return nums.size(); + } + + /* 获取队列的长度 */ + int size() { + int cap = capacity(); + // 由于将数组看作为环形，可能 rear < front ，因此需要取余数 + return (cap + rear - front) % cap; + } + + /* 判断队列是否为空 */ + bool empty() { + return rear - front == 0; + } + + /* 入队 */ + void offer(int num) { + if (size() == capacity()) { + cout << "队列已满" << endl; + return; + } + // 尾结点后添加 num + nums[rear] = num; + // 尾指针向后移动一位，越过尾部后返回到数组头部 + rear = (rear + 1) % capacity(); + } + + /* 出队 */ + int poll() { + // 删除头结点 + if (empty()) + throw out_of_range("队列为空"); + int num = nums[front]; + // 队头指针向后移动，越过尾部后返回到数组头部 + front = (front + 1) % capacity(); + return num; + } + + /* 访问队首元素 */ + int peek() { + // 删除头结点 + if (empty()) + throw out_of_range("队列为空"); + return nums[front]; + } + + vector toVector() { + int siz = size(); + int cap = capacity(); + // 仅转换有效长度范围内的列表元素 + vector arr(siz); + for (int i = 0, j = front; i < siz; i++, j++) { + arr[i] = nums[j % cap]; + } + return arr; + } +}; + + +/* Driver Code */ +int main() { + /* 初始化队列 */ + int capacity = 10; + ArrayQueue* queue = new ArrayQueue(capacity); + + /* 元素入队 */ + queue->offer(1); + queue->offer(3); + queue->offer(2); + queue->offer(5); + queue->offer(4); + cout << "队列 queue = "; + PrintUtil::printVector(queue->toVector()); + + /* 访问队首元素 */ + int peek = queue->peek(); + cout << "队首元素 peek = " << peek << endl; + + /* 元素出队 */ + int poll = queue->poll(); + cout << "出队元素 poll = " << poll << "，出队后 queue = "; + PrintUtil::printVector(queue->toVector()); + + /* 获取队列的长度 */ + int size = queue->size(); + cout << "队列长度 size = " << size << endl; + + /* 判断队列是否为空 */ + bool empty = queue->empty(); + cout << "队列是否为空 = " << empty << endl; + + /* 测试环形数组 */ + for (int i = 0; i < 10; i++) { + queue->offer(i); + queue->poll(); + cout << "第 " << i << " 轮入队 + 出队后 queue = "; + PrintUtil::printVector(queue->toVector()); + } + + return 0; +} diff --git a/codes/cpp/chapter_stack_and_queue/array_stack.cpp b/codes/cpp/chapter_stack_and_queue/array_stack.cpp index 8b08e1763..ccc1cb912 100644 --- a/codes/cpp/chapter_stack_and_queue/array_stack.cpp +++ b/codes/cpp/chapter_stack_and_queue/array_stack.cpp @@ -9,38 +9,44 @@ /* 基于数组实现的栈 */ class ArrayStack { private: - vector vec; + vector stack; + public: /* 获取栈的长度 */ int size() { - return vec.size(); + return stack.size(); } /* 判断栈是否为空 */ bool empty() { - return vec.empty(); + return stack.empty(); } /* 入栈 */ void push(int num) { - vec.push_back(num); + stack.push_back(num); } /* 出栈 */ int pop() { - int oldTop = vec.back(); - vec.pop_back(); + int oldTop = stack.back(); + stack.pop_back(); return oldTop; } /* 访问栈顶元素 */ int top() { - return vec.back(); + return stack.back(); + } + + /* 访问索引 index 处元素 */ + int get(int index) { + return stack[index]; } /* 返回 Vector */ vector toVector() { - return vec; + return stack; } }; @@ -57,8 +63,7 @@ int main() { stack->push(5); stack->push(4); cout << "栈 stack = "; - vector vec = stack->toVector(); - PrintUtil::printVector(vec); + PrintUtil::printVector(stack->toVector()); /* 访问栈顶元素 */ int top = stack->top(); @@ -67,8 +72,7 @@ int main() { /* 元素出栈 */ int pop = stack->pop(); cout << "出栈元素 pop = " << pop << "，出栈后 stack = "; - vec = stack->toVector(); - PrintUtil::printVector(vec); + PrintUtil::printVector(stack->toVector()); /* 获取栈的长度 */ int size = stack->size(); diff --git a/codes/cpp/chapter_stack_and_queue/deque.cpp b/codes/cpp/chapter_stack_and_queue/deque.cpp index cb777e896..820dd4af2 100644 --- a/codes/cpp/chapter_stack_and_queue/deque.cpp +++ b/codes/cpp/chapter_stack_and_queue/deque.cpp @@ -6,3 +6,42 @@ #include "../include/include.hpp" + +/* Driver Code */ +int main() { + /* 初始化双向队列 */ + deque deque; + + /* 元素入队 */ + deque.push_back(2); + deque.push_back(5); + deque.push_back(4); + deque.push_front(3); + deque.push_front(1); + cout << "双向队列 deque = "; + PrintUtil::printDeque(deque); + + /* 访问队首元素 */ + int front = deque.front(); + cout << "队首元素 front = " << front << endl; + int back = deque.back(); + cout << "队尾元素 back = " << back << endl; + + /* 元素出队 */ + deque.pop_front(); + cout << "队首出队元素 popFront = " << front << "，队首出队后 deque = "; + PrintUtil::printDeque(deque); + deque.pop_back(); + cout << "队尾出队元素 popLast = " << back << "，队尾出队后 deque = "; + PrintUtil::printDeque(deque); + + /* 获取双向队列的长度 */ + int size = deque.size(); + cout << "双向队列长度 size = " << size << endl; + + /* 判断双向队列是否为空 */ + bool empty = deque.empty(); + cout << "双向队列是否为空 = " << empty << endl; + + return 0; +} diff --git a/codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp b/codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp index 5c2422973..d3cb35b38 100644 --- a/codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp +++ b/codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp @@ -6,3 +6,97 @@ #include "../include/include.hpp" +/* 基于链表实现的队列 */ +class LinkedListQueue { +private: + ListNode *front, *back; + int qSize; + +public: + LinkedListQueue() { + front = nullptr; + back = nullptr; + qSize = 0; + } + + /* 获取队列的长度 */ + int size() { + return qSize; + } + + /* 判断队列是否为空 */ + bool empty() { + return qSize == 0; + } + + /* 入队 */ + void offer(int num) { + // 尾结点后添加 num + ListNode* node = new ListNode(num); + node->next = back; + back = node; + qSize++; + } + + /* 出队 */ + int poll() { + if (qSize == 0) + throw out_of_range("队列为空"); + // 删除头结点 + ListNode* node = front; + front = front->next; + return node->val; + } + + /* 访问队首元素 */ + int peek() { + return front->val; + } + + /* 将 List 转化为 Array 并返回 */ + vector toVector() { + ListNode* node = front; + vector vec; + while (node != nullptr) { + vec.push_back(node->val); + node = node->next; + } + reverse(vec.begin(), vec.end()); + return vec; + } +}; + + +/* Driver Code */ +int main() { + /* 初始化队列 */ + LinkedListQueue* queue = new LinkedListQueue(); + + /* 元素入队 */ + queue->offer(1); + queue->offer(3); + queue->offer(2); + queue->offer(5); + queue->offer(4); + cout << "队列 queue = "; + PrintUtil::printVector(queue->toVector()); + + /* 访问队首元素 */ + int peek = queue->peek(); + cout << "队首元素 peek = " << peek << endl; + + /* 元素出队 */ + int poll = queue->poll(); + cout << "出队元素 poll = " << poll << "，出队后 queue = "; + PrintUtil::printVector(queue->toVector()); + + /* 获取队列的长度 */ + int size = queue->size(); + cout << "队列长度 size = " << size << endl; + + /* 判断队列是否为空 */ + bool empty = queue->empty(); + cout << "队列是否为空 = " << empty << endl; + + return 0; +} diff --git a/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp b/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp index 15eec8071..1ffae5ecd 100644 --- a/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp +++ b/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp @@ -9,38 +9,59 @@ /* 基于链表实现的栈 */ class LinkedListStack { private: - list list; + ListNode* stackTop; // 将头结点作为栈顶 + int stackSize; // 栈的长度 + public: + LinkedListStack() { + stackTop = nullptr; + stackSize = 0; + } + /* 获取栈的长度 */ int size() { - return list.size(); + return stackSize; } + /* 判断栈是否为空 */ bool empty() { - return list.empty(); + return size() == 0; } + /* 入栈 */ void push(int num) { - list.push_back(num); + ListNode* node = new ListNode(num); + node->next = stackTop; + stackTop = node; + stackSize++; } + /* 出栈 */ int pop() { - int oldTop = list.back(); - list.pop_back(); - return oldTop; + if (size() == 0) + throw out_of_range("栈为空"); + int num = stackTop->val; + stackTop = stackTop->next; + stackSize--; + return num; } + /* 访问栈顶元素 */ int top() { - return list.back(); + if (size() == 0) + throw out_of_range("栈为空"); + return stackTop->val; } /* 将 List 转化为 Array 并返回 */ vector toVector() { - vector vec; - for (int num : list) { - vec.push_back(num); + ListNode* node = stackTop; + vector res(size()); + for (int i = res.size() - 1; i >= 0; i--) { + res[i] = node->val; + node = node->next; } - return vec; + return res; } }; @@ -57,8 +78,7 @@ int main() { stack->push(5); stack->push(4); cout << "栈 stack = "; - vector vec = stack->toVector(); - PrintUtil::printVector(vec); + PrintUtil::printVector(stack->toVector()); /* 访问栈顶元素 */ int top = stack->top(); @@ -67,8 +87,7 @@ int main() { /* 元素出栈 */ int pop = stack->pop(); cout << "出栈元素 pop = " << pop << "，出栈后 stack = "; - vec = stack->toVector(); - PrintUtil::printVector(vec); + PrintUtil::printVector(stack->toVector()); /* 获取栈的长度 */ int size = stack->size(); @@ -77,4 +96,6 @@ int main() { /* 判断是否为空 */ bool empty = stack->empty(); cout << "栈是否为空 = " << empty << endl; + + return 0; } diff --git a/codes/cpp/chapter_stack_and_queue/queue.cpp b/codes/cpp/chapter_stack_and_queue/queue.cpp index ccaefb1ef..2ca504a20 100644 --- a/codes/cpp/chapter_stack_and_queue/queue.cpp +++ b/codes/cpp/chapter_stack_and_queue/queue.cpp @@ -35,7 +35,8 @@ int main(){ cout << "队列长度 size = " << size << endl; /* 判断队列是否为空 */ - bool isEmpty = queue.empty(); + bool empty = queue.empty(); + cout << "队列是否为空 = " << empty << endl; return 0; } diff --git a/codes/cpp/chapter_stack_and_queue/stack.cpp b/codes/cpp/chapter_stack_and_queue/stack.cpp index 91cff9400..cc0276970 100644 --- a/codes/cpp/chapter_stack_and_queue/stack.cpp +++ b/codes/cpp/chapter_stack_and_queue/stack.cpp @@ -36,6 +36,7 @@ int main() { /* 判断是否为空 */ bool empty = stack.empty(); + cout << "栈是否为空 = " << empty << endl; return 0; } diff --git a/codes/cpp/include/PrintUtil.hpp b/codes/cpp/include/PrintUtil.hpp index 06f2f63ff..772eb9b25 100644 --- a/codes/cpp/include/PrintUtil.hpp +++ b/codes/cpp/include/PrintUtil.hpp @@ -102,7 +102,7 @@ class PrintUtil { * @param list */ template - static void printVector(vector &list) { + static void printVector(vector list) { cout << getVectorString(list) << '\n'; } @@ -218,7 +218,7 @@ class PrintUtil { * @param stk */ template - static void printStack(stack &stk) { + static void printStack(stack stk) { // Reverse the input stack stack tmp; while(!stk.empty()) { @@ -246,7 +246,7 @@ class PrintUtil { * @param queue */ template - static void printQueue(queue &queue) + static void printQueue(queue queue) { // Generate the string to print ostringstream s; @@ -261,4 +261,20 @@ class PrintUtil { } cout << "[" + s.str() + "]" << '\n'; } + + template + static void printDeque(deque deque) { + // Generate the string to print + ostringstream s; + bool flag = true; + while(!deque.empty()) { + if (flag) { + s << deque.front(); + flag = false; + } + else s << ", " << deque.front(); + deque.pop_front(); + } + cout << "[" + s.str() + "]" << '\n'; + } }; diff --git a/codes/java/chapter_stack_and_queue/array_queue.java b/codes/java/chapter_stack_and_queue/array_queue.java index 251e7ac4a..aab31542d 100644 --- a/codes/java/chapter_stack_and_queue/array_queue.java +++ b/codes/java/chapter_stack_and_queue/array_queue.java @@ -10,10 +10,9 @@ import java.util.*; /* 基于环形数组实现的队列 */ class ArrayQueue { - int[] nums; // 用于存储队列元素的数组 - int size = 0; // 队列长度（即元素个数） - int front = 0; // 头指针，指向队首 - int rear = 0; // 尾指针，指向队尾 + 1 + private int[] nums; // 用于存储队列元素的数组 + private int front = 0; // 头指针，指向队首 + private int rear = 0; // 尾指针，指向队尾 + 1 public ArrayQueue(int capacity) { // 初始化数组 @@ -108,12 +107,13 @@ public class array_queue { /* 判断队列是否为空 */ boolean isEmpty = queue.isEmpty(); + System.out.println("队列是否为空 = " + isEmpty); /* 测试环形数组 */ for (int i = 0; i < 10; i++) { queue.offer(i); queue.poll(); - System.out.println("第 " + i + " 轮入队+出队后 queue = " + Arrays.toString(queue.toArray())); + System.out.println("第 " + i + " 轮入队 + 出队后 queue = " + Arrays.toString(queue.toArray())); } } } diff --git a/codes/java/chapter_stack_and_queue/array_stack.java b/codes/java/chapter_stack_and_queue/array_stack.java index 395e79efe..0ac9b45cf 100644 --- a/codes/java/chapter_stack_and_queue/array_stack.java +++ b/codes/java/chapter_stack_and_queue/array_stack.java @@ -10,15 +10,15 @@ import java.util.*; /* 基于数组实现的栈 */ class ArrayStack { - ArrayList list; + private ArrayList stack; public ArrayStack() { // 初始化列表（动态数组） - list = new ArrayList<>(); + stack = new ArrayList<>(); } /* 获取栈的长度 */ public int size() { - return list.size(); + return stack.size(); } /* 判断栈是否为空 */ @@ -28,27 +28,27 @@ class ArrayStack { /* 入栈 */ public void push(int num) { - list.add(num); + stack.add(num); } /* 出栈 */ public int pop() { - return list.remove(size() - 1); + return stack.remove(size() - 1); } /* 访问栈顶元素 */ public int peek() { - return list.get(size() - 1); + return stack.get(size() - 1); } /* 访问索引 index 处元素 */ public int get(int index) { - return list.get(index); + return stack.get(index); } /* 将 List 转化为 Array 并返回 */ public Object[] toArray() { - return list.toArray(); + return stack.toArray(); } } @@ -79,5 +79,6 @@ public class array_stack { /* 判断是否为空 */ boolean isEmpty = stack.isEmpty(); + System.out.println("栈是否为空 = " + isEmpty); } } diff --git a/codes/java/chapter_stack_and_queue/deque.java b/codes/java/chapter_stack_and_queue/deque.java index 095e52833..cdfe65bf7 100644 --- a/codes/java/chapter_stack_and_queue/deque.java +++ b/codes/java/chapter_stack_and_queue/deque.java @@ -10,7 +10,7 @@ import java.util.*; public class deque { public static void main(String[] args) { - /* 初始化队列 */ + /* 初始化双向队列 */ Deque deque = new LinkedList<>(); /* 元素入队 */ @@ -19,7 +19,7 @@ public class deque { deque.offerLast(4); deque.offerFirst(3); deque.offerFirst(1); - System.out.println("队列 deque = " + deque); + System.out.println("双向队列 deque = " + deque); /* 访问队首元素 */ int peekFirst = deque.peekFirst(); @@ -33,11 +33,12 @@ public class deque { int pollLast = deque.pollLast(); System.out.println("队尾出队元素 pollLast = " + pollLast + "，队尾出队后 deque = " + deque); - /* 获取队列的长度 */ + /* 获取双向队列的长度 */ int size = deque.size(); - System.out.println("队列长度 size = " + size); + System.out.println("双向队列长度 size = " + size); - /* 判断队列是否为空 */ + /* 判断双向队列是否为空 */ boolean isEmpty = deque.isEmpty(); + System.out.println("双向队列是否为空 = " + isEmpty); } } diff --git a/codes/java/chapter_stack_and_queue/linkedlist_queue.java b/codes/java/chapter_stack_and_queue/linkedlist_queue.java index 30ddeb170..9429cc359 100644 --- a/codes/java/chapter_stack_and_queue/linkedlist_queue.java +++ b/codes/java/chapter_stack_and_queue/linkedlist_queue.java @@ -77,5 +77,6 @@ public class linkedlist_queue { /* 判断队列是否为空 */ boolean isEmpty = queue.isEmpty(); + System.out.println("队列是否为空 = " + isEmpty); } } diff --git a/codes/java/chapter_stack_and_queue/linkedlist_stack.java b/codes/java/chapter_stack_and_queue/linkedlist_stack.java index 003977b02..0dc47985e 100644 --- a/codes/java/chapter_stack_and_queue/linkedlist_stack.java +++ b/codes/java/chapter_stack_and_queue/linkedlist_stack.java @@ -7,18 +7,20 @@ package chapter_stack_and_queue; import java.util.*; +import include.*; /* 基于链表实现的栈 */ class LinkedListStack { - LinkedList list; + private ListNode stackPeek; // 将头结点作为栈顶 + private int stackSize = 0; // 栈的长度 + public LinkedListStack() { - // 初始化链表 - list = new LinkedList<>(); + stackPeek = null; } /* 获取栈的长度 */ public int size() { - return list.size(); + return stackSize; } /* 判断栈是否为空 */ @@ -28,22 +30,38 @@ class LinkedListStack { /* 入栈 */ public void push(int num) { - list.addLast(num); + ListNode node = new ListNode(num); + node.next = stackPeek; + stackPeek = node; + stackSize++; } /* 出栈 */ public int pop() { - return list.removeLast(); + if (size() == 0) + throw new IndexOutOfBoundsException(); + int num = peek(); + stackPeek = stackPeek.next; + stackSize--; + return num; } /* 访问栈顶元素 */ public int peek() { - return list.getLast(); + if (size() == 0) + throw new IndexOutOfBoundsException(); + return stackPeek.val; } /* 将 List 转化为 Array 并返回 */ - public Object[] toArray() { - return list.toArray(); + public int[] toArray() { + ListNode node = stackPeek; + int[] res = new int[size()]; + for (int i = res.length - 1; i >= 0; i--) { + res[i] = node.val; + node = node.next; + } + return res; } } @@ -74,5 +92,6 @@ public class linkedlist_stack { /* 判断是否为空 */ boolean isEmpty = stack.isEmpty(); + System.out.println("栈是否为空 = " + isEmpty); } } diff --git a/codes/java/chapter_stack_and_queue/queue.java b/codes/java/chapter_stack_and_queue/queue.java index 4d22b5028..232943fb1 100644 --- a/codes/java/chapter_stack_and_queue/queue.java +++ b/codes/java/chapter_stack_and_queue/queue.java @@ -35,5 +35,6 @@ public class queue { /* 判断队列是否为空 */ boolean isEmpty = queue.isEmpty(); + System.out.println("队列是否为空 = " + isEmpty); } } diff --git a/codes/java/chapter_stack_and_queue/stack.java b/codes/java/chapter_stack_and_queue/stack.java index 1ae525c38..9c94eb62b 100644 --- a/codes/java/chapter_stack_and_queue/stack.java +++ b/codes/java/chapter_stack_and_queue/stack.java @@ -11,22 +11,23 @@ import java.util.*; public class stack { public static void main(String[] args) { /* 初始化栈 */ - Stack stack = new Stack<>(); + // 在 Java 中，推荐将 LinkedList 当作栈来使用 + LinkedList stack = new LinkedList<>(); /* 元素入栈 */ - stack.push(1); - stack.push(3); - stack.push(2); - stack.push(5); - stack.push(4); + stack.addLast(1); + stack.addLast(3); + stack.addLast(2); + stack.addLast(5); + stack.addLast(4); System.out.println("栈 stack = " + stack); /* 访问栈顶元素 */ - int peek = stack.peek(); + int peek = stack.peekLast(); System.out.println("栈顶元素 peek = " + peek); /* 元素出栈 */ - int pop = stack.pop(); + int pop = stack.removeLast(); System.out.println("出栈元素 pop = " + pop + "，出栈后 stack = " + stack); /* 获取栈的长度 */ @@ -35,5 +36,6 @@ public class stack { /* 判断是否为空 */ boolean isEmpty = stack.isEmpty(); + System.out.println("栈是否为空 = " + isEmpty); } } diff --git a/codes/python/chapter_array_and_linkedlist/my_list.py b/codes/python/chapter_array_and_linkedlist/my_list.py index 1c178fc09..5d8997b7b 100644 --- a/codes/python/chapter_array_and_linkedlist/my_list.py +++ b/codes/python/chapter_array_and_linkedlist/my_list.py @@ -12,64 +12,64 @@ from include import * class MyList: """ 构造函数 """ def __init__(self): - self._capacity = 10 # 列表容量 - self._nums = [0] * self._capacity # 数组（存储列表元素） - self._size = 0 # 列表长度（即当前元素数量） - self._extend_ratio = 2 # 每次列表扩容的倍数 + self.__capacity = 10 # 列表容量 + self.__nums = [0] * self.__capacity # 数组（存储列表元素） + self.__size = 0 # 列表长度（即当前元素数量） + self.__extend_ratio = 2 # 每次列表扩容的倍数 """ 获取列表长度（即当前元素数量） """ def size(self): - return self._size + return self.__size """ 获取列表容量 """ def capacity(self): - return self._capacity + return self.__capacity """ 访问元素 """ def get(self, index): # 索引如果越界则抛出异常，下同 - assert index < self._size, "索引越界" - return self._nums[index] + assert index < self.__size, "索引越界" + return self.__nums[index] """ 更新元素 """ def set(self, num, index): - assert index < self._size, "索引越界" - self._nums[index] = num + assert index < self.__size, "索引越界" + self.__nums[index] = num """ 中间插入元素 """ def add(self, num, index=-1): - assert index < self._size, "索引越界" + assert index < self.__size, "索引越界" if index == -1: - index = self._size + index = self.__size # 元素数量超出容量时，触发扩容机制 - if self._size == self.capacity(): + if self.__size == self.capacity(): self.extend_capacity() # 索引 i 以及之后的元素都向后移动一位 - for j in range(self._size - 1, index - 1, -1): - self._nums[j + 1] = self._nums[j] - self._nums[index] = num + for j in range(self.__size - 1, index - 1, -1): + self.__nums[j + 1] = self.__nums[j] + self.__nums[index] = num # 更新元素数量 - self._size += 1 + self.__size += 1 """ 删除元素 """ def remove(self, index): - assert index < self._size, "索引越界" + assert index < self.__size, "索引越界" # 索引 i 之后的元素都向前移动一位 - for j in range(index, self._size - 1): - self._nums[j] = self._nums[j + 1] + for j in range(index, self.__size - 1): + self.__nums[j] = self.__nums[j + 1] # 更新元素数量 - self._size -= 1 + self.__size -= 1 """ 列表扩容 """ def extend_capacity(self): - # 新建一个长度为 self._size 的数组，并将原数组拷贝到新数组 - self._nums = self._nums + [0] * self.capacity() * (self._extend_ratio - 1) + # 新建一个长度为 self.__size 的数组，并将原数组拷贝到新数组 + self.__nums = self.__nums + [0] * self.capacity() * (self.__extend_ratio - 1) # 更新列表容量 - self._capacity = len(self._nums) + self.__capacity = len(self.__nums) """ 返回有效长度的列表 """ def to_array(self): - return self._nums[:self._size] + return self.__nums[:self.__size] """ Driver Code """ diff --git a/codes/python/chapter_stack_and_queue/array_stack.py b/codes/python/chapter_stack_and_queue/array_stack.py index ad899d905..e0bf5f20f 100644 --- a/codes/python/chapter_stack_and_queue/array_stack.py +++ b/codes/python/chapter_stack_and_queue/array_stack.py @@ -38,7 +38,7 @@ class ArrayStack: return self.__stack[index] """ 返回列表用于打印 """ - def toList(self): + def to_list(self): return self.__stack @@ -53,7 +53,7 @@ if __name__ == "__main__": stack.push(2) stack.push(5) stack.push(4) - print("栈 stack =", stack.toList()) + print("栈 stack =", stack.to_list()) """ 访问栈顶元素 """ peek = stack.peek() @@ -62,11 +62,12 @@ if __name__ == "__main__": """ 元素出栈 """ pop = stack.pop() print("出栈元素 pop =", pop) - print("出栈后 stack =", stack.toList()) + print("出栈后 stack =", stack.to_list()) """ 获取栈的长度 """ size = stack.size() print("栈的长度 size =", size) """ 判断是否为空 """ - isEmpty = stack.is_empty() + is_empty = stack.is_empty() + print("栈是否为空 =", is_empty) \ No newline at end of file diff --git a/codes/python/chapter_stack_and_queue/linkedlist_stack.py b/codes/python/chapter_stack_and_queue/linkedlist_stack.py index dce1e3586..49d1366c9 100644 --- a/codes/python/chapter_stack_and_queue/linkedlist_stack.py +++ b/codes/python/chapter_stack_and_queue/linkedlist_stack.py @@ -11,7 +11,7 @@ from include import * """ 基于链表实现的栈 """ class LinkedListStack: def __init__(self): - self.__head = None + self.__peek = None self.__size = 0 """ 获取栈的长度 """ @@ -20,34 +20,34 @@ class LinkedListStack: """ 判断栈是否为空 """ def is_empty(self): - return not self.__head + return not self.__peek """ 入栈 """ def push(self, val): node = ListNode(val) - node.next = self.__head - self.__head = node + node.next = self.__peek + self.__peek = node self.__size += 1 """ 出栈 """ def pop(self): # 判空处理 - if not self.__head: return None - pop = self.__head.val - self.__head = self.__head.next + if not self.__peek: return None + pop = self.__peek.val + self.__peek = self.__peek.next self.__size -= 1 return pop """ 访问栈顶元素 """ def peek(self): # 判空处理 - if not self.__head: return None - return self.__head.val + if not self.__peek: return None + return self.__peek.val """ 转化为列表用于打印 """ def to_list(self): arr = [] - node = self.__head + node = self.__peek while node: arr.append(node.val) node = node.next @@ -82,4 +82,5 @@ if __name__ == "__main__": print("栈的长度 size =", size) """ 判断是否为空 """ - isEmpty = stack.is_empty() + is_empty = stack.is_empty() + print("栈是否为空 =", is_empty) diff --git a/codes/python/chapter_stack_and_queue/stack.py b/codes/python/chapter_stack_and_queue/stack.py index 80e7fcc2b..a8d2a7a50 100644 --- a/codes/python/chapter_stack_and_queue/stack.py +++ b/codes/python/chapter_stack_and_queue/stack.py @@ -37,4 +37,5 @@ if __name__ == "__main__": print("栈的长度 size =", size) """ 判断是否为空 """ - isEmpty = len(stack) == 0 + is_empty = len(stack) == 0 + print("栈是否为空 =", is_empty) diff --git a/docs/chapter_array_and_linkedlist/list.md b/docs/chapter_array_and_linkedlist/list.md index a8310ec68..11dd816ec 100644 --- a/docs/chapter_array_and_linkedlist/list.md +++ b/docs/chapter_array_and_linkedlist/list.md @@ -356,14 +356,14 @@ comments: true int get(int index) { // 索引如果越界则抛出异常，下同 if (index >= size()) - throw std::out_of_range ("索引越界"); + throw out_of_range("索引越界"); return nums[index]; } /* 更新元素 */ void set(int index, int num) { if (index >= size()) - throw std::out_of_range ("索引越界"); + throw out_of_range("索引越界"); nums[index] = num; } @@ -380,7 +380,7 @@ comments: true /* 中间插入元素 */ void insert(int index, int num) { if (index >= size()) - throw std::out_of_range ("索引越界"); + throw out_of_range("索引越界"); // 元素数量超出容量时，触发扩容机制 if (size() == capacity()) extendCapacity(); @@ -396,7 +396,7 @@ comments: true /* 删除元素 */ void remove(int index) { if (index >= size()) - throw std::out_of_range ("索引越界"); + throw out_of_range("索引越界"); // 索引 i 之后的元素都向前移动一位 for (int j = index; j < size() - 1; j++) { nums[j] = nums[j + 1]; @@ -439,58 +439,58 @@ comments: true class MyList: """ 构造函数 """ def __init__(self): - self._capacity = 10 # 列表容量 - self._nums = [0] * self._capacity # 数组（存储列表元素） - self._size = 0 # 列表长度（即当前元素数量） - self._extend_ratio = 2 # 每次列表扩容的倍数 + self.__capacity = 10 # 列表容量 + self.__nums = [0] * self.__capacity # 数组（存储列表元素） + self.__size = 0 # 列表长度（即当前元素数量） + self.__extend_ratio = 2 # 每次列表扩容的倍数 """ 获取列表长度（即当前元素数量） """ def size(self): - return self._size + return self.__size """ 获取列表容量 """ def capacity(self): - return self._capacity + return self.__capacity """ 访问元素 """ def get(self, index): # 索引如果越界则抛出异常，下同 - assert index < self._size, "索引越界" - return self._nums[index] + assert index < self.__size, "索引越界" + return self.__nums[index] """ 更新元素 """ def set(self, num, index): - assert index < self._size, "索引越界" - self._nums[index] = num + assert index < self.__size, "索引越界" + self.__nums[index] = num """ 中间插入元素 """ def add(self, num, index=-1): - assert index < self._size, "索引越界" + assert index < self.__size, "索引越界" if index == -1: - index = self._size + index = self.__size # 元素数量超出容量时，触发扩容机制 - if self._size == self.capacity(): + if self.__size == self.capacity(): self.extend_capacity() # 索引 i 以及之后的元素都向后移动一位 - for j in range(self._size - 1, index - 1, -1): - self._nums[j + 1] = self._nums[j] - self._nums[index] = num + for j in range(self.__size - 1, index - 1, -1): + self.__nums[j + 1] = self.__nums[j] + self.__nums[index] = num # 更新元素数量 - self._size += 1 + self.__size += 1 """ 删除元素 """ def remove(self, index): - assert index < self._size, "索引越界" + assert index < self.__size, "索引越界" # 索引 i 之后的元素都向前移动一位 - for j in range(index, self._size - 1): - self._nums[j] = self._nums[j + 1] + for j in range(index, self.__size - 1): + self.__nums[j] = self.__nums[j + 1] # 更新元素数量 - self._size -= 1 + self.__size -= 1 """ 列表扩容 """ def extend_capacity(self): - # 新建一个长度为 self._size 的数组，并将原数组拷贝到新数组 - self._nums = self._nums + [0] * self.capacity() * (self._extend_ratio - 1) + # 新建一个长度为 self.__size 的数组，并将原数组拷贝到新数组 + self.__nums = self.__nums + [0] * self.capacity() * (self.__extend_ratio - 1) # 更新列表容量 - self._capacity = len(self._nums) + self.__capacity = len(self.__nums) ``` diff --git a/docs/chapter_stack_and_queue/deque.md b/docs/chapter_stack_and_queue/deque.md index eef13e7f5..407d35386 100644 --- a/docs/chapter_stack_and_queue/deque.md +++ b/docs/chapter_stack_and_queue/deque.md @@ -38,35 +38,34 @@ comments: true ```java title="deque.java" /* 初始化双向队列 */ Deque deque = new LinkedList<>(); - + /* 元素入队 */ deque.offerLast(2); deque.offerLast(5); deque.offerLast(4); deque.offerFirst(3); deque.offerFirst(1); - System.out.println("队列 deque = " + deque); - + System.out.println("双向队列 deque = " + deque); + /* 访问队首元素 */ int peekFirst = deque.peekFirst(); System.out.println("队首元素 peekFirst = " + peekFirst); int peekLast = deque.peekLast(); System.out.println("队尾元素 peekLast = " + peekLast); - + /* 元素出队 */ int pollFirst = deque.pollFirst(); - System.out.println("队首出队元素 pollFirst = " + pollFirst + - "，队首出队后 deque = " + deque); + System.out.println("队首出队元素 pollFirst = " + pollFirst + "，队首出队后 deque = " + deque); int pollLast = deque.pollLast(); - System.out.println("队尾出队元素 pollLast = " + pollLast + - "，队尾出队后 deque = " + deque); - - /* 获取队列的长度 */ + System.out.println("队尾出队元素 pollLast = " + pollLast + "，队尾出队后 deque = " + deque); + + /* 获取双向队列的长度 */ int size = deque.size(); - System.out.println("队列长度 size = " + size); - - /* 判断队列是否为空 */ + System.out.println("双向队列长度 size = " + size); + + /* 判断双向队列是否为空 */ boolean isEmpty = deque.isEmpty(); + System.out.println("双向队列是否为空 = " + isEmpty); ``` === "C++" diff --git a/docs/chapter_stack_and_queue/queue.md b/docs/chapter_stack_and_queue/queue.md index 0788ef03d..063768843 100644 --- a/docs/chapter_stack_and_queue/queue.md +++ b/docs/chapter_stack_and_queue/queue.md @@ -60,6 +60,7 @@ comments: true /* 判断队列是否为空 */ boolean isEmpty = queue.isEmpty(); + System.out.println("队列是否为空 = " + isEmpty); ``` === "C++" @@ -145,10 +146,9 @@ comments: true ```java title="array_queue.java" /* 基于环形数组实现的队列 */ class ArrayQueue { - int[] nums; // 用于存储队列元素的数组 - int size = 0; // 队列长度（即元素个数） - int front = 0; // 头指针，指向队首 - int rear = 0; // 尾指针，指向队尾 + 1 + private int[] nums; // 用于存储队列元素的数组 + private int front = 0; // 头指针，指向队首 + private int rear = 0; // 尾指针，指向队尾 + 1 public ArrayQueue(int capacity) { // 初始化数组 diff --git a/docs/chapter_stack_and_queue/stack.md b/docs/chapter_stack_and_queue/stack.md index aa0b3128f..b7b3e9304 100644 --- a/docs/chapter_stack_and_queue/stack.md +++ b/docs/chapter_stack_and_queue/stack.md @@ -36,22 +36,23 @@ comments: true ```java title="stack.java" /* 初始化栈 */ - Stack stack = new Stack<>(); + // 在 Java 中，推荐将 LinkedList 当作栈来使用 + LinkedList stack = new LinkedList<>(); /* 元素入栈 */ - stack.push(1); - stack.push(3); - stack.push(2); - stack.push(5); - stack.push(4); + stack.addLast(1); + stack.addLast(3); + stack.addLast(2); + stack.addLast(5); + stack.addLast(4); System.out.println("栈 stack = " + stack); /* 访问栈顶元素 */ - int peek = stack.peek(); + int peek = stack.peekLast(); System.out.println("栈顶元素 peek = " + peek); /* 元素出栈 */ - int pop = stack.pop(); + int pop = stack.removeLast(); System.out.println("出栈元素 pop = " + pop + "，出栈后 stack = " + stack); /* 获取栈的长度 */ @@ -60,18 +61,73 @@ comments: true /* 判断是否为空 */ boolean isEmpty = stack.isEmpty(); + System.out.println("栈是否为空 = " + isEmpty); ``` === "C++" ```cpp title="stack.cpp" - + /* 初始化栈 */ + stack stack; + + /* 元素入栈 */ + stack.push(1); + stack.push(3); + stack.push(2); + stack.push(5); + stack.push(4); + cout << "栈 stack = "; + PrintUtil::printStack(stack); + + /* 访问栈顶元素 */ + int top = stack.top(); + cout << "栈顶元素 top = " << top << endl; + + /* 元素出栈 */ + stack.pop(); + cout << "出栈元素 pop = " << top << "，出栈后 stack = "; + PrintUtil::printStack(stack); + + /* 获取栈的长度 */ + int size = stack.size(); + cout << "栈的长度 size = " << size << endl; + + /* 判断是否为空 */ + bool empty = stack.empty(); + cout << "栈是否为空 = " << empty << endl; ``` === "Python" ```python title="stack.py" - + """ 初始化栈 """ + # Python 没有内置的栈类，可以把 list 当作栈来使用 + stack = [] + + """ 元素入栈 """ + stack.append(1) + stack.append(3) + stack.append(2) + stack.append(5) + stack.append(4) + print("栈 stack =", stack) + + """ 访问栈顶元素 """ + peek = stack[-1] + print("栈顶元素 peek =", peek) + + """ 元素出栈 """ + pop = stack.pop() + print("出栈元素 pop =", pop) + print("出栈后 stack =", stack) + + """ 获取栈的长度 """ + size = len(stack) + print("栈的长度 size =", size) + + """ 判断是否为空 """ + is_empty = len(stack) == 0 + print("栈是否为空 =", is_empty) ``` ## 栈的实现 @@ -91,14 +147,15 @@ comments: true ```java title="linkedlist_stack.java" /* 基于链表实现的栈 */ class LinkedListStack { - LinkedList list; + private ListNode stackPeek; // 将头结点作为栈顶 + private int stackSize = 0; // 栈的长度 + public LinkedListStack() { - // 初始化链表 - list = new LinkedList<>(); + stackPeek = null; } /* 获取栈的长度 */ public int size() { - return list.size(); + return stackSize; } /* 判断栈是否为空 */ public boolean isEmpty() { @@ -106,15 +163,25 @@ comments: true } /* 入栈 */ public void push(int num) { - list.addLast(num); + ListNode node = new ListNode(num); + node.next = stackPeek; + stackPeek = node; + stackSize++; } /* 出栈 */ public int pop() { - return list.removeLast(); + if (size() == 0) + throw new IndexOutOfBoundsException(); + int num = peek(); + stackPeek = stackPeek.next; + stackSize--; + return num; } /* 访问栈顶元素 */ public int peek() { - return list.getLast(); + if (size() == 0) + throw new IndexOutOfBoundsException(); + return stackPeek.val; } } ``` @@ -122,13 +189,88 @@ comments: true === "C++" ```cpp title="linkedlist_stack.cpp" - + /* 基于链表实现的栈 */ + class LinkedListStack { + private: + ListNode* stackTop; // 将头结点作为栈顶 + int stackSize; // 栈的长度 + + public: + LinkedListStack() { + stackTop = nullptr; + stackSize = 0; + } + /* 获取栈的长度 */ + int size() { + return stackSize; + } + /* 判断栈是否为空 */ + bool empty() { + return size() == 0; + } + /* 入栈 */ + void push(int num) { + ListNode* node = new ListNode(num); + node->next = stackTop; + stackTop = node; + stackSize++; + } + /* 出栈 */ + int pop() { + if (size() == 0) + throw out_of_range("栈为空"); + int num = stackTop->val; + stackTop = stackTop->next; + stackSize--; + return num; + } + /* 访问栈顶元素 */ + int top() { + if (size() == 0) + throw out_of_range("栈为空"); + return stackTop->val; + } + }; ``` === "Python" ```python title="linkedlist_stack.py" - + """ 基于链表实现的栈 """ + class LinkedListStack: + def __init__(self): + self.__peek = None + self.__size = 0 + + """ 获取栈的长度 """ + def size(self): + return self.__size + + """ 判断栈是否为空 """ + def is_empty(self): + return not self.__peek + + """ 入栈 """ + def push(self, val): + node = ListNode(val) + node.next = self.__peek + self.__peek = node + self.__size += 1 + + """ 出栈 """ + def pop(self): + # 判空处理 + if not self.__peek: return None + pop = self.__peek.val + self.__peek = self.__peek.next + self.__size -= 1 + return pop + + """ 访问栈顶元素 """ + def peek(self): + # 判空处理 + if not self.__peek: return None + return self.__peek.val ``` ### 基于数组的实现 @@ -142,14 +284,14 @@ comments: true ```java title="array_stack.java" /* 基于数组实现的栈 */ class ArrayStack { - List list; + private ArrayList stack; public ArrayStack() { // 初始化列表（动态数组） - list = new ArrayList<>(); + stack = new ArrayList<>(); } /* 获取栈的长度 */ public int size() { - return list.size(); + return stack.size(); } /* 判断栈是否为空 */ public boolean isEmpty() { @@ -157,19 +299,19 @@ comments: true } /* 入栈 */ public void push(int num) { - list.add(num); + stack.add(num); } /* 出栈 */ public int pop() { - return list.remove(size() - 1); + return stack.remove(size() - 1); } /* 访问栈顶元素 */ public int peek() { - return list.get(size() - 1); + return stack.get(size() - 1); } /* 访问索引 index 处元素 */ public int get(int index) { - return list.get(index); + return stack.get(index); } } ``` @@ -177,13 +319,72 @@ comments: true === "C++" ```cpp title="array_stack.cpp" - + /* 基于数组实现的栈 */ + class ArrayStack { + private: + vector stack; + + public: + /* 获取栈的长度 */ + int size() { + return stack.size(); + } + /* 判断栈是否为空 */ + bool empty() { + return stack.empty(); + } + /* 入栈 */ + void push(int num) { + stack.push_back(num); + } + /* 出栈 */ + int pop() { + int oldTop = stack.back(); + stack.pop_back(); + return oldTop; + } + /* 访问栈顶元素 */ + int top() { + return stack.back(); + } + /* 访问索引 index 处元素 */ + int get(int index) { + return stack[index]; + } + }; ``` === "Python" ```python title="array_stack.py" - + """ 基于数组实现的栈 """ + class ArrayStack: + def __init__(self): + self.__stack = [] + + """ 获取栈的长度 """ + def size(self): + return len(self.__stack) + + """ 判断栈是否为空 """ + def is_empty(self): + return self.__stack == [] + + """ 入栈 """ + def push(self, item): + self.__stack.append(item) + + """ 出栈 """ + def pop(self): + return self.__stack.pop() + + """ 访问栈顶元素 """ + def peek(self): + return self.__stack[-1] + + """ 访问索引 index 处元素 """ + def get(self, index): + return self.__stack[index] ``` !!! tip @@ -193,5 +394,4 @@ comments: true ## 栈典型应用 - **浏览器中的后退与前进、软件中的撤销与反撤销。** 每当我们打开新的网页，浏览器就讲上一个网页执行入栈，这样我们就可以通过「后退」操作来回到上一页面，后退操作实际上是在执行出栈。如果要同时支持后退和前进，那么则需要两个栈来配合实现。 - - **程序内存管理。** 每当调用函数时，系统就会在栈顶添加一个栈帧，用来记录函数的上下文信息。在递归函数中，向下递推会不断执行入栈，向上回溯阶段时出栈。 From acfdc713bafc7cf6b27041c75be53941d928d851 Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Wed, 30 Nov 2022 03:46:53 +0800 Subject: [PATCH 31/67] update stack and queue. --- .../chapter_stack_and_queue/array_queue.cpp | 27 ++- .../chapter_stack_and_queue/array_stack.cpp | 4 + .../linkedlist_queue.cpp | 46 +++-- .../linkedlist_stack.cpp | 14 +- .../chapter_stack_and_queue/array_queue.java | 14 +- .../chapter_stack_and_queue/array_stack.java | 4 + .../linkedlist_queue.java | 45 +++-- .../linkedlist_stack.java | 10 +- .../chapter_stack_and_queue/array_stack.py | 4 + .../linkedlist_stack.py | 6 +- docs/chapter_stack_and_queue/deque.md | 43 +++-- docs/chapter_stack_and_queue/queue.md | 178 ++++++++++++++++-- docs/chapter_stack_and_queue/stack.md | 50 ++--- 13 files changed, 321 insertions(+), 124 deletions(-) diff --git a/codes/cpp/chapter_stack_and_queue/array_queue.cpp b/codes/cpp/chapter_stack_and_queue/array_queue.cpp index 0aea80b02..e98caa2e0 100644 --- a/codes/cpp/chapter_stack_and_queue/array_queue.cpp +++ b/codes/cpp/chapter_stack_and_queue/array_queue.cpp @@ -9,26 +9,27 @@ /* 基于环形数组实现的队列 */ class ArrayQueue { private: - vector nums; // 用于存储队列元素的数组 - int front = 0; // 头指针，指向队首 - int rear = 0; // 尾指针，指向队尾 + 1 + int *nums; // 用于存储队列元素的数组 + int cap; // 队列容量 + int front = 0; // 头指针，指向队首 + int rear = 0; // 尾指针，指向队尾 + 1 public: ArrayQueue(int capacity) { // 初始化数组 - nums.resize(capacity); + cap = capacity; + nums = new int[capacity]; } /* 获取队列的容量 */ int capacity() { - return nums.size(); + return cap; } /* 获取队列的长度 */ int size() { - int cap = capacity(); // 由于将数组看作为环形，可能 rear < front ，因此需要取余数 - return (cap + rear - front) % cap; + return (capacity() + rear - front) % capacity(); } /* 判断队列是否为空 */ @@ -67,6 +68,14 @@ public: return nums[front]; } + /* 访问指定索引元素 */ + int get(int index) { + if (index >= size()) + throw out_of_range("索引越界"); + return nums[(front + index) % capacity()]; + } + + /* 将数组转化为 Vector 并返回 */ vector toVector() { int siz = size(); int cap = capacity(); @@ -99,6 +108,10 @@ int main() { int peek = queue->peek(); cout << "队首元素 peek = " << peek << endl; + /* 访问指定索引元素 */ + int num = queue->get(2); + cout << "队列第 3 个元素为 num = " << num << endl; + /* 元素出队 */ int poll = queue->poll(); cout << "出队元素 poll = " << poll << "，出队后 queue = "; diff --git a/codes/cpp/chapter_stack_and_queue/array_stack.cpp b/codes/cpp/chapter_stack_and_queue/array_stack.cpp index ccc1cb912..96a751035 100644 --- a/codes/cpp/chapter_stack_and_queue/array_stack.cpp +++ b/codes/cpp/chapter_stack_and_queue/array_stack.cpp @@ -69,6 +69,10 @@ int main() { int top = stack->top(); cout << "栈顶元素 top = " << top << endl; + /* 访问索引 index 处元素 */ + int num = stack->get(3); + cout << "栈索引 3 处的元素为 num = " << num << endl; + /* 元素出栈 */ int pop = stack->pop(); cout << "出栈元素 pop = " << pop << "，出栈后 stack = "; diff --git a/codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp b/codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp index d3cb35b38..17625322d 100644 --- a/codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp +++ b/codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp @@ -9,60 +9,68 @@ /* 基于链表实现的队列 */ class LinkedListQueue { private: - ListNode *front, *back; - int qSize; + ListNode *front, *rear; // 头结点 front ，尾结点 rear + int queSize; public: LinkedListQueue() { front = nullptr; - back = nullptr; - qSize = 0; + rear = nullptr; + queSize = 0; } /* 获取队列的长度 */ int size() { - return qSize; + return queSize; } /* 判断队列是否为空 */ bool empty() { - return qSize == 0; + return queSize == 0; } /* 入队 */ void offer(int num) { // 尾结点后添加 num ListNode* node = new ListNode(num); - node->next = back; - back = node; - qSize++; + // 如果队列为空，则令头、尾结点都指向该结点 + if (front == nullptr) { + front = node; + rear = node; + } + // 如果队列不为空，则将该结点添加到尾结点后 + else { + rear->next = node; + rear = node; + } + queSize++; } /* 出队 */ int poll() { - if (qSize == 0) - throw out_of_range("队列为空"); + int num = peek(); // 删除头结点 - ListNode* node = front; front = front->next; - return node->val; + queSize--; + return num; } /* 访问队首元素 */ int peek() { + if (size() == 0) + throw out_of_range("队列为空"); return front->val; } - /* 将 List 转化为 Array 并返回 */ + /* 将链表转化为 Vector 并返回 */ vector toVector() { ListNode* node = front; - vector vec; - while (node != nullptr) { - vec.push_back(node->val); + vector res(size()); + for (int i = 0; i < res.size(); i++) { + res[i] = node->val; node = node->next; } - reverse(vec.begin(), vec.end()); - return vec; + return res; } }; diff --git a/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp b/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp index 1ffae5ecd..1bb7c2a3c 100644 --- a/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp +++ b/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp @@ -10,17 +10,17 @@ class LinkedListStack { private: ListNode* stackTop; // 将头结点作为栈顶 - int stackSize; // 栈的长度 + int stkSize; // 栈的长度 public: LinkedListStack() { stackTop = nullptr; - stackSize = 0; + stkSize = 0; } /* 获取栈的长度 */ int size() { - return stackSize; + return stkSize; } /* 判断栈是否为空 */ @@ -33,16 +33,14 @@ public: ListNode* node = new ListNode(num); node->next = stackTop; stackTop = node; - stackSize++; + stkSize++; } /* 出栈 */ int pop() { - if (size() == 0) - throw out_of_range("栈为空"); - int num = stackTop->val; + int num = top(); stackTop = stackTop->next; - stackSize--; + stkSize--; return num; } diff --git a/codes/java/chapter_stack_and_queue/array_queue.java b/codes/java/chapter_stack_and_queue/array_queue.java index aab31542d..ff22559ea 100644 --- a/codes/java/chapter_stack_and_queue/array_queue.java +++ b/codes/java/chapter_stack_and_queue/array_queue.java @@ -67,15 +67,23 @@ class ArrayQueue { return nums[front]; } + /* 访问索引 index 处元素 */ + int get(int index) { + if (index >= size()) + throw new IndexOutOfBoundsException(); + return nums[(front + index) % capacity()]; + } + + /* 返回数组 */ public int[] toArray() { int size = size(); int capacity = capacity(); // 仅转换有效长度范围内的列表元素 - int[] arr = new int[size]; + int[] res = new int[size]; for (int i = 0, j = front; i < size; i++, j++) { - arr[i] = nums[j % capacity]; + res[i] = nums[j % capacity]; } - return arr; + return res; } } diff --git a/codes/java/chapter_stack_and_queue/array_stack.java b/codes/java/chapter_stack_and_queue/array_stack.java index 0ac9b45cf..26a3e9605 100644 --- a/codes/java/chapter_stack_and_queue/array_stack.java +++ b/codes/java/chapter_stack_and_queue/array_stack.java @@ -69,6 +69,10 @@ public class array_stack { int peek = stack.peek(); System.out.println("栈顶元素 peek = " + peek); + /* 访问索引 index 处元素 */ + int num = stack.get(3); + System.out.println("栈索引 3 处的元素为 num = " + num); + /* 元素出栈 */ int pop = stack.pop(); System.out.println("出栈元素 pop = " + pop + "，出栈后 stack = " + Arrays.toString(stack.toArray())); diff --git a/codes/java/chapter_stack_and_queue/linkedlist_queue.java b/codes/java/chapter_stack_and_queue/linkedlist_queue.java index 9429cc359..291ff4174 100644 --- a/codes/java/chapter_stack_and_queue/linkedlist_queue.java +++ b/codes/java/chapter_stack_and_queue/linkedlist_queue.java @@ -7,46 +7,69 @@ package chapter_stack_and_queue; import java.util.*; +import include.*; /* 基于链表实现的队列 */ class LinkedListQueue { - LinkedList list; + private ListNode front, rear; // 头结点 front ，尾结点 rear + private int queSize = 0; public LinkedListQueue() { - // 初始化链表 - list = new LinkedList<>(); + front = null; + rear = null; } /* 获取队列的长度 */ public int size() { - return list.size(); + return queSize; } /* 判断队列是否为空 */ public boolean isEmpty() { - return list.size() == 0; + return size() == 0; } /* 入队 */ public void offer(int num) { // 尾结点后添加 num - list.addLast(num); + ListNode node = new ListNode(num); + // 如果队列为空，则令头、尾结点都指向该结点 + if (front == null) { + front = node; + rear = node; + // 如果队列不为空，则将该结点添加到尾结点后 + } else { + rear.next = node; + rear = node; + } + queSize++; } /* 出队 */ public int poll() { + int num = peek(); // 删除头结点 - return list.removeFirst(); + front = front.next; + queSize--; + return num; } /* 访问队首元素 */ public int peek() { - return list.getFirst(); + if (size() == 0) + throw new IndexOutOfBoundsException(); + return front.val; } - /* 将 List 转化为 Array 并返回 */ - public Object[] toArray() { - return list.toArray(); + /* 将链表转化为 Array 并返回 */ + public int[] toArray() { + ListNode node = front; + int[] res = new int[size()]; + for (int i = 0; i < res.length; i++) { + res[i] = node.val; + node = node.next; + } + return res; } } diff --git a/codes/java/chapter_stack_and_queue/linkedlist_stack.java b/codes/java/chapter_stack_and_queue/linkedlist_stack.java index 0dc47985e..8b1d67b13 100644 --- a/codes/java/chapter_stack_and_queue/linkedlist_stack.java +++ b/codes/java/chapter_stack_and_queue/linkedlist_stack.java @@ -12,7 +12,7 @@ import include.*; /* 基于链表实现的栈 */ class LinkedListStack { private ListNode stackPeek; // 将头结点作为栈顶 - private int stackSize = 0; // 栈的长度 + private int stkSize = 0; // 栈的长度 public LinkedListStack() { stackPeek = null; @@ -20,7 +20,7 @@ class LinkedListStack { /* 获取栈的长度 */ public int size() { - return stackSize; + return stkSize; } /* 判断栈是否为空 */ @@ -33,16 +33,14 @@ class LinkedListStack { ListNode node = new ListNode(num); node.next = stackPeek; stackPeek = node; - stackSize++; + stkSize++; } /* 出栈 */ public int pop() { - if (size() == 0) - throw new IndexOutOfBoundsException(); int num = peek(); stackPeek = stackPeek.next; - stackSize--; + stkSize--; return num; } diff --git a/codes/python/chapter_stack_and_queue/array_stack.py b/codes/python/chapter_stack_and_queue/array_stack.py index e0bf5f20f..b1640a068 100644 --- a/codes/python/chapter_stack_and_queue/array_stack.py +++ b/codes/python/chapter_stack_and_queue/array_stack.py @@ -59,6 +59,10 @@ if __name__ == "__main__": peek = stack.peek() print("栈顶元素 peek =", peek) + """ 访问索引 index 处元素 """ + num = stack.get(3); + print("栈索引 3 处的元素为 num =", num); + """ 元素出栈 """ pop = stack.pop() print("出栈元素 pop =", pop) diff --git a/codes/python/chapter_stack_and_queue/linkedlist_stack.py b/codes/python/chapter_stack_and_queue/linkedlist_stack.py index 49d1366c9..5ee90353b 100644 --- a/codes/python/chapter_stack_and_queue/linkedlist_stack.py +++ b/codes/python/chapter_stack_and_queue/linkedlist_stack.py @@ -31,12 +31,10 @@ class LinkedListStack: """ 出栈 """ def pop(self): - # 判空处理 - if not self.__peek: return None - pop = self.__peek.val + num = self.peek() self.__peek = self.__peek.next self.__size -= 1 - return pop + return num """ 访问栈顶元素 """ def peek(self): diff --git a/docs/chapter_stack_and_queue/deque.md b/docs/chapter_stack_and_queue/deque.md index 407d35386..06657626b 100644 --- a/docs/chapter_stack_and_queue/deque.md +++ b/docs/chapter_stack_and_queue/deque.md @@ -40,38 +40,53 @@ comments: true Deque deque = new LinkedList<>(); /* 元素入队 */ - deque.offerLast(2); + deque.offerLast(2); // 添加至队尾 deque.offerLast(5); deque.offerLast(4); - deque.offerFirst(3); + deque.offerFirst(3); // 添加至队首 deque.offerFirst(1); - System.out.println("双向队列 deque = " + deque); /* 访问队首元素 */ - int peekFirst = deque.peekFirst(); - System.out.println("队首元素 peekFirst = " + peekFirst); - int peekLast = deque.peekLast(); - System.out.println("队尾元素 peekLast = " + peekLast); + int peekFirst = deque.peekFirst(); // 队首元素 + int peekLast = deque.peekLast(); // 队尾元素 /* 元素出队 */ - int pollFirst = deque.pollFirst(); - System.out.println("队首出队元素 pollFirst = " + pollFirst + "，队首出队后 deque = " + deque); - int pollLast = deque.pollLast(); - System.out.println("队尾出队元素 pollLast = " + pollLast + "，队尾出队后 deque = " + deque); + int pollFirst = deque.pollFirst(); // 队首元素出队 + int pollLast = deque.pollLast(); // 队尾元素出队 /* 获取双向队列的长度 */ int size = deque.size(); - System.out.println("双向队列长度 size = " + size); /* 判断双向队列是否为空 */ boolean isEmpty = deque.isEmpty(); - System.out.println("双向队列是否为空 = " + isEmpty); ``` === "C++" ```cpp title="deque.cpp" - + /* 初始化双向队列 */ + deque deque; + + /* 元素入队 */ + deque.push_back(2); // 添加至队尾 + deque.push_back(5); + deque.push_back(4); + deque.push_front(3); // 添加至队首 + deque.push_front(1); + + /* 访问队首元素 */ + int front = deque.front(); // 队首元素 + int back = deque.back(); // 队尾元素 + + /* 元素出队 */ + deque.pop_front(); // 队首元素出队 + deque.pop_back(); // 队尾元素出队 + + /* 获取双向队列的长度 */ + int size = deque.size(); + + /* 判断双向队列是否为空 */ + bool empty = deque.empty(); ``` === "Python" diff --git a/docs/chapter_stack_and_queue/queue.md b/docs/chapter_stack_and_queue/queue.md index 063768843..f69f37e09 100644 --- a/docs/chapter_stack_and_queue/queue.md +++ b/docs/chapter_stack_and_queue/queue.md @@ -44,29 +44,44 @@ comments: true queue.offer(2); queue.offer(5); queue.offer(4); - System.out.println("队列 queue = " + queue); /* 访问队首元素 */ int peek = queue.peek(); - System.out.println("队首元素 peek = " + peek); /* 元素出队 */ int poll = queue.poll(); - System.out.println("出队元素 poll = " + poll + "，出队后 queue = " + queue); /* 获取队列的长度 */ int size = queue.size(); - System.out.println("队列长度 size = " + size); /* 判断队列是否为空 */ boolean isEmpty = queue.isEmpty(); - System.out.println("队列是否为空 = " + isEmpty); ``` === "C++" ```cpp title="queue.cpp" + /* 初始化队列 */ + queue queue; + /* 元素入队 */ + queue.push(1); + queue.push(3); + queue.push(2); + queue.push(5); + queue.push(4); + + /* 访问队首元素 */ + int front = queue.front(); + + /* 元素出队 */ + queue.pop(); + + /* 获取队列的长度 */ + int size = queue.size(); + + /* 判断队列是否为空 */ + bool empty = queue.empty(); ``` === "Python" @@ -88,33 +103,49 @@ comments: true ```java title="linkedlist_queue.java" /* 基于链表实现的队列 */ class LinkedListQueue { - LinkedList list; + private ListNode front, rear; // 头结点 front ，尾结点 rear + private int queSize = 0; public LinkedListQueue() { - // 初始化链表 - list = new LinkedList<>(); + front = null; + rear = null; } /* 获取队列的长度 */ public int size() { - return list.size(); + return queSize; } /* 判断队列是否为空 */ public boolean isEmpty() { - return list.size() == 0; + return size() == 0; } /* 入队 */ public void offer(int num) { // 尾结点后添加 num - list.addLast(num); + ListNode node = new ListNode(num); + // 如果队列为空，则令头、尾结点都指向该结点 + if (front == null) { + front = node; + rear = node; + // 如果队列不为空，则将该结点添加到尾结点后 + } else { + rear.next = node; + rear = node; + } + queSize++; } /* 出队 */ public int poll() { + int num = peek(); // 删除头结点 - return list.removeFirst(); + front = front.next; + queSize--; + return num; } /* 访问队首元素 */ public int peek() { - return list.getFirst(); + if (size() == 0) + throw new IndexOutOfBoundsException(); + return front.val; } } ``` @@ -122,7 +153,57 @@ comments: true === "C++" ```cpp title="linkedlist_queue.cpp" - + /* 基于链表实现的队列 */ + class LinkedListQueue { + private: + ListNode *front, *rear; // 头结点 front ，尾结点 rear + int queSize; + + public: + LinkedListQueue() { + front = nullptr; + rear = nullptr; + queSize = 0; + } + /* 获取队列的长度 */ + int size() { + return queSize; + } + /* 判断队列是否为空 */ + bool empty() { + return queSize == 0; + } + /* 入队 */ + void offer(int num) { + // 尾结点后添加 num + ListNode* node = new ListNode(num); + // 如果队列为空，则令头、尾结点都指向该结点 + if (front == nullptr) { + front = node; + rear = node; + } + // 如果队列不为空，则将该结点添加到尾结点后 + else { + rear->next = node; + rear = node; + } + queSize++; + } + /* 出队 */ + int poll() { + int num = peek(); + // 删除头结点 + front = front->next; + queSize--; + return num; + } + /* 访问队首元素 */ + int peek() { + if (size() == 0) + throw out_of_range("队列为空"); + return front->val; + } + }; ``` === "Python" @@ -196,13 +277,80 @@ comments: true throw new EmptyStackException(); return nums[front]; } + /* 访问指定索引元素 */ + int get(int index) { + if (index >= size()) + throw new IndexOutOfBoundsException(); + return nums[(front + index) % capacity()]; + } } ``` === "C++" ```cpp title="array_queue.cpp" - + /* 基于环形数组实现的队列 */ + class ArrayQueue { + private: + int *nums; // 用于存储队列元素的数组 + int cap; // 队列容量 + int front = 0; // 头指针，指向队首 + int rear = 0; // 尾指针，指向队尾 + 1 + + public: + ArrayQueue(int capacity) { + // 初始化数组 + cap = capacity; + nums = new int[capacity]; + } + /* 获取队列的容量 */ + int capacity() { + return cap; + } + /* 获取队列的长度 */ + int size() { + // 由于将数组看作为环形，可能 rear < front ，因此需要取余数 + return (capacity() + rear - front) % capacity(); + } + /* 判断队列是否为空 */ + bool empty() { + return rear - front == 0; + } + /* 入队 */ + void offer(int num) { + if (size() == capacity()) { + cout << "队列已满" << endl; + return; + } + // 尾结点后添加 num + nums[rear] = num; + // 尾指针向后移动一位，越过尾部后返回到数组头部 + rear = (rear + 1) % capacity(); + } + /* 出队 */ + int poll() { + // 删除头结点 + if (empty()) + throw out_of_range("队列为空"); + int num = nums[front]; + // 队头指针向后移动，越过尾部后返回到数组头部 + front = (front + 1) % capacity(); + return num; + } + /* 访问队首元素 */ + int peek() { + // 删除头结点 + if (empty()) + throw out_of_range("队列为空"); + return nums[front]; + } + /* 访问指定位置元素 */ + int get(int index) { + if (index >= size()) + throw out_of_range("索引越界"); + return nums[(front + index) % capacity()] + } + }; ``` === "Python" diff --git a/docs/chapter_stack_and_queue/stack.md b/docs/chapter_stack_and_queue/stack.md index b7b3e9304..9991c51e3 100644 --- a/docs/chapter_stack_and_queue/stack.md +++ b/docs/chapter_stack_and_queue/stack.md @@ -45,23 +45,18 @@ comments: true stack.addLast(2); stack.addLast(5); stack.addLast(4); - System.out.println("栈 stack = " + stack); /* 访问栈顶元素 */ int peek = stack.peekLast(); - System.out.println("栈顶元素 peek = " + peek); /* 元素出栈 */ int pop = stack.removeLast(); - System.out.println("出栈元素 pop = " + pop + "，出栈后 stack = " + stack); /* 获取栈的长度 */ int size = stack.size(); - System.out.println("栈的长度 size = " + size); /* 判断是否为空 */ boolean isEmpty = stack.isEmpty(); - System.out.println("栈是否为空 = " + isEmpty); ``` === "C++" @@ -76,32 +71,25 @@ comments: true stack.push(2); stack.push(5); stack.push(4); - cout << "栈 stack = "; - PrintUtil::printStack(stack); /* 访问栈顶元素 */ int top = stack.top(); - cout << "栈顶元素 top = " << top << endl; /* 元素出栈 */ stack.pop(); - cout << "出栈元素 pop = " << top << "，出栈后 stack = "; - PrintUtil::printStack(stack); /* 获取栈的长度 */ int size = stack.size(); - cout << "栈的长度 size = " << size << endl; /* 判断是否为空 */ bool empty = stack.empty(); - cout << "栈是否为空 = " << empty << endl; ``` === "Python" ```python title="stack.py" """ 初始化栈 """ - # Python 没有内置的栈类，可以把 list 当作栈来使用 + # Python 没有内置的栈类，可以把 List 当作栈来使用 stack = [] """ 元素入栈 """ @@ -110,24 +98,18 @@ comments: true stack.append(2) stack.append(5) stack.append(4) - print("栈 stack =", stack) """ 访问栈顶元素 """ peek = stack[-1] - print("栈顶元素 peek =", peek) """ 元素出栈 """ pop = stack.pop() - print("出栈元素 pop =", pop) - print("出栈后 stack =", stack) """ 获取栈的长度 """ size = len(stack) - print("栈的长度 size =", size) """ 判断是否为空 """ is_empty = len(stack) == 0 - print("栈是否为空 =", is_empty) ``` ## 栈的实现 @@ -148,14 +130,14 @@ comments: true /* 基于链表实现的栈 */ class LinkedListStack { private ListNode stackPeek; // 将头结点作为栈顶 - private int stackSize = 0; // 栈的长度 + private int stkSize = 0; // 栈的长度 public LinkedListStack() { stackPeek = null; } /* 获取栈的长度 */ public int size() { - return stackSize; + return stkSize; } /* 判断栈是否为空 */ public boolean isEmpty() { @@ -166,15 +148,13 @@ comments: true ListNode node = new ListNode(num); node.next = stackPeek; stackPeek = node; - stackSize++; + stkSize++; } /* 出栈 */ public int pop() { - if (size() == 0) - throw new IndexOutOfBoundsException(); int num = peek(); stackPeek = stackPeek.next; - stackSize--; + stkSize--; return num; } /* 访问栈顶元素 */ @@ -193,16 +173,16 @@ comments: true class LinkedListStack { private: ListNode* stackTop; // 将头结点作为栈顶 - int stackSize; // 栈的长度 + int stkSize; // 栈的长度 public: LinkedListStack() { stackTop = nullptr; - stackSize = 0; + stkSize = 0; } /* 获取栈的长度 */ int size() { - return stackSize; + return stkSize; } /* 判断栈是否为空 */ bool empty() { @@ -213,15 +193,13 @@ comments: true ListNode* node = new ListNode(num); node->next = stackTop; stackTop = node; - stackSize++; + stkSize++; } /* 出栈 */ int pop() { - if (size() == 0) - throw out_of_range("栈为空"); - int num = stackTop->val; + int num = top(); stackTop = stackTop->next; - stackSize--; + stkSize--; return num; } /* 访问栈顶元素 */ @@ -259,12 +237,10 @@ comments: true """ 出栈 """ def pop(self): - # 判空处理 - if not self.__peek: return None - pop = self.__peek.val + num = self.peek() self.__peek = self.__peek.next self.__size -= 1 - return pop + return num """ 访问栈顶元素 """ def peek(self): From a2b7586c986733f81c6549b9bff7c3fbb98dd267 Mon Sep 17 00:00:00 2001 From: pengchzn Date: Wed, 30 Nov 2022 12:15:50 +0800 Subject: [PATCH 32/67] Add python code for queue --- .../chapter_stack_and_queue/array_queue.py | 91 ++++++++++++++++++- codes/python/chapter_stack_and_queue/deque.py | 43 ++++++++- .../linkedlist_queue.py | 88 +++++++++++++++++- codes/python/chapter_stack_and_queue/queue.py | 38 +++++++- 4 files changed, 248 insertions(+), 12 deletions(-) diff --git a/codes/python/chapter_stack_and_queue/array_queue.py b/codes/python/chapter_stack_and_queue/array_queue.py index 7bc6a3261..0e173fea1 100644 --- a/codes/python/chapter_stack_and_queue/array_queue.py +++ b/codes/python/chapter_stack_and_queue/array_queue.py @@ -1,10 +1,95 @@ ''' File: array_queue.py -Created Time: 2022-11-25 -Author: Krahets (krahets@163.com) +Created Time: 2022-11-29 +Author: Peng Chen (pengchzn@gmail.com) ''' -import sys, os.path as osp +import os.path as osp +import sys + sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__)))) from include import * +""" 基于环形数组实现的队列 """ +class ArrayQueue: + def __init__(self, size): + self.nums = [None] * size # 用于存储队列元素的数组 + self.front = 0 # 头指针，指向队首 + self.rear = 0 # 尾指针，指向队尾 + 1 + + """ 获取队列的容量 """ + def capacity(self): + return len(self.nums) + + """ 获取队列的长度 """ + def size(self): + # 由于将数组看作为环形，可能 rear < front ，因此需要取余数 + return (self.capacity() + self.rear - self.front) % self.capacity() + + """ 判断队列是否为空 """ + def is_empty(self): + return len(self.nums)==0 + + """ 入队 """ + def put(self, val): + if self.size() == self.capacity(): + print("队列已满") + return False + # 尾结点后添加 num + self.nums[self.rear] = val + # 尾指针向后移动一位，越过尾部后返回到数组头部 + self.rear = (self.rear + 1) % self.capacity() + + """ 出队 """ + def get(self): + # 删除头结点 + if self.is_empty(): + print("队列为空") + return False + num = self.nums[self.front] + self.nums[self.front] = None + # 队头指针向后移动，越过尾部后返回到数组头部 + self.front = (self.front + 1) % self.capacity() + return num + + """ 访问队首元素 """ + def peek(self): + # 删除头结点 + if self.is_empty(): + return 1 + return self.nums[self.front] + + """ 访问指定位置元素 """ + def get_index(self, index): + if index >= self.size(): + return -1 + return self.nums[(self.front + index) % self.capacity()] + +if __name__ == "__main__": + """ 初始化队列 """ + queue = ArrayQueue(5) + + """ 元素入队 """ + queue.put(1) + queue.put(3) + queue.put(2) + queue.put(5) + queue.put(4) + print("队列 queue = ", queue.nums) + + """ 访问队首元素 """ + peek = queue.peek() + print("队首元素 peek = ", peek) + + """ 元素出队 """ + get = queue.get() + print("出队元素 get = ", get) + print("出队后 queue = ", queue.nums) + + """ 获取队列的长度 """ + size = queue.size() + print("队列长度 size = ", size) + + """ 判断队列是否为空 """ + is_empty = queue.is_empty() + print("队列是否为空 = ", is_empty) diff --git a/codes/python/chapter_stack_and_queue/deque.py b/codes/python/chapter_stack_and_queue/deque.py index 989497580..0bddd0d8b 100644 --- a/codes/python/chapter_stack_and_queue/deque.py +++ b/codes/python/chapter_stack_and_queue/deque.py @@ -1,10 +1,47 @@ ''' File: deque.py -Created Time: 2022-11-25 -Author: Krahets (krahets@163.com) +Created Time: 2022-11-29 +Author: Peng Chen (pengchzn@gmail.com) ''' -import sys, os.path as osp +import os.path as osp +import sys + sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__)))) from include import * +from collections import deque + +if __name__ == "__main__": + """ 初始化双向队列 """ + duque = deque() + + """ 元素入队 """ + duque.append(2) # 添加至队尾 + duque.append(5) + duque.append(4) + duque.appendleft(3) # 添加至队首 + duque.appendleft(1) + print("双向队列 duque = ", duque) + + """ 访问队首元素 """ + peekFirst = duque[0] # 队首元素 + print("队首元素 peekFirst = ", peekFirst) + peekLast = duque[-1] # 队尾元素 + print("队尾元素 peekLast = ", peekLast) + + """ 元素出队 """ + popFirst = duque.pop() # 队首元素出队 + print("队首出队元素 popFirst= ", popFirst) + print("队首出队后 duque = ", duque) + popLast = duque.popleft() # 队尾元素出队 + print("队尾出队元素 popLast= ", popLast) + print("队尾出队后 duque = ", duque) + + """ 获取队列的长度 """ + size = len(duque) + print("队列长度 size = ", size) + + """ 判断队列是否为空 """ + is_empty = len(duque) == 0 + print("队列是否为空 = ", is_empty) diff --git a/codes/python/chapter_stack_and_queue/linkedlist_queue.py b/codes/python/chapter_stack_and_queue/linkedlist_queue.py index 3606c8a46..53f3b9a82 100644 --- a/codes/python/chapter_stack_and_queue/linkedlist_queue.py +++ b/codes/python/chapter_stack_and_queue/linkedlist_queue.py @@ -1,10 +1,92 @@ ''' File: linkedlist_queue.py -Created Time: 2022-11-25 -Author: Krahets (krahets@163.com) +Created Time: 2022-11-29 +Author: Peng Chen (pengchzn@gmail.com) ''' -import sys, os.path as osp +import os.path as osp +import sys + sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__)))) from include import * +""" 基于链表实现的队列 """ +class LinkedListQueue: + def __init__(self): + self.__front = 0 # 头结点 front + self.__rear = 0 # 尾结点 rear + self.__size = 0 + + """ 获取队列的长度 """ + def size(self): + return self.__size + + """ 判断队列是否为空 """ + def is_empty(self): + return not self.__front + + """ 入队 """ + def put(self, num): + # 尾结点后添加 num + node = ListNode(num) + # 如果队列为空，则令头、尾结点都指向该结点 + if self.__front == 0: + self.__front = node + self.__rear = node + # 如果队列不为空，则将该结点添加到尾结点后 + else: + self.__rear.next = node + self.__rear = node + self.__size += 1 + + """ 出队 """ + def get(self): + num = self.peek() + # 删除头结点 + self.__front = self.__front.next + self.__size -= 1 + return num + + """ 访问队首元素 """ + def peek(self): + if self.size() == 0: + return -1 + return self.__front.val + + def to_array(self): + queue = [] + temp = self.__front + while temp: + queue.append(temp.val) + temp = temp.next + return queue + + +if __name__ == "__main__": + """ 初始化队列 """ + queue = LinkedListQueue() + + """ 元素入队 """ + queue.put(1) + queue.put(3) + queue.put(2) + queue.put(5) + queue.put(4) + print("队列 queue = ", queue.to_array()) + + """ 访问队首元素 """ + peek = queue.peek() + print("队首元素 front = ", peek) + + """ 元素出队 """ + get = queue.get() + print("出队元素 get = ", get) + print("出队后 queue = ", queue.to_array()) + + """ 获取队列的长度 """ + size = queue.size() + print("队列长度 size = ", size) + + """ 判断队列是否为空 """ + is_empty = queue.is_empty() + print("队列是否为空 = ", is_empty) diff --git a/codes/python/chapter_stack_and_queue/queue.py b/codes/python/chapter_stack_and_queue/queue.py index 52855b2a0..3f39d2d87 100644 --- a/codes/python/chapter_stack_and_queue/queue.py +++ b/codes/python/chapter_stack_and_queue/queue.py @@ -1,10 +1,42 @@ ''' File: queue.py -Created Time: 2022-11-25 -Author: Krahets (krahets@163.com) +Created Time: 2022-11-29 +Author: Peng Chen (pengchzn@gmail.com) ''' -import sys, os.path as osp +import os.path as osp +import sys + sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__)))) from include import * +import queue + +if __name__ == "__main__": + """ 初始化队列 """ + queue = queue.Queue() + + """ 元素入队 """ + queue.put(1) + queue.put(3) + queue.put(2) + queue.put(5) + queue.put(4) + print("队列 queue = ", queue.queue) + + """ 访问队首元素 """ + peek = queue.queue[0] + print("队首元素 peek = ", peek) + + """ 元素出队 """ + get = queue.get() + print("出队元素 get = ", get) + print("出队后 queue = ", queue.queue) + + """ 获取队列的长度 """ + size = queue.qsize() + print("队列长度 size = ", size) + + """ 判断队列是否为空 """ + is_empty = queue.empty() + print("队列是否为空 = ", is_empty) From 6879f7dc219fe6be156927210a4f73ef1b0e5618 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=BD=AD=E7=90=9B?= <66410605+pengchzn@users.noreply.github.com> Date: Thu, 1 Dec 2022 06:50:25 +0800 Subject: [PATCH 33/67] Update array_stack.py An type error of ";" --- codes/python/chapter_stack_and_queue/array_stack.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/codes/python/chapter_stack_and_queue/array_stack.py b/codes/python/chapter_stack_and_queue/array_stack.py index b1640a068..23e4b4b5d 100644 --- a/codes/python/chapter_stack_and_queue/array_stack.py +++ b/codes/python/chapter_stack_and_queue/array_stack.py @@ -60,8 +60,8 @@ if __name__ == "__main__": print("栈顶元素 peek =", peek) """ 访问索引 index 处元素 """ - num = stack.get(3); - print("栈索引 3 处的元素为 num =", num); + num = stack.get(3) + print("栈索引 3 处的元素为 num =", num) """ 元素出栈 """ pop = stack.pop() @@ -74,4 +74,4 @@ if __name__ == "__main__": """ 判断是否为空 """ is_empty = stack.is_empty() - print("栈是否为空 =", is_empty) \ No newline at end of file + print("栈是否为空 =", is_empty) From 59e46ada826ec0588e59f386c0a13da2fa741d7f Mon Sep 17 00:00:00 2001 From: pengchzn Date: Thu, 1 Dec 2022 06:53:08 +0800 Subject: [PATCH 34/67] Add python code for queue --- .../chapter_stack_and_queue/array_queue.py | 53 ++++++++++++------- codes/python/chapter_stack_and_queue/deque.py | 8 +-- .../linkedlist_queue.py | 12 +++-- 3 files changed, 45 insertions(+), 28 deletions(-) diff --git a/codes/python/chapter_stack_and_queue/array_queue.py b/codes/python/chapter_stack_and_queue/array_queue.py index 0e173fea1..c4284d8f9 100644 --- a/codes/python/chapter_stack_and_queue/array_queue.py +++ b/codes/python/chapter_stack_and_queue/array_queue.py @@ -1,6 +1,6 @@ ''' File: array_queue.py -Created Time: 2022-11-29 +Created Time: 2022-12-01 Author: Peng Chen (pengchzn@gmail.com) ''' @@ -13,22 +13,22 @@ from include import * """ 基于环形数组实现的队列 """ class ArrayQueue: def __init__(self, size): - self.nums = [None] * size # 用于存储队列元素的数组 - self.front = 0 # 头指针，指向队首 - self.rear = 0 # 尾指针，指向队尾 + 1 + self.__nums = [None] * size # 用于存储队列元素的数组 + self.__front = 0 # 头指针，指向队首 + self.__rear = 0 # 尾指针，指向队尾 + 1 """ 获取队列的容量 """ def capacity(self): - return len(self.nums) + return len(self.__nums) """ 获取队列的长度 """ def size(self): # 由于将数组看作为环形，可能 rear < front ，因此需要取余数 - return (self.capacity() + self.rear - self.front) % self.capacity() + return (self.capacity() + self.__rear - self.__front) % self.capacity() """ 判断队列是否为空 """ def is_empty(self): - return len(self.nums)==0 + return (self.__rear - self.__front) == 0 """ 入队 """ def put(self, val): @@ -36,9 +36,9 @@ class ArrayQueue: print("队列已满") return False # 尾结点后添加 num - self.nums[self.rear] = val + self.__nums[self.__rear] = val # 尾指针向后移动一位，越过尾部后返回到数组头部 - self.rear = (self.rear + 1) % self.capacity() + self.__rear = (self.__rear + 1) % self.capacity() """ 出队 """ def get(self): @@ -46,28 +46,39 @@ class ArrayQueue: if self.is_empty(): print("队列为空") return False - num = self.nums[self.front] - self.nums[self.front] = None + num = self.__nums[self.__front] # 队头指针向后移动，越过尾部后返回到数组头部 - self.front = (self.front + 1) % self.capacity() + self.__front = (self.__front + 1) % self.capacity() return num """ 访问队首元素 """ def peek(self): # 删除头结点 if self.is_empty(): - return 1 - return self.nums[self.front] + print("队列为空") + return False + return self.__nums[self.__front] """ 访问指定位置元素 """ def get_index(self, index): if index >= self.size(): - return -1 - return self.nums[(self.front + index) % self.capacity()] + print("索引越界") + return False + return self.__nums[(self.__front + index) % self.capacity()] + + """ 返回列表用于打印 """ + def to_list(self): + res = [None] * self.size() + j = self.__front + for i in range(self.size()): + res[i] = self.__nums[(j % self.capacity())] + j += 1 + return res + if __name__ == "__main__": """ 初始化队列 """ - queue = ArrayQueue(5) + queue = ArrayQueue(10) """ 元素入队 """ queue.put(1) @@ -75,16 +86,20 @@ if __name__ == "__main__": queue.put(2) queue.put(5) queue.put(4) - print("队列 queue = ", queue.nums) + print("队列 queue = ", queue.to_list()) """ 访问队首元素 """ peek = queue.peek() print("队首元素 peek = ", peek) + """ 访问索引 index 处元素 """ + num = queue.get_index(3) + print("队列索引 3 处的元素为 num =", num) + """ 元素出队 """ get = queue.get() print("出队元素 get = ", get) - print("出队后 queue = ", queue.nums) + print("出队后 queue = ", queue.to_list()) """ 获取队列的长度 """ size = queue.size() diff --git a/codes/python/chapter_stack_and_queue/deque.py b/codes/python/chapter_stack_and_queue/deque.py index 0bddd0d8b..a2929dfd4 100644 --- a/codes/python/chapter_stack_and_queue/deque.py +++ b/codes/python/chapter_stack_and_queue/deque.py @@ -38,10 +38,10 @@ if __name__ == "__main__": print("队尾出队元素 popLast= ", popLast) print("队尾出队后 duque = ", duque) - """ 获取队列的长度 """ + """ 获取双向队列的长度 """ size = len(duque) - print("队列长度 size = ", size) + print("双向队列长度 size = ", size) - """ 判断队列是否为空 """ + """ 判断双向队列是否为空 """ is_empty = len(duque) == 0 - print("队列是否为空 = ", is_empty) + print("双向队列是否为空 = ", is_empty) diff --git a/codes/python/chapter_stack_and_queue/linkedlist_queue.py b/codes/python/chapter_stack_and_queue/linkedlist_queue.py index 53f3b9a82..d5a2202d4 100644 --- a/codes/python/chapter_stack_and_queue/linkedlist_queue.py +++ b/codes/python/chapter_stack_and_queue/linkedlist_queue.py @@ -1,6 +1,6 @@ ''' File: linkedlist_queue.py -Created Time: 2022-11-29 +Created Time: 2022-12-01 Author: Peng Chen (pengchzn@gmail.com) ''' @@ -50,10 +50,12 @@ class LinkedListQueue: """ 访问队首元素 """ def peek(self): if self.size() == 0: - return -1 + print("队列为空") + return False return self.__front.val - def to_array(self): + """ 转化为列表用于打印 """ + def to_list(self): queue = [] temp = self.__front while temp: @@ -72,7 +74,7 @@ if __name__ == "__main__": queue.put(2) queue.put(5) queue.put(4) - print("队列 queue = ", queue.to_array()) + print("队列 queue = ", queue.to_list()) """ 访问队首元素 """ peek = queue.peek() @@ -81,7 +83,7 @@ if __name__ == "__main__": """ 元素出队 """ get = queue.get() print("出队元素 get = ", get) - print("出队后 queue = ", queue.to_array()) + print("出队后 queue = ", queue.to_list()) """ 获取队列的长度 """ size = queue.size() From 84825a22d9b64a2e02dffbb0dcdc3535b1072606 Mon Sep 17 00:00:00 2001 From: mgisr Date: Thu, 1 Dec 2022 09:09:34 +0800 Subject: [PATCH 35/67] fix(codes/cpp/include/TreeNode.hpp): Fix 'vecToTree' function --- codes/cpp/include/TreeNode.hpp | 31 +++++++++++++++++-------------- 1 file changed, 17 insertions(+), 14 deletions(-) diff --git a/codes/cpp/include/TreeNode.hpp b/codes/cpp/include/TreeNode.hpp index 614d7992b..7be2b8d20 100644 --- a/codes/cpp/include/TreeNode.hpp +++ b/codes/cpp/include/TreeNode.hpp @@ -23,25 +23,28 @@ struct TreeNode { * @param list * @return TreeNode* */ -TreeNode* vecToTree(vector list) { - TreeNode *root = new TreeNode(list[0]); - queue que; - que.emplace(root); - int i = 1; - while(!que.empty()) { - TreeNode *node = que.front(); +TreeNode *vecToTree(vector list) { + if (list.empty()) { + return nullptr; + } + + auto *root = new TreeNode(list[0]); + queue que; + size_t n = list.size(), index = 1; + while (index < n) { + auto node = que.front(); que.pop(); - if(list[i] != INT_MAX) { - node->left = new TreeNode(list[i]); + + if (index < n) { + node->left = new TreeNode(list[index++]); que.emplace(node->left); } - i++; - if(list[i] != INT_MAX) { - node->right = new TreeNode(list[i]); + if (index < n) { + node->right = new TreeNode(list[index++]); que.emplace(node->right); } - i++; } + return root; } @@ -52,7 +55,7 @@ TreeNode* vecToTree(vector list) { * @param val * @return TreeNode* */ -TreeNode* getTreeNode(TreeNode *root, int val) { +TreeNode *getTreeNode(TreeNode *root, int val) { if (root == nullptr) return nullptr; if (root->val == val) From 7eea137c28a767dd6deb96af163d29ee883950de Mon Sep 17 00:00:00 2001 From: IsChristina <315644507@qq.com> Date: Thu, 1 Dec 2022 18:28:57 +0800 Subject: [PATCH 36/67] add sort for javascript codes --- .../javascript/chapter_sorting/bubble_sort.js | 49 ++++++ .../chapter_sorting/insertion_sort.js | 24 +++ .../javascript/chapter_sorting/merge_sort.js | 51 ++++++ .../javascript/chapter_sorting/quick_sort.js | 157 ++++++++++++++++++ docs/chapter_sorting/bubble_sort.md | 44 +++++ docs/chapter_sorting/insertion_sort.md | 18 ++ docs/chapter_sorting/merge_sort.md | 45 +++++ docs/chapter_sorting/quick_sort.md | 91 ++++++++++ 8 files changed, 479 insertions(+) create mode 100644 codes/javascript/chapter_sorting/bubble_sort.js create mode 100644 codes/javascript/chapter_sorting/insertion_sort.js create mode 100644 codes/javascript/chapter_sorting/merge_sort.js create mode 100644 codes/javascript/chapter_sorting/quick_sort.js diff --git a/codes/javascript/chapter_sorting/bubble_sort.js b/codes/javascript/chapter_sorting/bubble_sort.js new file mode 100644 index 000000000..270565c13 --- /dev/null +++ b/codes/javascript/chapter_sorting/bubble_sort.js @@ -0,0 +1,49 @@ +/** + * File: quick_sort.js + * Created Time: 2022-12-01 + * Author: IsChristina (christinaxia77@foxmail.com) + */ + +/* 冒泡排序 */ +function bubbleSort(nums) { + // 外循环：待排序元素数量为 n-1, n-2, ..., 1 + for (let i = nums.length - 1; i > 0; i--) { + // 内循环：冒泡操作 + for (let j = 0; j < i; j++) { + if (nums[j] > nums[j + 1]) { + // 交换 nums[j] 与 nums[j + 1] + let tmp = nums[j]; + nums[j] = nums[j + 1]; + nums[j + 1] = tmp; + } + } + } +} + +/* 冒泡排序（标志优化）*/ +function bubbleSortWithFlag(nums) { + // 外循环：待排序元素数量为 n-1, n-2, ..., 1 + for (let i = nums.length - 1; i > 0; i--) { + let flag = false; // 初始化标志位 + // 内循环：冒泡操作 + for (let j = 0; j < i; j++) { + if (nums[j] > nums[j + 1]) { + // 交换 nums[j] 与 nums[j + 1] + let tmp = nums[j]; + nums[j] = nums[j + 1]; + nums[j + 1] = tmp; + flag = true; // 记录交换元素 + } + } + if (!flag) break; // 此轮冒泡未交换任何元素，直接跳出 + } +} + +/* Driver Code */ +var nums = [4, 1, 3, 1, 5, 2] +bubbleSort(nums) +console.log("排序后数组 nums =", nums) + +var nums1 = [4, 1, 3, 1, 5, 2] +bubbleSortWithFlag(nums1) +console.log("排序后数组 nums =", nums1) \ No newline at end of file diff --git a/codes/javascript/chapter_sorting/insertion_sort.js b/codes/javascript/chapter_sorting/insertion_sort.js new file mode 100644 index 000000000..2ba715597 --- /dev/null +++ b/codes/javascript/chapter_sorting/insertion_sort.js @@ -0,0 +1,24 @@ +/** + * File: quick_sort.js + * Created Time: 2022-12-01 + * Author: IsChristina (christinaxia77@foxmail.com) + */ + +/* 插入排序 */ +function insertionSort(nums) { + // 外循环：base = nums[1], nums[2], ..., nums[n-1] + for (let i = 1; i < nums.length; i++) { + let base = nums[i], j = i - 1; + // 内循环：将 base 插入到左边的正确位置 + while (j >= 0 && nums[j] > base) { + nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位 + j--; + } + nums[j + 1] = base; // 2. 将 base 赋值到正确位置 + } +} + +/* Driver Code */ +var nums = [4, 1, 3, 1, 5, 2] +insertionSort(nums) +console.log("排序后数组 nums = ", nums) \ No newline at end of file diff --git a/codes/javascript/chapter_sorting/merge_sort.js b/codes/javascript/chapter_sorting/merge_sort.js new file mode 100644 index 000000000..635cc1d36 --- /dev/null +++ b/codes/javascript/chapter_sorting/merge_sort.js @@ -0,0 +1,51 @@ +/** + * File: quick_sort.js + * Created Time: 2022-12-01 + * Author: IsChristina (christinaxia77@foxmail.com) + */ + +/** +* 合并左子数组和右子数组 +* 左子数组区间 [left, mid] +* 右子数组区间 [mid + 1, right] +*/ +function merge(nums, left, mid, right) { + // 初始化辅助数组 + let tmp = nums.slice(left, right + 1); + // 左子数组的起始索引和结束索引 + let leftStart = left - left, leftEnd = mid - left; + // 右子数组的起始索引和结束索引 + let rightStart = mid + 1 - left, rightEnd = right - left; + // i, j 分别指向左子数组、右子数组的首元素 + let i = leftStart, j = rightStart; + // 通过覆盖原数组 nums 来合并左子数组和右子数组 + for (let k = left; k <= right; k++) { + // 若 “左子数组已全部合并完”，则选取右子数组元素，并且 j++ + if (i > leftEnd) { + nums[k] = tmp[j++]; + // 否则，若 “右子数组已全部合并完” 或 “左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++ + } else if (j > rightEnd || tmp[i] <= tmp[j]) { + nums[k] = tmp[i++]; + // 否则，若 “左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++ + } else { + nums[k] = tmp[j++]; + } + } +} + +/* 归并排序 */ +function mergeSort(nums, left, right) { + // 终止条件 + if (left >= right) return; // 当子数组长度为 1 时终止递归 + // 划分阶段 + let mid = Math.floor((left + right) / 2); // 计算中点 + mergeSort(nums, left, mid); // 递归左子数组 + mergeSort(nums, mid + 1, right); // 递归右子数组 + // 合并阶段 + merge(nums, left, mid, right); +} + +/* Driver Code */ +var nums = [ 7, 3, 2, 6, 0, 1, 5, 4 ] +mergeSort(nums, 0, nums.length - 1) +console.log("归并排序完成后 nums =", nums) \ No newline at end of file diff --git a/codes/javascript/chapter_sorting/quick_sort.js b/codes/javascript/chapter_sorting/quick_sort.js new file mode 100644 index 000000000..bad6fa7f3 --- /dev/null +++ b/codes/javascript/chapter_sorting/quick_sort.js @@ -0,0 +1,157 @@ +/** + * File: quick_sort.js + * Created Time: 2022-12-01 + * Author: IsChristina (christinaxia77@foxmail.com) + */ + +/* 快速排序类 */ +class QuickSort { + /* 元素交换 */ + swap(nums, i, j) { + let tmp = nums[i] + nums[i] = nums[j] + nums[j] = tmp + } + + /* 哨兵划分 */ + partition(nums, left, right){ + // 以 nums[left] 作为基准数 + let i = left, j = right + while(i < j){ + while(i < j && nums[j] >= nums[left]){ + j -= 1 // 从右向左找首个小于基准数的元素 + } + while(i < j && nums[i] <= nums[left]){ + i += 1 // 从左向右找首个大于基准数的元素 + } + // 元素交换 + this.swap(nums, i, j) // 交换这两个元素 + } + this.swap(nums, i, left) // 将基准数交换至两子数组的分界线 + return i // 返回基准数的索引 + } + + /* 快速排序 */ + quickSort(nums, left, right){ + // 子数组长度为 1 时终止递归 + if(left >= right) return + // 哨兵划分 + const pivot = this.partition(nums, left, right) + // 递归左子数组、右子数组 + this.quickSort(nums, left, pivot - 1) + this.quickSort(nums, pivot + 1, right) + } +} + +/* 快速排序类（中位基准数优化） */ +class QuickSortMedian { + /* 元素交换 */ + swap(nums, i, j) { + let tmp = nums[i] + nums[i] = nums[j] + nums[j] = tmp + } + + /* 选取三个元素的中位数 */ + medianThree(nums, left, mid, right) { + // 使用了异或操作来简化代码 + // 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1 + if ((nums[left] > nums[mid]) ^ (nums[left] > nums[right])) + return left; + else if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right])) + return mid; + else + return right; + } + + /* 哨兵划分（三数取中值） */ + partition(nums, left, right) { + // 选取三个候选元素的中位数 + let med = this.medianThree(nums, left, Math.floor((left + right) / 2), right); + // 将中位数交换至数组最左端 + this.swap(nums, left, med); + // 以 nums[left] 作为基准数 + let i = left, j = right; + while (i < j) { + while (i < j && nums[j] >= nums[left]) + j--; // 从右向左找首个小于基准数的元素 + while (i < j && nums[i] <= nums[left]) + i++; // 从左向右找首个大于基准数的元素 + this.swap(nums, i, j); // 交换这两个元素 + } + this.swap(nums, i, left); // 将基准数交换至两子数组的分界线 + return i; // 返回基准数的索引 + } + + /* 快速排序 */ + quickSort(nums, left, right) { + // 子数组长度为 1 时终止递归 + if (left >= right) return; + // 哨兵划分 + const pivot = this.partition(nums, left, right); + // 递归左子数组、右子数组 + this.quickSort(nums, left, pivot - 1); + this.quickSort(nums, pivot + 1, right); + } +} + +/* 快速排序类（尾递归优化） */ +class QuickSortTailCall { + /* 元素交换 */ + swap(nums, i, j) { + let tmp = nums[i] + nums[i] = nums[j] + nums[j] = tmp + } + + /* 哨兵划分 */ + partition(nums, left, right) { + // 以 nums[left] 作为基准数 + let i = left, j = right; + while (i < j) { + while (i < j && nums[j] >= nums[left]) + j--; // 从右向左找首个小于基准数的元素 + while (i < j && nums[i] <= nums[left]) + i++; // 从左向右找首个大于基准数的元素 + this.swap(nums, i, j); // 交换这两个元素 + } + this.swap(nums, i, left); // 将基准数交换至两子数组的分界线 + return i; // 返回基准数的索引 + } + + /* 快速排序（尾递归优化） */ + quickSort(nums, left, right) { + // 子数组长度为 1 时终止 + while (left < right) { + // 哨兵划分操作 + let pivot = this.partition(nums, left, right); + // 对两个子数组中较短的那个执行快排 + if (pivot - left < right - pivot) { + this.quickSort(nums, left, pivot - 1); // 递归排序左子数组 + left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right] + } else { + this.quickSort(nums, pivot + 1, right); // 递归排序右子数组 + right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1] + } + } + } +} + +/* Driver Code */ +/* 快速排序 */ +var nums = [4, 1, 3, 1, 5, 2] +var quickSort = new QuickSort() +quickSort.quickSort(nums, 0, nums.length - 1) +console.log("快速排序完成后 nums =", nums) + +/* 快速排序（中位基准数优化） */ +nums1 = [4, 1, 3, 1, 5,2] +var quickSortMedian = new QuickSort() +quickSortMedian.quickSort(nums1, 0, nums1.length - 1) +console.log("快速排序（中位基准数优化）完成后 nums =", nums1) + +/* 快速排序（尾递归优化） */ +nums2 = [4, 1, 3, 1, 5, 2] +var quickSortTailCall = new QuickSort() +quickSortTailCall.quickSort(nums2, 0, nums2.length - 1) +console.log("快速排序（尾递归优化）完成后 nums =", nums2) \ No newline at end of file diff --git a/docs/chapter_sorting/bubble_sort.md b/docs/chapter_sorting/bubble_sort.md index 3f35ea11f..fe1d07140 100644 --- a/docs/chapter_sorting/bubble_sort.md +++ b/docs/chapter_sorting/bubble_sort.md @@ -73,6 +73,27 @@ comments: true } } ``` + +=== "JavaScript" + + ```js title="bubble_sort.js" + /* 冒泡排序 */ + function bubbleSort(nums) { + // 外循环：待排序元素数量为 n-1, n-2, ..., 1 + for (let i = nums.length - 1; i > 0; i--) { + // 内循环：冒泡操作 + for (let j = 0; j < i; j++) { + if (nums[j] > nums[j + 1]) { + // 交换 nums[j] 与 nums[j + 1] + let tmp = nums[j]; + nums[j] = nums[j + 1]; + nums[j + 1] = tmp; + } + } + } + } + ``` + === "C++" ```cpp title="bubble_sort.cpp" @@ -149,6 +170,29 @@ comments: true } ``` +=== "JavaScript" + + ```js title="bubble_sort.js" + /* 冒泡排序（标志优化）*/ + function bubbleSortWithFlag(nums) { + // 外循环：待排序元素数量为 n-1, n-2, ..., 1 + for (let i = nums.length - 1; i > 0; i--) { + let flag = false; // 初始化标志位 + // 内循环：冒泡操作 + for (let j = 0; j < i; j++) { + if (nums[j] > nums[j + 1]) { + // 交换 nums[j] 与 nums[j + 1] + let tmp = nums[j]; + nums[j] = nums[j + 1]; + nums[j + 1] = tmp; + flag = true; // 记录交换元素 + } + } + if (!flag) break; // 此轮冒泡未交换任何元素，直接跳出 + } + } + ``` + === "C++" ```cpp title="bubble_sort.cpp" diff --git a/docs/chapter_sorting/insertion_sort.md b/docs/chapter_sorting/insertion_sort.md index c9563fc0e..e220c2e0e 100644 --- a/docs/chapter_sorting/insertion_sort.md +++ b/docs/chapter_sorting/insertion_sort.md @@ -42,6 +42,24 @@ comments: true } ``` +=== "JavaScript" + + ```js title="insertion_sort.js" + /* 插入排序 */ + function insertionSort(nums) { + // 外循环：base = nums[1], nums[2], ..., nums[n-1] + for (let i = 1; i < nums.length; i++) { + let base = nums[i], j = i - 1; + // 内循环：将 base 插入到左边的正确位置 + while (j >= 0 && nums[j] > base) { + nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位 + j--; + } + nums[j + 1] = base; // 2. 将 base 赋值到正确位置 + } + } + ``` + === "C++" ```cpp title="insertion_sort.cpp" diff --git a/docs/chapter_sorting/merge_sort.md b/docs/chapter_sorting/merge_sort.md index 00df17722..58a48c25c 100644 --- a/docs/chapter_sorting/merge_sort.md +++ b/docs/chapter_sorting/merge_sort.md @@ -103,6 +103,51 @@ comments: true } ``` +=== "JavaScript" + + ```js title="merge_sort.js" + /** + * 合并左子数组和右子数组 + * 左子数组区间 [left, mid] + * 右子数组区间 [mid + 1, right] + */ + function merge(nums, left, mid, right) { + // 初始化辅助数组 + let tmp = nums.slice(left, right + 1); + // 左子数组的起始索引和结束索引 + let leftStart = left - left, leftEnd = mid - left; + // 右子数组的起始索引和结束索引 + let rightStart = mid + 1 - left, rightEnd = right - left; + // i, j 分别指向左子数组、右子数组的首元素 + let i = leftStart, j = rightStart; + // 通过覆盖原数组 nums 来合并左子数组和右子数组 + for (let k = left; k <= right; k++) { + // 若 “左子数组已全部合并完”，则选取右子数组元素，并且 j++ + if (i > leftEnd) { + nums[k] = tmp[j++]; + // 否则，若 “右子数组已全部合并完” 或 “左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++ + } else if (j > rightEnd || tmp[i] <= tmp[j]) { + nums[k] = tmp[i++]; + // 否则，若 “左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++ + } else { + nums[k] = tmp[j++]; + } + } + } + + /* 归并排序 */ + function mergeSort(nums, left, right) { + // 终止条件 + if (left >= right) return; // 当子数组长度为 1 时终止递归 + // 划分阶段 + let mid = Math.floor((left + right) / 2); // 计算中点 + mergeSort(nums, left, mid); // 递归左子数组 + mergeSort(nums, mid + 1, right); // 递归右子数组 + // 合并阶段 + merge(nums, left, mid, right); + } + ``` + === "C++" ```cpp title="merge_sort.cpp" diff --git a/docs/chapter_sorting/quick_sort.md b/docs/chapter_sorting/quick_sort.md index c9488f1d1..f931e068f 100644 --- a/docs/chapter_sorting/quick_sort.md +++ b/docs/chapter_sorting/quick_sort.md @@ -61,6 +61,35 @@ comments: true } ``` +=== "JavaScript" + + ``` js title="quick_sort.js" + /* 元素交换 */ + function swap(nums, i, j) { + let tmp = nums[i] + nums[i] = nums[j] + nums[j] = tmp + } + + /* 哨兵划分 */ + function partition(nums, left, right){ + // 以 nums[left] 作为基准数 + let i = left, j = right + while(i < j){ + while(i < j && nums[j] >= nums[left]){ + j -= 1 // 从右向左找首个小于基准数的元素 + } + while(i < j && nums[i] <= nums[left]){ + i += 1 // 从左向右找首个大于基准数的元素 + } + // 元素交换 + swap(nums, i, j) // 交换这两个元素 + } + swap(nums, i, left) // 将基准数交换至两子数组的分界线 + return i // 返回基准数的索引 + } + ``` + === "C++" ```cpp title="quick_sort.cpp" @@ -138,6 +167,21 @@ comments: true } ``` +=== "JavaScript" + + ```js title="quick_sort.js" + /* 快速排序 */ + function quickSort(nums, left, right){ + // 子数组长度为 1 时终止递归 + if(left >= right) return + // 哨兵划分 + const pivot = partition(nums, left, right) + // 递归左子数组、右子数组 + quick_sort(nums, left, pivot - 1) + quick_sort(nums, pivot + 1, right) + } + ``` + === "C++" ```cpp title="quick_sort.cpp" @@ -225,6 +269,32 @@ comments: true } ``` +=== "JavaScript" + + ```js title="quick_sort.js" + /* 选取三个元素的中位数 */ + function medianThree(nums, left, mid, right) { + // 使用了异或操作来简化代码 + // 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1 + if ((nums[left] > nums[mid]) ^ (nums[left] > nums[right])) + return left; + else if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right])) + return mid; + else + return right; + } + + /* 哨兵划分（三数取中值） */ + function partition(nums, left, right) { + // 选取三个候选元素的中位数 + let med = medianThree(nums, left, Math.floor((left + right) / 2), right); + // 将中位数交换至数组最左端 + swap(nums, left, med); + // 以 nums[left] 作为基准数 + // 下同省略... + } + ``` + === "C++" ```cpp title="quick_sort.cpp" @@ -301,6 +371,27 @@ comments: true } ``` +=== "JavaScript" + + ```js title="quick_sort.js" + /* 快速排序（尾递归优化） */ + quickSort(nums, left, right) { + // 子数组长度为 1 时终止 + while (left < right) { + // 哨兵划分操作 + let pivot = partition(nums, left, right); + // 对两个子数组中较短的那个执行快排 + if (pivot - left < right - pivot) { + quickSort(nums, left, pivot - 1); // 递归排序左子数组 + left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right] + } else { + quickSort(nums, pivot + 1, right); // 递归排序右子数组 + right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1] + } + } + } + ``` + === "C++" ```cpp title="quick_sort.cpp" From be8a586768ed246bd0278481a6d16ba80d5ec6d4 Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Thu, 1 Dec 2022 22:38:01 +0800 Subject: [PATCH 37/67] Update quick_sort.js Fix indentation --- .../javascript/chapter_sorting/quick_sort.js | 38 +++++++++---------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/codes/javascript/chapter_sorting/quick_sort.js b/codes/javascript/chapter_sorting/quick_sort.js index bad6fa7f3..405bf7621 100644 --- a/codes/javascript/chapter_sorting/quick_sort.js +++ b/codes/javascript/chapter_sorting/quick_sort.js @@ -17,29 +17,29 @@ class QuickSort { partition(nums, left, right){ // 以 nums[left] 作为基准数 let i = left, j = right - while(i < j){ - while(i < j && nums[j] >= nums[left]){ - j -= 1 // 从右向左找首个小于基准数的元素 - } - while(i < j && nums[i] <= nums[left]){ - i += 1 // 从左向右找首个大于基准数的元素 - } - // 元素交换 - this.swap(nums, i, j) // 交换这两个元素 + while(i < j){ + while(i < j && nums[j] >= nums[left]){ + j -= 1 // 从右向左找首个小于基准数的元素 } - this.swap(nums, i, left) // 将基准数交换至两子数组的分界线 - return i // 返回基准数的索引 + while(i < j && nums[i] <= nums[left]){ + i += 1 // 从左向右找首个大于基准数的元素 + } + // 元素交换 + this.swap(nums, i, j) // 交换这两个元素 + } + this.swap(nums, i, left) // 将基准数交换至两子数组的分界线 + return i // 返回基准数的索引 } /* 快速排序 */ quickSort(nums, left, right){ - // 子数组长度为 1 时终止递归 - if(left >= right) return - // 哨兵划分 - const pivot = this.partition(nums, left, right) - // 递归左子数组、右子数组 - this.quickSort(nums, left, pivot - 1) - this.quickSort(nums, pivot + 1, right) + // 子数组长度为 1 时终止递归 + if(left >= right) return + // 哨兵划分 + const pivot = this.partition(nums, left, right) + // 递归左子数组、右子数组 + this.quickSort(nums, left, pivot - 1) + this.quickSort(nums, pivot + 1, right) } } @@ -154,4 +154,4 @@ console.log("快速排序（中位基准数优化）完成后 nums =", nums1) nums2 = [4, 1, 3, 1, 5, 2] var quickSortTailCall = new QuickSort() quickSortTailCall.quickSort(nums2, 0, nums2.length - 1) -console.log("快速排序（尾递归优化）完成后 nums =", nums2) \ No newline at end of file +console.log("快速排序（尾递归优化）完成后 nums =", nums2) From 1728be1e61289f88ad186d72e05c89019e558d3b Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Thu, 1 Dec 2022 22:39:31 +0800 Subject: [PATCH 38/67] Update quick_sort.md Fix indentation --- docs/chapter_sorting/quick_sort.md | 36 +++++++++++++++--------------- 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/docs/chapter_sorting/quick_sort.md b/docs/chapter_sorting/quick_sort.md index f931e068f..a0df18e7b 100644 --- a/docs/chapter_sorting/quick_sort.md +++ b/docs/chapter_sorting/quick_sort.md @@ -75,18 +75,18 @@ comments: true function partition(nums, left, right){ // 以 nums[left] 作为基准数 let i = left, j = right - while(i < j){ - while(i < j && nums[j] >= nums[left]){ - j -= 1 // 从右向左找首个小于基准数的元素 - } - while(i < j && nums[i] <= nums[left]){ - i += 1 // 从左向右找首个大于基准数的元素 - } - // 元素交换 - swap(nums, i, j) // 交换这两个元素 + while(i < j){ + while(i < j && nums[j] >= nums[left]){ + j -= 1 // 从右向左找首个小于基准数的元素 } - swap(nums, i, left) // 将基准数交换至两子数组的分界线 - return i // 返回基准数的索引 + while(i < j && nums[i] <= nums[left]){ + i += 1 // 从左向右找首个大于基准数的元素 + } + // 元素交换 + swap(nums, i, j) // 交换这两个元素 + } + swap(nums, i, left) // 将基准数交换至两子数组的分界线 + return i // 返回基准数的索引 } ``` @@ -172,13 +172,13 @@ comments: true ```js title="quick_sort.js" /* 快速排序 */ function quickSort(nums, left, right){ - // 子数组长度为 1 时终止递归 - if(left >= right) return - // 哨兵划分 - const pivot = partition(nums, left, right) - // 递归左子数组、右子数组 - quick_sort(nums, left, pivot - 1) - quick_sort(nums, pivot + 1, right) + // 子数组长度为 1 时终止递归 + if(left >= right) return + // 哨兵划分 + const pivot = partition(nums, left, right) + // 递归左子数组、右子数组 + quick_sort(nums, left, pivot - 1) + quick_sort(nums, pivot + 1, right) } ``` From bd0054ecf28dd7accd754ad03fd8a17538b8e452 Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Thu, 1 Dec 2022 23:01:45 +0800 Subject: [PATCH 39/67] Update preface. --- docs/chapter_preface/index.md | 2 -- 1 file changed, 2 deletions(-) diff --git a/docs/chapter_preface/index.md b/docs/chapter_preface/index.md index 3527b3f26..0defc4a99 100644 --- a/docs/chapter_preface/index.md +++ b/docs/chapter_preface/index.md @@ -111,8 +111,6 @@ comments: true ## 致谢 -感谢本开源书的每一位撰稿人，是他们的无私奉献让这本书变得更好，他们的 GitHub ID（按首次提交时间排序）为：krahets, Reanon. - 本书的成书过程中，我获得了许多人的帮助，包括但不限于： - 感谢我的女朋友泡泡担任本书的首位读者，从算法小白的视角为本书的写作提出了许多建议，使这本书更加适合算法初学者来阅读。 From e20bc251f58f26e95dc366b9dde98081639642d6 Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Fri, 2 Dec 2022 00:09:34 +0800 Subject: [PATCH 40/67] Add python code of chapter queue to docs. --- .../chapter_array_and_linkedlist/my_list.cpp | 5 +- .../chapter_stack_and_queue/array_queue.cpp | 7 +- .../go/chapter_stack_and_queue/array_queue.go | 2 +- .../chapter_array_and_linkedlist/my_list.java | 13 +- .../chapter_stack_and_queue/array_queue.java | 7 +- .../javascript/chapter_sorting/bubble_sort.js | 2 +- .../chapter_sorting/insertion_sort.js | 2 +- .../javascript/chapter_sorting/merge_sort.js | 2 +- .../chapter_array_and_linkedlist/my_list.py | 3 +- .../chapter_stack_and_queue/array_queue.py | 48 +++--- codes/python/chapter_stack_and_queue/deque.py | 30 ++-- .../linkedlist_queue.py | 33 ++-- codes/python/chapter_stack_and_queue/queue.py | 40 ++--- codes/python/include/__init__.py | 1 + codes/python/include/print_util.py | 3 +- docs/chapter_array_and_linkedlist/list.md | 29 ++-- docs/chapter_stack_and_queue/deque.md | 24 ++- docs/chapter_stack_and_queue/queue.md | 159 +++++++++++++++--- 18 files changed, 276 insertions(+), 134 deletions(-) diff --git a/codes/cpp/chapter_array_and_linkedlist/my_list.cpp b/codes/cpp/chapter_array_and_linkedlist/my_list.cpp index 48d0cdb96..f64bd27c8 100644 --- a/codes/cpp/chapter_array_and_linkedlist/my_list.cpp +++ b/codes/cpp/chapter_array_and_linkedlist/my_list.cpp @@ -72,15 +72,18 @@ public: } /* 删除元素 */ - void remove(int index) { + int remove(int index) { if (index >= size()) throw out_of_range("索引越界"); + int num = nums[index]; // 索引 i 之后的元素都向前移动一位 for (int j = index; j < size() - 1; j++) { nums[j] = nums[j + 1]; } // 更新元素数量 numsSize--; + // 返回被删除元素 + return num; } /* 列表扩容 */ diff --git a/codes/cpp/chapter_stack_and_queue/array_queue.cpp b/codes/cpp/chapter_stack_and_queue/array_queue.cpp index e98caa2e0..8bc6a939f 100644 --- a/codes/cpp/chapter_stack_and_queue/array_queue.cpp +++ b/codes/cpp/chapter_stack_and_queue/array_queue.cpp @@ -51,11 +51,8 @@ public: /* 出队 */ int poll() { - // 删除头结点 - if (empty()) - throw out_of_range("队列为空"); - int num = nums[front]; - // 队头指针向后移动，越过尾部后返回到数组头部 + int num = peek(); + // 队头指针向后移动一位，若越过尾部则返回到数组头部 front = (front + 1) % capacity(); return num; } diff --git a/codes/go/chapter_stack_and_queue/array_queue.go b/codes/go/chapter_stack_and_queue/array_queue.go index f771ea214..fd41f8bae 100644 --- a/codes/go/chapter_stack_and_queue/array_queue.go +++ b/codes/go/chapter_stack_and_queue/array_queue.go @@ -56,7 +56,7 @@ func (q *ArrayQueue) Poll() any { return nil } v := q.data[q.head] - // 队头指针向后移动，越过尾部后返回到数组头部 + // 队头指针向后移动一位，若越过尾部则返回到数组头部 q.head = (q.head + 1) % q.capacity return v } diff --git a/codes/java/chapter_array_and_linkedlist/my_list.java b/codes/java/chapter_array_and_linkedlist/my_list.java index 74153b021..1f9fdc3eb 100644 --- a/codes/java/chapter_array_and_linkedlist/my_list.java +++ b/codes/java/chapter_array_and_linkedlist/my_list.java @@ -56,13 +56,13 @@ class MyList { } /* 中间插入元素 */ - public void add(int index, int num) { + public void insert(int index, int num) { if (index >= size) throw new IndexOutOfBoundsException("索引越界"); // 元素数量超出容量时，触发扩容机制 if (size == capacity()) extendCapacity(); - // 索引 i 以及之后的元素都向后移动一位 + // 将索引 index 以及之后的元素都向后移动一位 for (int j = size - 1; j >= index; j--) { nums[j + 1] = nums[j]; } @@ -72,15 +72,18 @@ class MyList { } /* 删除元素 */ - public void remove(int index) { + public int remove(int index) { if (index >= size) throw new IndexOutOfBoundsException("索引越界"); - // 索引 i 之后的元素都向前移动一位 + int num = nums[index]; + // 将索引 index 之后的元素都向前移动一位 for (int j = index; j < size - 1; j++) { nums[j] = nums[j + 1]; } // 更新元素数量 size--; + // 返回被删除元素 + return num; } /* 列表扩容 */ @@ -118,7 +121,7 @@ public class my_list { " ，容量 = " + list.capacity() + " ，长度 = " + list.size()); /* 中间插入元素 */ - list.add(3, 6); + list.insert(3, 6); System.out.println("在索引 3 处插入数字 6 ，得到 list = " + Arrays.toString(list.toArray())); /* 删除元素 */ diff --git a/codes/java/chapter_stack_and_queue/array_queue.java b/codes/java/chapter_stack_and_queue/array_queue.java index ff22559ea..620ce2db1 100644 --- a/codes/java/chapter_stack_and_queue/array_queue.java +++ b/codes/java/chapter_stack_and_queue/array_queue.java @@ -50,11 +50,8 @@ class ArrayQueue { /* 出队 */ public int poll() { - // 删除头结点 - if (isEmpty()) - throw new EmptyStackException(); - int num = nums[front]; - // 队头指针向后移动，越过尾部后返回到数组头部 + int num = peek(); + // 队头指针向后移动一位，若越过尾部则返回到数组头部 front = (front + 1) % capacity(); return num; } diff --git a/codes/javascript/chapter_sorting/bubble_sort.js b/codes/javascript/chapter_sorting/bubble_sort.js index 270565c13..3d3c6a83b 100644 --- a/codes/javascript/chapter_sorting/bubble_sort.js +++ b/codes/javascript/chapter_sorting/bubble_sort.js @@ -46,4 +46,4 @@ console.log("排序后数组 nums =", nums) var nums1 = [4, 1, 3, 1, 5, 2] bubbleSortWithFlag(nums1) -console.log("排序后数组 nums =", nums1) \ No newline at end of file +console.log("排序后数组 nums =", nums1) diff --git a/codes/javascript/chapter_sorting/insertion_sort.js b/codes/javascript/chapter_sorting/insertion_sort.js index 2ba715597..9a6f119ba 100644 --- a/codes/javascript/chapter_sorting/insertion_sort.js +++ b/codes/javascript/chapter_sorting/insertion_sort.js @@ -21,4 +21,4 @@ function insertionSort(nums) { /* Driver Code */ var nums = [4, 1, 3, 1, 5, 2] insertionSort(nums) -console.log("排序后数组 nums = ", nums) \ No newline at end of file +console.log("排序后数组 nums = ", nums) diff --git a/codes/javascript/chapter_sorting/merge_sort.js b/codes/javascript/chapter_sorting/merge_sort.js index 635cc1d36..d57e41a8e 100644 --- a/codes/javascript/chapter_sorting/merge_sort.js +++ b/codes/javascript/chapter_sorting/merge_sort.js @@ -48,4 +48,4 @@ function mergeSort(nums, left, right) { /* Driver Code */ var nums = [ 7, 3, 2, 6, 0, 1, 5, 4 ] mergeSort(nums, 0, nums.length - 1) -console.log("归并排序完成后 nums =", nums) \ No newline at end of file +console.log("归并排序完成后 nums =", nums) diff --git a/codes/python/chapter_array_and_linkedlist/my_list.py b/codes/python/chapter_array_and_linkedlist/my_list.py index 5d8997b7b..077fc0ce5 100644 --- a/codes/python/chapter_array_and_linkedlist/my_list.py +++ b/codes/python/chapter_array_and_linkedlist/my_list.py @@ -36,9 +36,10 @@ class MyList: assert index < self.__size, "索引越界" self.__nums[index] = num - """ 中间插入元素 """ + """ 中间插入（尾部添加）元素 """ def add(self, num, index=-1): assert index < self.__size, "索引越界" + # 若不指定索引 index ，则向数组尾部添加元素 if index == -1: index = self.__size # 元素数量超出容量时，触发扩容机制 diff --git a/codes/python/chapter_stack_and_queue/array_queue.py b/codes/python/chapter_stack_and_queue/array_queue.py index c4284d8f9..b848794be 100644 --- a/codes/python/chapter_stack_and_queue/array_queue.py +++ b/codes/python/chapter_stack_and_queue/array_queue.py @@ -13,9 +13,9 @@ from include import * """ 基于环形数组实现的队列 """ class ArrayQueue: def __init__(self, size): - self.__nums = [None] * size # 用于存储队列元素的数组 - self.__front = 0 # 头指针，指向队首 - self.__rear = 0 # 尾指针，指向队尾 + 1 + self.__nums = [0] * size # 用于存储队列元素的数组 + self.__front = 0 # 头指针，指向队首 + self.__rear = 0 # 尾指针，指向队尾 + 1 """ 获取队列的容量 """ def capacity(self): @@ -31,7 +31,7 @@ class ArrayQueue: return (self.__rear - self.__front) == 0 """ 入队 """ - def put(self, val): + def push(self, val): if self.size() == self.capacity(): print("队列已满") return False @@ -41,13 +41,10 @@ class ArrayQueue: self.__rear = (self.__rear + 1) % self.capacity() """ 出队 """ - def get(self): + def poll(self): # 删除头结点 - if self.is_empty(): - print("队列为空") - return False - num = self.__nums[self.__front] - # 队头指针向后移动，越过尾部后返回到数组头部 + num = self.peek() + # 队头指针向后移动一位，若越过尾部则返回到数组头部 self.__front = (self.__front + 1) % self.capacity() return num @@ -60,7 +57,7 @@ class ArrayQueue: return self.__nums[self.__front] """ 访问指定位置元素 """ - def get_index(self, index): + def get(self, index): if index >= self.size(): print("索引越界") return False @@ -68,7 +65,7 @@ class ArrayQueue: """ 返回列表用于打印 """ def to_list(self): - res = [None] * self.size() + res = [0] * self.size() j = self.__front for i in range(self.size()): res[i] = self.__nums[(j % self.capacity())] @@ -76,35 +73,36 @@ class ArrayQueue: return res +""" Driver Code """ if __name__ == "__main__": """ 初始化队列 """ queue = ArrayQueue(10) """ 元素入队 """ - queue.put(1) - queue.put(3) - queue.put(2) - queue.put(5) - queue.put(4) - print("队列 queue = ", queue.to_list()) + queue.push(1) + queue.push(3) + queue.push(2) + queue.push(5) + queue.push(4) + print("队列 queue =", queue.to_list()) """ 访问队首元素 """ peek = queue.peek() - print("队首元素 peek = ", peek) + print("队首元素 peek =", peek) """ 访问索引 index 处元素 """ - num = queue.get_index(3) + num = queue.get(3) print("队列索引 3 处的元素为 num =", num) """ 元素出队 """ - get = queue.get() - print("出队元素 get = ", get) - print("出队后 queue = ", queue.to_list()) + poll = queue.poll() + print("出队元素 poll =", poll) + print("出队后 queue =", queue.to_list()) """ 获取队列的长度 """ size = queue.size() - print("队列长度 size = ", size) + print("队列长度 size =", size) """ 判断队列是否为空 """ is_empty = queue.is_empty() - print("队列是否为空 = ", is_empty) + print("队列是否为空 =", is_empty) diff --git a/codes/python/chapter_stack_and_queue/deque.py b/codes/python/chapter_stack_and_queue/deque.py index a2929dfd4..8a68fe76f 100644 --- a/codes/python/chapter_stack_and_queue/deque.py +++ b/codes/python/chapter_stack_and_queue/deque.py @@ -12,36 +12,38 @@ from include import * from collections import deque + +""" Driver Code """ if __name__ == "__main__": """ 初始化双向队列 """ duque = deque() """ 元素入队 """ - duque.append(2) # 添加至队尾 + duque.append(2) # 添加至队尾 duque.append(5) duque.append(4) duque.appendleft(3) # 添加至队首 duque.appendleft(1) - print("双向队列 duque = ", duque) + print("双向队列 duque =", duque) """ 访问队首元素 """ - peekFirst = duque[0] # 队首元素 - print("队首元素 peekFirst = ", peekFirst) - peekLast = duque[-1] # 队尾元素 - print("队尾元素 peekLast = ", peekLast) + front = duque[0] # 队首元素 + print("队首元素 front =", front) + rear = duque[-1] # 队尾元素 + print("队尾元素 rear =", rear) """ 元素出队 """ - popFirst = duque.pop() # 队首元素出队 - print("队首出队元素 popFirst= ", popFirst) - print("队首出队后 duque = ", duque) - popLast = duque.popleft() # 队尾元素出队 - print("队尾出队元素 popLast= ", popLast) - print("队尾出队后 duque = ", duque) + pop_front = duque.popleft() # 队首元素出队 + print("队首出队元素 pop_front =", pop_front) + print("队首出队后 duque =", duque) + pop_rear = duque.pop() # 队尾元素出队 + print("队尾出队元素 pop_rear =", pop_rear) + print("队尾出队后 duque =", duque) """ 获取双向队列的长度 """ size = len(duque) - print("双向队列长度 size = ", size) + print("双向队列长度 size =", size) """ 判断双向队列是否为空 """ is_empty = len(duque) == 0 - print("双向队列是否为空 = ", is_empty) + print("双向队列是否为空 =", is_empty) diff --git a/codes/python/chapter_stack_and_queue/linkedlist_queue.py b/codes/python/chapter_stack_and_queue/linkedlist_queue.py index d5a2202d4..0d4a28d4d 100644 --- a/codes/python/chapter_stack_and_queue/linkedlist_queue.py +++ b/codes/python/chapter_stack_and_queue/linkedlist_queue.py @@ -13,8 +13,8 @@ from include import * """ 基于链表实现的队列 """ class LinkedListQueue: def __init__(self): - self.__front = 0 # 头结点 front - self.__rear = 0 # 尾结点 rear + self.__front = None # 头结点 front + self.__rear = None # 尾结点 rear self.__size = 0 """ 获取队列的长度 """ @@ -26,7 +26,7 @@ class LinkedListQueue: return not self.__front """ 入队 """ - def put(self, num): + def push(self, num): # 尾结点后添加 num node = ListNode(num) # 如果队列为空，则令头、尾结点都指向该结点 @@ -40,7 +40,7 @@ class LinkedListQueue: self.__size += 1 """ 出队 """ - def get(self): + def poll(self): num = self.peek() # 删除头结点 self.__front = self.__front.next @@ -64,31 +64,32 @@ class LinkedListQueue: return queue +""" Driver Code """ if __name__ == "__main__": """ 初始化队列 """ queue = LinkedListQueue() """ 元素入队 """ - queue.put(1) - queue.put(3) - queue.put(2) - queue.put(5) - queue.put(4) - print("队列 queue = ", queue.to_list()) + queue.push(1) + queue.push(3) + queue.push(2) + queue.push(5) + queue.push(4) + print("队列 queue =", queue.to_list()) """ 访问队首元素 """ peek = queue.peek() - print("队首元素 front = ", peek) + print("队首元素 front =", peek) """ 元素出队 """ - get = queue.get() - print("出队元素 get = ", get) - print("出队后 queue = ", queue.to_list()) + pop_front = queue.poll() + print("出队元素 poll =", pop_front) + print("出队后 queue =", queue.to_list()) """ 获取队列的长度 """ size = queue.size() - print("队列长度 size = ", size) + print("队列长度 size =", size) """ 判断队列是否为空 """ is_empty = queue.is_empty() - print("队列是否为空 = ", is_empty) + print("队列是否为空 =", is_empty) diff --git a/codes/python/chapter_stack_and_queue/queue.py b/codes/python/chapter_stack_and_queue/queue.py index 3f39d2d87..93729a868 100644 --- a/codes/python/chapter_stack_and_queue/queue.py +++ b/codes/python/chapter_stack_and_queue/queue.py @@ -1,5 +1,5 @@ ''' -File: queue.py +File: que.py Created Time: 2022-11-29 Author: Peng Chen (pengchzn@gmail.com) ''' @@ -10,33 +10,35 @@ import sys sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__)))) from include import * -import queue -if __name__ == "__main__": +""" Driver Code """ +if __name__ == "__main__": """ 初始化队列 """ - queue = queue.Queue() + # 在 Python 中，我们一般将双向队列类 deque 看左队列使用 + # 虽然 queue.Queue() 是纯正的队列类，但不太好用，因此不建议 + que = collections.deque() """ 元素入队 """ - queue.put(1) - queue.put(3) - queue.put(2) - queue.put(5) - queue.put(4) - print("队列 queue = ", queue.queue) + que.append(1) + que.append(3) + que.append(2) + que.append(5) + que.append(4) + print("队列 que =", que) """ 访问队首元素 """ - peek = queue.queue[0] - print("队首元素 peek = ", peek) + front = que[0]; + print("队首元素 front =", front); """ 元素出队 """ - get = queue.get() - print("出队元素 get = ", get) - print("出队后 queue = ", queue.queue) + pop = que.popleft() + print("出队元素 pop =", pop) + print("出队后 que =", que) """ 获取队列的长度 """ - size = queue.qsize() - print("队列长度 size = ", size) + size = len(que) + print("队列长度 size =", size) """ 判断队列是否为空 """ - is_empty = queue.empty() - print("队列是否为空 = ", is_empty) + is_empty = len(que) == 0 + print("队列是否为空 =", is_empty) diff --git a/codes/python/include/__init__.py b/codes/python/include/__init__.py index 5939efb5a..77cf855a5 100644 --- a/codes/python/include/__init__.py +++ b/codes/python/include/__init__.py @@ -1,5 +1,6 @@ import copy import math +import queue import random import functools import collections diff --git a/codes/python/include/print_util.py b/codes/python/include/print_util.py index b7c2ba2db..f315add8d 100644 --- a/codes/python/include/print_util.py +++ b/codes/python/include/print_util.py @@ -4,6 +4,8 @@ Created Time: 2021-12-11 Author: Krahets (krahets@163.com) ''' +import copy +import queue from .binary_tree import TreeNode, tree_to_list from .linked_list import ListNode, linked_list_to_list @@ -28,7 +30,6 @@ def print_linked_list(head): arr = linked_list_to_list(head) print(' -> '.join([str(a) for a in arr])) - class Trunk: def __init__(self, prev=None, str=None): self.prev = prev diff --git a/docs/chapter_array_and_linkedlist/list.md b/docs/chapter_array_and_linkedlist/list.md index 11dd816ec..db9bdbf11 100644 --- a/docs/chapter_array_and_linkedlist/list.md +++ b/docs/chapter_array_and_linkedlist/list.md @@ -288,13 +288,13 @@ comments: true } /* 中间插入元素 */ - public void add(int index, int num) { + public void insert(int index, int num) { if (index >= size) throw new IndexOutOfBoundsException("索引越界"); // 元素数量超出容量时，触发扩容机制 if (size == capacity()) extendCapacity(); - // 索引 i 以及之后的元素都向后移动一位 + // 将索引 index 以及之后的元素都向后移动一位 for (int j = size - 1; j >= index; j--) { nums[j + 1] = nums[j]; } @@ -304,15 +304,18 @@ comments: true } /* 删除元素 */ - public void remove(int index) { + public int remove(int index) { if (index >= size) throw new IndexOutOfBoundsException("索引越界"); - // 索引 i 之后的元素都向前移动一位 + int num = nums[index]; + // 将索引 index 之后的元素都向前移动一位 for (int j = index; j < size - 1; j++) { nums[j] = nums[j + 1]; } // 更新元素数量 size--; + // 返回被删除元素 + return num; } /* 列表扩容 */ @@ -394,15 +397,18 @@ comments: true } /* 删除元素 */ - void remove(int index) { + int remove(int index) { if (index >= size()) throw out_of_range("索引越界"); + int num = nums[index]; // 索引 i 之后的元素都向前移动一位 for (int j = index; j < size() - 1; j++) { nums[j] = nums[j + 1]; } // 更新元素数量 numsSize--; + // 返回被删除元素 + return num; } /* 列表扩容 */ @@ -419,16 +425,6 @@ comments: true delete[] temp; numsCapacity = newCapacity; } - - /* 将列表转换为 Vector 用于打印 */ - vector toVector() { - // 仅转换有效长度范围内的列表元素 - vector vec(size()); - for (int i = 0; i < size(); i++) { - vec[i] = nums[i]; - } - return vec; - } }; ``` @@ -463,9 +459,10 @@ comments: true assert index < self.__size, "索引越界" self.__nums[index] = num - """ 中间插入元素 """ + """ 中间插入（尾部添加）元素 """ def add(self, num, index=-1): assert index < self.__size, "索引越界" + # 若不指定索引 index ，则向数组尾部添加元素 if index == -1: index = self.__size # 元素数量超出容量时，触发扩容机制 diff --git a/docs/chapter_stack_and_queue/deque.md b/docs/chapter_stack_and_queue/deque.md index 06657626b..f9b45eca2 100644 --- a/docs/chapter_stack_and_queue/deque.md +++ b/docs/chapter_stack_and_queue/deque.md @@ -92,5 +92,27 @@ comments: true === "Python" ```python title="deque.py" - + """ 初始化双向队列 """ + duque = deque() + + """ 元素入队 """ + duque.append(2) # 添加至队尾 + duque.append(5) + duque.append(4) + duque.appendleft(3) # 添加至队首 + duque.appendleft(1) + + """ 访问队首元素 """ + front = duque[0] # 队首元素 + rear = duque[-1] # 队尾元素 + + """ 元素出队 """ + pop_front = duque.popleft() # 队首元素出队 + pop_rear = duque.pop() # 队尾元素出队 + + """ 获取双向队列的长度 """ + size = len(duque) + + """ 判断双向队列是否为空 """ + is_empty = len(duque) == 0 ``` diff --git a/docs/chapter_stack_and_queue/queue.md b/docs/chapter_stack_and_queue/queue.md index f69f37e09..825b58ed6 100644 --- a/docs/chapter_stack_and_queue/queue.md +++ b/docs/chapter_stack_and_queue/queue.md @@ -20,13 +20,13 @@ comments: true
-| 方法 | 描述 | -| --------- | ---------------------------- | -| offer() | 元素入队，即将元素添加至队尾 | -| poll() | 队首元素出队 | -| front() | 访问队首元素 | -| size() | 获取队列的长度 | -| isEmpty() | 判断队列是否为空 | +| 方法 | 描述 | +| --------- | ------------------------ | +| offer() | 元素入队，即将元素添加至队尾 | +| poll() | 队首元素出队 | +| front() | 访问队首元素 | +| size() | 获取队列的长度 | +| isEmpty() | 判断队列是否为空 |
@@ -87,7 +87,29 @@ comments: true === "Python" ```python title="queue.py" - + """ 初始化队列 """ + # 在 Python 中，我们一般将双向队列类 deque 看左队列使用 + # 虽然 queue.Queue() 是纯正的队列类，但不太好用，因此不建议 + que = collections.deque() + + """ 元素入队 """ + que.append(1) + que.append(3) + que.append(2) + que.append(5) + que.append(4) + + """ 访问队首元素 """ + front = que[0]; + + """ 元素出队 """ + pop = que.popleft() + + """ 获取队列的长度 """ + size = len(que) + + """ 判断队列是否为空 """ + is_empty = len(que) == 0 ``` ## 队列实现 @@ -209,7 +231,49 @@ comments: true === "Python" ```python title="linkedlist_queue.py" - + """ 基于链表实现的队列 """ + class LinkedListQueue: + def __init__(self): + self.__front = None # 头结点 front + self.__rear = None # 尾结点 rear + self.__size = 0 + + """ 获取队列的长度 """ + def size(self): + return self.__size + + """ 判断队列是否为空 """ + def is_empty(self): + return not self.__front + + """ 入队 """ + def push(self, num): + # 尾结点后添加 num + node = ListNode(num) + # 如果队列为空，则令头、尾结点都指向该结点 + if self.__front == 0: + self.__front = node + self.__rear = node + # 如果队列不为空，则将该结点添加到尾结点后 + else: + self.__rear.next = node + self.__rear = node + self.__size += 1 + + """ 出队 """ + def poll(self): + num = self.peek() + # 删除头结点 + self.__front = self.__front.next + self.__size -= 1 + return num + + """ 访问队首元素 """ + def peek(self): + if self.size() == 0: + print("队列为空") + return False + return self.__front.val ``` ### 基于数组的实现 @@ -262,11 +326,8 @@ comments: true } /* 出队 */ public int poll() { - // 删除头结点 - if (isEmpty()) - throw new EmptyStackException(); - int num = nums[front]; - // 队头指针向后移动，越过尾部后返回到数组头部 + int num = peek(); + // 队头指针向后移动一位，若越过尾部则返回到数组头部 front = (front + 1) % capacity(); return num; } @@ -329,11 +390,8 @@ comments: true } /* 出队 */ int poll() { - // 删除头结点 - if (empty()) - throw out_of_range("队列为空"); - int num = nums[front]; - // 队头指针向后移动，越过尾部后返回到数组头部 + int num = peek(); + // 队头指针向后移动一位，若越过尾部则返回到数组头部 front = (front + 1) % capacity(); return num; } @@ -356,11 +414,70 @@ comments: true === "Python" ```python title="array_queue.py" - + """ 基于环形数组实现的队列 """ + class ArrayQueue: + def __init__(self, size): + self.__nums = [0] * size # 用于存储队列元素的数组 + self.__front = 0 # 头指针，指向队首 + self.__rear = 0 # 尾指针，指向队尾 + 1 + + """ 获取队列的容量 """ + def capacity(self): + return len(self.__nums) + + """ 获取队列的长度 """ + def size(self): + # 由于将数组看作为环形，可能 rear < front ，因此需要取余数 + return (self.capacity() + self.__rear - self.__front) % self.capacity() + + """ 判断队列是否为空 """ + def is_empty(self): + return (self.__rear - self.__front) == 0 + + """ 入队 """ + def push(self, val): + if self.size() == self.capacity(): + print("队列已满") + return False + # 尾结点后添加 num + self.__nums[self.__rear] = val + # 尾指针向后移动一位，越过尾部后返回到数组头部 + self.__rear = (self.__rear + 1) % self.capacity() + + """ 出队 """ + def poll(self): + # 删除头结点 + num = self.peek() + # 队头指针向后移动一位，若越过尾部则返回到数组头部 + self.__front = (self.__front + 1) % self.capacity() + return num + + """ 访问队首元素 """ + def peek(self): + # 删除头结点 + if self.is_empty(): + print("队列为空") + return False + return self.__nums[self.__front] + + """ 访问指定位置元素 """ + def get(self, index): + if index >= self.size(): + print("索引越界") + return False + return self.__nums[(self.__front + index) % self.capacity()] + + """ 返回列表用于打印 """ + def to_list(self): + res = [0] * self.size() + j = self.__front + for i in range(self.size()): + res[i] = self.__nums[(j % self.capacity())] + j += 1 + return res ``` ## 队列典型应用 - **淘宝订单。** 购物者下单后，订单就被加入到队列之中，随后系统再根据顺序依次处理队列中的订单。在双十一时，在短时间内会产生海量的订单，如何处理「高并发」则是工程师们需要重点思考的问题。 - - **各种待办事项。** 例如打印机的任务队列、餐厅的出餐队列等等。 From d85a14521f45cc2a38875fe942548f968fb7af94 Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Fri, 2 Dec 2022 00:53:19 +0800 Subject: [PATCH 41/67] Fix the util of array to tree. --- README.md | 2 +- codes/java/include/TreeNode.java | 3 +++ codes/python/include/binary_tree.py | 2 +- 3 files changed, 5 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 24391cfb9..a006289c5 100644 --- a/README.md +++ b/README.md @@ -29,7 +29,7 @@ ## 关于本书 -本书致力于达成以下目标： +本书面向数据结构与算法初学者，致力于达成以下目标： - 开源免费，所有同学都可在网上获取本书； - 新手友好，适合算法初学者自主学习入门； diff --git a/codes/java/include/TreeNode.java b/codes/java/include/TreeNode.java index bba76b123..6541064f7 100755 --- a/codes/java/include/TreeNode.java +++ b/codes/java/include/TreeNode.java @@ -26,6 +26,9 @@ public class TreeNode { * @return */ public static TreeNode arrToTree(Integer[] arr) { + if (arr.length == 0) + return null; + TreeNode root = new TreeNode(arr[0]); Queue queue = new LinkedList<>() {{ add(root); }}; int i = 1; diff --git a/codes/python/include/binary_tree.py b/codes/python/include/binary_tree.py index d905d8270..24acb47d4 100644 --- a/codes/python/include/binary_tree.py +++ b/codes/python/include/binary_tree.py @@ -24,7 +24,7 @@ def list_to_tree(arr): [type]: [description] """ if not arr: - return + return None i = 1 root = TreeNode(int(arr[0])) queue = collections.deque() From a51b3fc60f43c31e0777896ea36d4ae30715c6b4 Mon Sep 17 00:00:00 2001 From: yabo083 <103875886+yabo083@users.noreply.github.com> Date: Fri, 2 Dec 2022 20:23:52 +0800 Subject: [PATCH 42/67] Update binary_tree_types.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 已简单修改有关完美二叉树的性质部分错误，但字体并不与原文相符，待进一步订正。 --- docs/chapter_tree/binary_tree_types.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/chapter_tree/binary_tree_types.md b/docs/chapter_tree/binary_tree_types.md index 9fd6d06a2..af0112bc7 100644 --- a/docs/chapter_tree/binary_tree_types.md +++ b/docs/chapter_tree/binary_tree_types.md @@ -16,7 +16,7 @@ comments: true 完美二叉树的性质有： -- 若树高度 $= h$ ，则结点总数 $= 2^h$ ； +- 若树高度 $= h$ ，则结点总数 $= 2^h$ - 1； ## 完全二叉树 @@ -38,4 +38,4 @@ comments: true **「平衡二叉树 Balanced Binary Tree」，又称「AVL 树」** ，其任意结点的左子树和右子树的高度之差的绝对值 $\leq 1$ 。 -![balanced_binary_tree](binary_tree_types.assets/balanced_binary_tree.png) \ No newline at end of file +![balanced_binary_tree](binary_tree_types.assets/balanced_binary_tree.png) From 9bd5980a81ec3d3a48bcd85b17f6c2d0fad86ad0 Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Sat, 3 Dec 2022 01:31:29 +0800 Subject: [PATCH 43/67] Organizing all the code blocks. --- docs/chapter_array_and_linkedlist/array.md | 322 +++++++---- .../linked_list.md | 180 +++++++ docs/chapter_array_and_linkedlist/list.md | 210 ++++++++ .../space_complexity.md | 270 ++++++++++ .../space_time_tradeoff.md | 52 +- .../time_complexity.md | 504 +++++++++++++++++- .../chapter_data_structure/data_and_memory.md | 32 +- docs/chapter_searching/binary_search.md | 109 +++- docs/chapter_searching/hashing_search.md | 72 +++ docs/chapter_searching/linear_search.md | 72 +++ docs/chapter_searching/summary.md | 4 + docs/chapter_sorting/bubble_sort.md | 134 +++-- docs/chapter_sorting/insertion_sort.md | 60 ++- docs/chapter_sorting/merge_sort.md | 114 ++-- docs/chapter_sorting/quick_sort.md | 278 ++++++---- docs/chapter_stack_and_queue/deque.md | 30 ++ docs/chapter_stack_and_queue/queue.md | 90 ++++ docs/chapter_stack_and_queue/stack.md | 90 ++++ docs/chapter_tree/binary_search_tree.md | 72 +++ docs/chapter_tree/binary_tree.md | 128 ++++- docs/chapter_tree/binary_tree_types.md | 7 +- 21 files changed, 2520 insertions(+), 310 deletions(-) diff --git a/docs/chapter_array_and_linkedlist/array.md b/docs/chapter_array_and_linkedlist/array.md index 44cafd326..74e2063f0 100644 --- a/docs/chapter_array_and_linkedlist/array.md +++ b/docs/chapter_array_and_linkedlist/array.md @@ -24,14 +24,6 @@ comments: true int[] nums = { 1, 3, 2, 5, 4 }; ``` -=== "JavaScript" - - ```javascript title="array.javascript" - /* 初始化数组 */ - var arr = new Array(5).fill(0) - var nums = [1, 3, 2, 5, 4] - ``` - === "C++" ```cpp title="array.cpp" @@ -48,6 +40,38 @@ comments: true nums = [1, 3, 2, 5, 4] ``` +=== "Go" + + ```go title="array.go" + + ``` + +=== "JavaScript" + + ```javascript title="array.js" + /* 初始化数组 */ + var arr = new Array(5).fill(0) + var nums = [1, 3, 2, 5, 4] + ``` + +=== "TypeScript" + + ```typescript title="array.ts" + + ``` + +=== "C" + + ```c title="array.c" + + ``` + +=== "C#" + + ```csharp title="array.cs" + + ``` + ## 数组优点 **在数组中访问元素非常高效。** 这是因为在数组中，计算元素的内存地址非常容易。给定数组首个元素的地址、和一个元素的索引，利用以下公式可以直接计算得到该元素的内存地址，从而直接访问此元素。 @@ -77,19 +101,6 @@ elementAddr = firtstElementAddr + elementLength * elementIndex } ``` -=== "JavaScript" - - ```javascript title="array.javascript" - /* 随机返回一个数组元素 */ - function randomAccess(nums){ - // 在区间 [0, nums.length) 中随机抽取一个数字 - const random_index = Math.floor(Math.random() * nums.length) - // 获取并返回随机元素 - random_num = nums[random_index] - return random_num - } - ``` - === "C++" ```cpp title="array.cpp" @@ -115,6 +126,43 @@ elementAddr = firtstElementAddr + elementLength * elementIndex return random_num ``` +=== "Go" + + ```go title="array.go" + + ``` + +=== "JavaScript" + + ```javascript title="array.js" + /* 随机返回一个数组元素 */ + function randomAccess(nums){ + // 在区间 [0, nums.length) 中随机抽取一个数字 + const random_index = Math.floor(Math.random() * nums.length) + // 获取并返回随机元素 + random_num = nums[random_index] + return random_num + } + ``` + +=== "TypeScript" + + ```typescript title="array.ts" + + ``` + +=== "C" + + ```c title="array.c" + + ``` + +=== "C#" + + ```csharp title="array.cs" + + ``` + ## 数组缺点 **数组在初始化后长度不可变。** 由于系统无法保证数组之后的内存空间是可用的，因此数组长度无法扩展。而若希望扩容数组，则需新建一个数组，然后把原数组元素依次拷贝到新数组，在数组很大的情况下，这是非常耗时的。 @@ -135,22 +183,6 @@ elementAddr = firtstElementAddr + elementLength * elementIndex } ``` -=== "JavaScript" - - ```javascript title="array.javascript" - /* 扩展数组长度 */ - function extend(nums, enlarge){ - // 初始化一个扩展长度后的数组 - let res = new Array(nums.length + enlarge).fill(0) - // 将原数组中的所有元素复制到新数组 - for(let i=0; i= index; i--) { - nums[i] = nums[i - 1]; - } - // 将 num 赋给 index 处元素 - nums[index] = num; - } - - /* 删除索引 index 处元素 */ - function remove(nums, index){ - // 把索引 index 之后的所有元素向前移动一位 - for (let i = index; i < nums.length - 1; i++) { - nums[i] = nums[i + 1] - } - } - ``` - === "C++" ```cpp title="array.cpp" @@ -277,6 +327,52 @@ elementAddr = firtstElementAddr + elementLength * elementIndex nums[i] = nums[i + 1] ``` +=== "Go" + + ```go title="array.go" + + ``` + +=== "JavaScript" + + ```javascript title="array.js" + /* 在数组的索引 index 处插入元素 num */ + function insert(nums, num, index){ + // 把索引 index 以及之后的所有元素向后移动一位 + for (let i = nums.length - 1; i >= index; i--) { + nums[i] = nums[i - 1]; + } + // 将 num 赋给 index 处元素 + nums[index] = num; + } + + /* 删除索引 index 处元素 */ + function remove(nums, index){ + // 把索引 index 之后的所有元素向前移动一位 + for (let i = index; i < nums.length - 1; i++) { + nums[i] = nums[i + 1] + } + } + ``` + +=== "TypeScript" + + ```typescript title="array.ts" + + ``` + +=== "C" + + ```c title="array.c" + + ``` + +=== "C#" + + ```csharp title="array.cs" + + ``` + ## 数组常用操作 **数组遍历。** 以下介绍两种常用的遍历方法。 @@ -298,23 +394,6 @@ elementAddr = firtstElementAddr + elementLength * elementIndex } ``` -=== "JavaScript" - - ```javascript title="array.javascript" - /* 遍历数组 */ - function traverse(nums){ - let count = 0 - // 通过索引遍历数组 - for (let i = 0; i < nums.length; i++) { - count++; - } - // 直接遍历数组 - for(let num of nums){ - count += 1 - } - } - ``` - === "C++" ```cpp title="array.cpp" @@ -342,6 +421,47 @@ elementAddr = firtstElementAddr + elementLength * elementIndex count += 1 ``` +=== "Go" + + ```go title="array.go" + + ``` + +=== "JavaScript" + + ```javascript title="array.js" + /* 遍历数组 */ + function traverse(nums){ + let count = 0 + // 通过索引遍历数组 + for (let i = 0; i < nums.length; i++) { + count++; + } + // 直接遍历数组 + for(let num of nums){ + count += 1 + } + } + ``` + +=== "TypeScript" + + ```typescript title="array.ts" + + ``` + +=== "C" + + ```c title="array.c" + + ``` + +=== "C#" + + ```csharp title="array.cs" + + ``` + **数组查找。** 通过遍历数组，查找数组内的指定元素，并输出对应索引。 === "Java" @@ -357,19 +477,6 @@ elementAddr = firtstElementAddr + elementLength * elementIndex } ``` -=== "JavaScript" - - ```javascript title="array.javascript" - /* 在数组中查找指定元素 */ - function find(nums, target){ - for (let i = 0; i < nums.length; i++) { - if (nums[i] == target) - return i; - } - return -1 - } - ``` - === "C++" ```cpp title="array.cpp" @@ -394,6 +501,43 @@ elementAddr = firtstElementAddr + elementLength * elementIndex return -1 ``` +=== "Go" + + ```go title="array.go" + + ``` + +=== "JavaScript" + + ```javascript title="array.js" + /* 在数组中查找指定元素 */ + function find(nums, target){ + for (let i = 0; i < nums.length; i++) { + if (nums[i] == target) + return i; + } + return -1 + } + ``` + +=== "TypeScript" + + ```typescript title="array.ts" + + ``` + +=== "C" + + ```c title="array.c" + + ``` + +=== "C#" + + ```csharp title="array.cs" + + ``` + ## 数组典型应用 **随机访问。** 如果我们想要随机抽取一些样本，那么可以用数组存储，并生成一个随机序列，根据索引实现样本的随机抽取。 diff --git a/docs/chapter_array_and_linkedlist/linked_list.md b/docs/chapter_array_and_linkedlist/linked_list.md index 79dee24ac..d8dcce4a5 100644 --- a/docs/chapter_array_and_linkedlist/linked_list.md +++ b/docs/chapter_array_and_linkedlist/linked_list.md @@ -48,6 +48,36 @@ comments: true self.next = None # 指向下一结点的指针（引用） ``` +=== "Go" + + ```go title="" + + ``` + +=== "JavaScript" + + ```js title="" + + ``` + +=== "TypeScript" + + ```typescript title="" + + ``` + +=== "C" + + ```c title="" + + ``` + +=== "C#" + + ```csharp title="" + + ``` + **尾结点指向什么？** 我们一般将链表的最后一个结点称为「尾结点」，其指向的是「空」，在 Java / C++ / Python 中分别记为 `null` / `nullptr` / `None` 。在不引起歧义下，本书都使用 `null` 来表示空。 **链表初始化方法。** 建立链表分为两步，第一步是初始化各个结点对象，第二步是构建引用指向关系。完成后，即可以从链表的首个结点（即头结点）出发，访问其余所有的结点。 @@ -107,6 +137,36 @@ comments: true n3.next = n4 ``` +=== "Go" + + ```go title="" + + ``` + +=== "JavaScript" + + ```js title="" + + ``` + +=== "TypeScript" + + ```typescript title="" + + ``` + +=== "C" + + ```c title="" + + ``` + +=== "C#" + + ```csharp title="" + + ``` + ## 链表优点 **在链表中，插入与删除结点的操作效率高。** 例如，如果想在链表中间的两个结点 `A` , `B` 之间插入一个新结点 `P` ，我们只需要改变两个结点指针即可，时间复杂度为 $O(1)$ ，相比数组的插入操作高效很多。在链表中删除某个结点也很方便，只需要改变一个结点指针即可。 @@ -176,6 +236,36 @@ comments: true n0.next = n1 ``` +=== "Go" + + ```go title="" + + ``` + +=== "JavaScript" + + ```js title="" + + ``` + +=== "TypeScript" + + ```typescript title="" + + ``` + +=== "C" + + ```c title="" + + ``` + +=== "C#" + + ```csharp title="" + + ``` + ## 链表缺点 **链表访问结点效率低。** 上节提到，数组可以在 $O(1)$ 时间下访问任意元素，但链表无法直接访问任意结点。这是因为计算机需要从头结点出发，一个一个地向后遍历到目标结点。例如，倘若想要访问链表索引为 `index` （即第 `index + 1` 个）的结点，那么需要 `index` 次访问操作。 @@ -220,6 +310,36 @@ comments: true return head ``` +=== "Go" + + ```go title="" + + ``` + +=== "JavaScript" + + ```js title="" + + ``` + +=== "TypeScript" + + ```typescript title="" + + ``` + +=== "C" + + ```c title="" + + ``` + +=== "C#" + + ```csharp title="" + + ``` + **链表的内存占用多。** 链表以结点为单位，每个结点除了保存值外，还需额外保存指针（引用）。这意味着同样数据量下，链表比数组需要占用更多内存空间。 ## 链表常用操作 @@ -272,6 +392,36 @@ comments: true return -1 ``` +=== "Go" + + ```go title="" + + ``` + +=== "JavaScript" + + ```js title="" + + ``` + +=== "TypeScript" + + ```typescript title="" + + ``` + +=== "C" + + ```c title="" + + ``` + +=== "C#" + + ```csharp title="" + + ``` + ## 常见链表类型 **单向链表。** 即上述介绍的普通链表。单向链表的结点有「值」和指向下一结点的「指针（引用）」两项数据。我们将首个结点称为头结点，尾结点指向 `null` 。 @@ -315,6 +465,36 @@ comments: true self.prev = None # 指向前驱结点的指针（引用） ``` +=== "Go" + + ```go title="" + + ``` + +=== "JavaScript" + + ```js title="" + + ``` + +=== "TypeScript" + + ```typescript title="" + + ``` + +=== "C" + + ```c title="" + + ``` + +=== "C#" + + ```csharp title="" + + ``` + ![linkedlist_common_types](linked_list.assets/linkedlist_common_types.png)

Fig. 常见链表类型

diff --git a/docs/chapter_array_and_linkedlist/list.md b/docs/chapter_array_and_linkedlist/list.md index db9bdbf11..ebff3877f 100644 --- a/docs/chapter_array_and_linkedlist/list.md +++ b/docs/chapter_array_and_linkedlist/list.md @@ -35,6 +35,36 @@ comments: true list = [1, 3, 2, 5, 4] ``` +=== "Go" + + ```go title="list.go" + + ``` + +=== "JavaScript" + + ```js title="list.js" + + ``` + +=== "TypeScript" + + ```typescript title="list.ts" + + ``` + +=== "C" + + ```c title="list.c" + + ``` + +=== "C#" + + ```csharp title="list.cs" + + ``` + **访问与更新元素。** 列表的底层数据结构是数组，因此可以在 $O(1)$ 时间内访问与更新元素，效率很高。 === "Java" @@ -67,6 +97,36 @@ comments: true list[1] = 0 # 将索引 1 处的元素更新为 0 ``` +=== "Go" + + ```go title="list.go" + + ``` + +=== "JavaScript" + + ```js title="list.js" + + ``` + +=== "TypeScript" + + ```typescript title="list.ts" + + ``` + +=== "C" + + ```c title="list.c" + + ``` + +=== "C#" + + ```csharp title="list.cs" + + ``` + **在列表中添加、插入、删除元素。** 相对于数组，列表可以自由地添加与删除元素。在列表尾部添加元素的时间复杂度为 $O(1)$ ，但是插入与删除元素的效率仍与数组一样低，时间复杂度为 $O(N)$ 。 === "Java" @@ -129,6 +189,36 @@ comments: true list.pop(3) # 删除索引 3 处的元素 ``` +=== "Go" + + ```go title="list.go" + + ``` + +=== "JavaScript" + + ```js title="list.js" + + ``` + +=== "TypeScript" + + ```typescript title="list.ts" + + ``` + +=== "C" + + ```c title="list.c" + + ``` + +=== "C#" + + ```csharp title="list.cs" + + ``` + **遍历列表。** 与数组一样，列表可以使用索引遍历，也可以使用 `for-each` 直接遍历。 === "Java" @@ -177,6 +267,36 @@ comments: true count += 1 ``` +=== "Go" + + ```go title="list.go" + + ``` + +=== "JavaScript" + + ```js title="list.js" + + ``` + +=== "TypeScript" + + ```typescript title="list.ts" + + ``` + +=== "C" + + ```c title="list.c" + + ``` + +=== "C#" + + ```csharp title="list.cs" + + ``` + **拼接两个列表。** 再创建一个新列表 `list1` ，我们可以将其中一个列表拼接到另一个的尾部。 === "Java" @@ -204,6 +324,36 @@ comments: true list += list1 # 将列表 list1 拼接到 list 之后 ``` +=== "Go" + + ```go title="list.go" + + ``` + +=== "JavaScript" + + ```js title="list.js" + + ``` + +=== "TypeScript" + + ```typescript title="list.ts" + + ``` + +=== "C" + + ```c title="list.c" + + ``` + +=== "C#" + + ```csharp title="list.cs" + + ``` + **排序列表。** 排序也是常用的方法之一，完成列表排序后，我们就可以使用在数组类算法题中经常考察的「二分查找」和「双指针」算法了。 === "Java" @@ -227,6 +377,36 @@ comments: true list.sort() # 排序后，列表元素从小到大排列 ``` +=== "Go" + + ```go title="list.go" + + ``` + +=== "JavaScript" + + ```js title="list.js" + + ``` + +=== "TypeScript" + + ```typescript title="list.ts" + + ``` + +=== "C" + + ```c title="list.c" + + ``` + +=== "C#" + + ```csharp title="list.cs" + + ``` + ## 列表简易实现 * 为了帮助加深对列表的理解，我们在此提供一个列表的简易版本的实现。需要关注三个核心点： @@ -491,3 +671,33 @@ comments: true # 更新列表容量 self.__capacity = len(self.__nums) ``` + +=== "Go" + + ```go title="my_list.go" + + ``` + +=== "JavaScript" + + ```js title="my_list.js" + + ``` + +=== "TypeScript" + + ```typescript title="my_list.ts" + + ``` + +=== "C" + + ```c title="my_list.c" + + ``` + +=== "C#" + + ```csharp title="my_list.cs" + + ``` diff --git a/docs/chapter_computational_complexity/space_complexity.md b/docs/chapter_computational_complexity/space_complexity.md index 9bd24e1c4..eda90137c 100644 --- a/docs/chapter_computational_complexity/space_complexity.md +++ b/docs/chapter_computational_complexity/space_complexity.md @@ -99,6 +99,36 @@ comments: true return a + b + c # 输出数据 ``` +=== "Go" + + ```go title="" + + ``` + +=== "JavaScript" + + ```js title="" + + ``` + +=== "TypeScript" + + ```typescript title="" + + ``` + +=== "C" + + ```c title="" + + ``` + +=== "C#" + + ```csharp title="" + + ``` + ## 推算方法 空间复杂度的推算方法和时间复杂度总体类似，只是从统计 “计算操作数量” 变为统计 “使用空间大小” 。与时间复杂度不同的是，**我们一般只关注「最差空间复杂度」**。这是因为内存空间是一个硬性要求，我们必须保证在所有输入数据下都有足够的内存空间预留。 @@ -140,6 +170,36 @@ comments: true nums = [0] * n # O(n) ``` +=== "Go" + + ```go title="" + + ``` + +=== "JavaScript" + + ```js title="" + + ``` + +=== "TypeScript" + + ```typescript title="" + + ``` + +=== "C" + + ```c title="" + + ``` + +=== "C#" + + ```csharp title="" + + ``` + **在递归函数中，需要注意统计栈帧空间。** 例如函数 `loop()`，在循环中调用了 $n$ 次 `function()` ，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。而递归函数 `recur()` 在运行中会同时存在 $n$ 个未返回的 `recur()` ，从而使用 $O(n)$ 的栈帧空间。 === "Java" @@ -200,6 +260,36 @@ comments: true return recur(n - 1) ``` +=== "Go" + + ```go title="" + + ``` + +=== "JavaScript" + + ```js title="" + + ``` + +=== "TypeScript" + + ```typescript title="" + + ``` + +=== "C" + + ```c title="" + + ``` + +=== "C#" + + ```csharp title="" + + ``` + ## 常见类型 设输入数据大小为 $n$ ，常见的空间复杂度类型有（从低到高排列） @@ -284,6 +374,36 @@ $$ function() ``` +=== "Go" + + ```go title="space_complexity_types.go" + + ``` + +=== "JavaScript" + + ```js title="space_complexity_types.js" + + ``` + +=== "TypeScript" + + ```typescript title="space_complexity_types.ts" + + ``` + +=== "C" + + ```c title="space_complexity_types.c" + + ``` + +=== "C#" + + ```csharp title="space_complexity_types.cs" + + ``` + ### 线性阶 $O(n)$ 线性阶常见于元素数量与 $n$ 成正比的数组、链表、栈、队列等。 @@ -341,6 +461,36 @@ $$ mapp[i] = str(i) ``` +=== "Go" + + ```go title="space_complexity_types.go" + + ``` + +=== "JavaScript" + + ```js title="space_complexity_types.js" + + ``` + +=== "TypeScript" + + ```typescript title="space_complexity_types.ts" + + ``` + +=== "C" + + ```c title="space_complexity_types.c" + + ``` + +=== "C#" + + ```csharp title="space_complexity_types.cs" + + ``` + 以下递归函数会同时存在 $n$ 个未返回的 `algorithm()` 函数，使用 $O(n)$ 大小的栈帧空间。 === "Java" @@ -375,6 +525,36 @@ $$ linearRecur(n - 1) ``` +=== "Go" + + ```go title="space_complexity_types.go" + + ``` + +=== "JavaScript" + + ```js title="space_complexity_types.js" + + ``` + +=== "TypeScript" + + ```typescript title="space_complexity_types.ts" + + ``` + +=== "C" + + ```c title="space_complexity_types.c" + + ``` + +=== "C#" + + ```csharp title="space_complexity_types.cs" + + ``` + ![space_complexity_recursive_linear](space_complexity.assets/space_complexity_recursive_linear.png)

Fig. 递归函数产生的线性阶空间复杂度

@@ -428,6 +608,36 @@ $$ num_matrix = [[0] * n for _ in range(n)] ``` +=== "Go" + + ```go title="space_complexity_types.go" + + ``` + +=== "JavaScript" + + ```js title="space_complexity_types.js" + + ``` + +=== "TypeScript" + + ```typescript title="space_complexity_types.ts" + + ``` + +=== "C" + + ```c title="space_complexity_types.c" + + ``` + +=== "C#" + + ```csharp title="space_complexity_types.cs" + + ``` + 在以下递归函数中，同时存在 $n$ 个未返回的 `algorihtm()` ，并且每个函数中都初始化了一个数组，长度分别为 $n, n-1, n-2, ..., 2, 1$ ，平均长度为 $\frac{n}{2}$ ，因此总体使用 $O(n^2)$ 空间。 === "Java" @@ -465,6 +675,36 @@ $$ return quadratic_recur(n - 1) ``` +=== "Go" + + ```go title="space_complexity_types.go" + + ``` + +=== "JavaScript" + + ```js title="space_complexity_types.js" + + ``` + +=== "TypeScript" + + ```typescript title="space_complexity_types.ts" + + ``` + +=== "C" + + ```c title="space_complexity_types.c" + + ``` + +=== "C#" + + ```csharp title="space_complexity_types.cs" + + ``` + ![space_complexity_recursive_quadratic](space_complexity.assets/space_complexity_recursive_quadratic.png)

Fig. 递归函数产生的平方阶空间复杂度

@@ -511,6 +751,36 @@ $$ return root ``` +=== "Go" + + ```go title="space_complexity_types.go" + + ``` + +=== "JavaScript" + + ```js title="space_complexity_types.js" + + ``` + +=== "TypeScript" + + ```typescript title="space_complexity_types.ts" + + ``` + +=== "C" + + ```c title="space_complexity_types.c" + + ``` + +=== "C#" + + ```csharp title="space_complexity_types.cs" + + ``` + ![space_complexity_exponential](space_complexity.assets/space_complexity_exponential.png)

Fig. 满二叉树下的指数阶空间复杂度

diff --git a/docs/chapter_computational_complexity/space_time_tradeoff.md b/docs/chapter_computational_complexity/space_time_tradeoff.md index 8e778f8fc..da1f7201d 100644 --- a/docs/chapter_computational_complexity/space_time_tradeoff.md +++ b/docs/chapter_computational_complexity/space_time_tradeoff.md @@ -20,7 +20,7 @@ comments: true === "Java" - ```java title="" title="leetcode_two_sum.java" + ```java title="leetcode_two_sum.java" class SolutionBruteForce { public int[] twoSum(int[] nums, int target) { int size = nums.length; @@ -85,6 +85,30 @@ comments: true } ``` +=== "JavaScript" + + ```js title="leetcode_two_sum.js" + + ``` + +=== "TypeScript" + + ```typescript title="leetcode_two_sum.ts" + + ``` + +=== "C" + + ```c title="leetcode_two_sum.c" + + ``` + +=== "C#" + + ```csharp title="leetcode_two_sum.cs" + + ``` + ### 方法二：辅助哈希表 时间复杂度 $O(N)$ ，空间复杂度 $O(N)$ ，属于「空间换时间」。 @@ -93,7 +117,7 @@ comments: true === "Java" - ```java title="" title="leetcode_two_sum.java" + ```java title="leetcode_two_sum.java" class SolutionHashMap { public int[] twoSum(int[] nums, int target) { int size = nums.length; @@ -163,3 +187,27 @@ comments: true return nil } ``` + +=== "JavaScript" + + ```js title="leetcode_two_sum.js" + + ``` + +=== "TypeScript" + + ```typescript title="leetcode_two_sum.ts" + + ``` + +=== "C" + + ```c title="leetcode_two_sum.c" + + ``` + +=== "C#" + + ```csharp title="leetcode_two_sum.cs" + + ``` diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md index ed1197542..df0ea51a7 100644 --- a/docs/chapter_computational_complexity/time_complexity.md +++ b/docs/chapter_computational_complexity/time_complexity.md @@ -61,6 +61,36 @@ $$ print(0) # 5 ns ``` +=== "Go" + + ```go title="" + + ``` + +=== "JavaScript" + + ```js title="" + + ``` + +=== "TypeScript" + + ```typescript title="" + + ``` + +=== "C" + + ```c title="" + + ``` + +=== "C#" + + ```csharp title="" + + ``` + 但实际上， **统计算法的运行时间既不合理也不现实。** 首先，我们不希望预估时间和运行平台绑定，毕竟算法需要跑在各式各样的平台之上。其次，我们很难获知每一种操作的运行时间，这为预估过程带来了极大的难度。 ## 统计时间增长趋势 @@ -131,6 +161,36 @@ $$ print(0) ``` +=== "Go" + + ```go title="" + + ``` + +=== "JavaScript" + + ```js title="" + + ``` + +=== "TypeScript" + + ```typescript title="" + + ``` + +=== "C" + + ```c title="" + + ``` + +=== "C#" + + ```csharp title="" + + ``` + ![time_complexity_first_example](time_complexity.assets/time_complexity_first_example.png)

Fig. 算法 A, B, C 的时间增长趋势

@@ -192,6 +252,36 @@ $$ } ``` +=== "Go" + + ```go title="" + + ``` + +=== "JavaScript" + + ```js title="" + + ``` + +=== "TypeScript" + + ```typescript title="" + + ``` + +=== "C" + + ```c title="" + + ``` + +=== "C#" + + ```csharp title="" + + ``` + $T(n)$ 是个一次函数，说明时间增长趋势是线性的，因此易得时间复杂度是线性阶。 我们将线性阶的时间复杂度记为 $O(n)$ ，这个数学符号被称为「大 $O$ 记号 Big-$O$ Notation」，代表函数 $T(n)$ 的「渐进上界 asymptotic upper bound」。 @@ -296,6 +386,36 @@ $$ print(0) ``` +=== "Go" + + ```go title="" + + ``` + +=== "JavaScript" + + ```js title="" + + ``` + +=== "TypeScript" + + ```typescript title="" + + ``` + +=== "C" + + ```c title="" + + ``` + +=== "C#" + + ```csharp title="" + + ``` + ### 2. 判断渐进上界 **时间复杂度由多项式 $T(n)$ 中最高阶的项来决定**。这是因为在 $n$ 趋于无穷大时，最高阶的项将处于主导作用，其它项的影响都可以被忽略。 @@ -341,7 +461,7 @@ $$ === "Java" - ```java title="" title="time_complexity_types.java" + ```java title="time_complexity_types.java" /* 常数阶 */ int constant(int n) { int count = 0; @@ -377,13 +497,43 @@ $$ return count ``` +=== "Go" + + ```go title="time_complexity_types.go" + + ``` + +=== "JavaScript" + + ```js title="time_complexity_types.js" + + ``` + +=== "TypeScript" + + ```typescript title="time_complexity_types.ts" + + ``` + +=== "C" + + ```c title="time_complexity_types.c" + + ``` + +=== "C#" + + ```csharp title="time_complexity_types.cs" + + ``` + ### 线性阶 $O(n)$ 线性阶的操作数量相对输入数据大小成线性级别增长。线性阶常出现于单层循环。 === "Java" - ```java title="" title="time_complexity_types.java" + ```java title="time_complexity_types.java" /* 线性阶 */ int linear(int n) { int count = 0; @@ -416,6 +566,36 @@ $$ return count ``` +=== "Go" + + ```go title="time_complexity_types.go" + + ``` + +=== "JavaScript" + + ```js title="time_complexity_types.js" + + ``` + +=== "TypeScript" + + ```typescript title="time_complexity_types.ts" + + ``` + +=== "C" + + ```c title="time_complexity_types.c" + + ``` + +=== "C#" + + ```csharp title="time_complexity_types.cs" + + ``` + 「遍历数组」和「遍历链表」等操作，时间复杂度都为 $O(n)$ ，其中 $n$ 为数组或链表的长度。 !!! tip @@ -424,7 +604,7 @@ $$ === "Java" - ```java title="" title="time_complexity_types.java" + ```java title="time_complexity_types.java" /* 线性阶（遍历数组） */ int arrayTraversal(int[] nums) { int count = 0; @@ -462,13 +642,43 @@ $$ return count ``` +=== "Go" + + ```go title="time_complexity_types.go" + + ``` + +=== "JavaScript" + + ```js title="time_complexity_types.js" + + ``` + +=== "TypeScript" + + ```typescript title="time_complexity_types.ts" + + ``` + +=== "C" + + ```c title="time_complexity_types.c" + + ``` + +=== "C#" + + ```csharp title="time_complexity_types.cs" + + ``` + ### 平方阶 $O(n^2)$ 平方阶的操作数量相对输入数据大小成平方级别增长。平方阶常出现于嵌套循环，外层循环和内层循环都为 $O(n)$ ，总体为 $O(n^2)$ 。 === "Java" - ```java title="" title="time_complexity_types.java" + ```java title="time_complexity_types.java" /* 平方阶 */ int quadratic(int n) { int count = 0; @@ -511,6 +721,36 @@ $$ return count ``` +=== "Go" + + ```go title="time_complexity_types.go" + + ``` + +=== "JavaScript" + + ```js title="time_complexity_types.js" + + ``` + +=== "TypeScript" + + ```typescript title="time_complexity_types.ts" + + ``` + +=== "C" + + ```c title="time_complexity_types.c" + + ``` + +=== "C#" + + ```csharp title="time_complexity_types.cs" + + ``` + ![time_complexity_constant_linear_quadratic](time_complexity.assets/time_complexity_constant_linear_quadratic.png)

Fig. 常数阶、线性阶、平方阶的时间复杂度

@@ -523,7 +763,7 @@ $$ === "Java" - ```java title="" title="time_complexity_types.java" + ```java title="time_complexity_types.java" /* 平方阶（冒泡排序） */ int bubbleSort(int[] nums) { int count = 0; // 计数器 @@ -586,6 +826,36 @@ $$ return count ``` +=== "Go" + + ```go title="time_complexity_types.go" + + ``` + +=== "JavaScript" + + ```js title="time_complexity_types.js" + + ``` + +=== "TypeScript" + + ```typescript title="time_complexity_types.ts" + + ``` + +=== "C" + + ```c title="time_complexity_types.c" + + ``` + +=== "C#" + + ```csharp title="time_complexity_types.cs" + + ``` + ### 指数阶 $O(2^n)$ !!! note @@ -596,7 +866,7 @@ $$ === "Java" - ```java title="" title="time_complexity_types.java" + ```java title="time_complexity_types.java" /* 指数阶（循环实现） */ int exponential(int n) { int count = 0, base = 1; @@ -645,6 +915,36 @@ $$ return count ``` +=== "Go" + + ```go title="time_complexity_types.go" + + ``` + +=== "JavaScript" + + ```js title="time_complexity_types.js" + + ``` + +=== "TypeScript" + + ```typescript title="time_complexity_types.ts" + + ``` + +=== "C" + + ```c title="time_complexity_types.c" + + ``` + +=== "C#" + + ```csharp title="time_complexity_types.cs" + + ``` + ![time_complexity_exponential](time_complexity.assets/time_complexity_exponential.png)

Fig. 指数阶的时间复杂度

@@ -653,7 +953,7 @@ $$ === "Java" - ```java title="" title="time_complexity_types.java" + ```java title="time_complexity_types.java" /* 指数阶（递归实现） */ int expRecur(int n) { if (n == 1) return 1; @@ -680,6 +980,36 @@ $$ return exp_recur(n - 1) + exp_recur(n - 1) + 1 ``` +=== "Go" + + ```go title="time_complexity_types.go" + + ``` + +=== "JavaScript" + + ```js title="time_complexity_types.js" + + ``` + +=== "TypeScript" + + ```typescript title="time_complexity_types.ts" + + ``` + +=== "C" + + ```c title="time_complexity_types.c" + + ``` + +=== "C#" + + ```csharp title="time_complexity_types.cs" + + ``` + ### 对数阶 $O(\log n)$ 对数阶与指数阶正好相反，后者反映 “每轮增加到两倍的情况” ，而前者反映 “每轮缩减到一半的情况” 。对数阶仅次于常数阶，时间增长的很慢，是理想的时间复杂度。 @@ -690,7 +1020,7 @@ $$ === "Java" - ```java title="" title="time_complexity_types.java" + ```java title="time_complexity_types.java" /* 对数阶（循环实现） */ int logarithmic(float n) { int count = 0; @@ -728,6 +1058,36 @@ $$ return count ``` +=== "Go" + + ```go title="time_complexity_types.go" + + ``` + +=== "JavaScript" + + ```js title="time_complexity_types.js" + + ``` + +=== "TypeScript" + + ```typescript title="time_complexity_types.ts" + + ``` + +=== "C" + + ```c title="time_complexity_types.c" + + ``` + +=== "C#" + + ```csharp title="time_complexity_types.cs" + + ``` + ![time_complexity_logarithmic](time_complexity.assets/time_complexity_logarithmic.png)

Fig. 对数阶的时间复杂度

@@ -736,7 +1096,7 @@ $$ === "Java" - ```java title="" title="time_complexity_types.java" + ```java title="time_complexity_types.java" /* 对数阶（递归实现） */ int logRecur(float n) { if (n <= 1) return 0; @@ -763,6 +1123,36 @@ $$ return log_recur(n / 2) + 1 ``` +=== "Go" + + ```go title="time_complexity_types.go" + + ``` + +=== "JavaScript" + + ```js title="time_complexity_types.js" + + ``` + +=== "TypeScript" + + ```typescript title="time_complexity_types.ts" + + ``` + +=== "C" + + ```c title="time_complexity_types.c" + + ``` + +=== "C#" + + ```csharp title="time_complexity_types.cs" + + ``` + ### 线性对数阶 $O(n \log n)$ 线性对数阶常出现于嵌套循环中，两层循环的时间复杂度分别为 $O(\log n)$ 和 $O(n)$ 。 @@ -771,7 +1161,7 @@ $$ === "Java" - ```java title="" title="time_complexity_types.java" + ```java title="time_complexity_types.java" /* 线性对数阶 */ int linearLogRecur(float n) { if (n <= 1) return 1; @@ -812,6 +1202,36 @@ $$ return count ``` +=== "Go" + + ```go title="time_complexity_types.go" + + ``` + +=== "JavaScript" + + ```js title="time_complexity_types.js" + + ``` + +=== "TypeScript" + + ```typescript title="time_complexity_types.ts" + + ``` + +=== "C" + + ```c title="time_complexity_types.c" + + ``` + +=== "C#" + + ```csharp title="time_complexity_types.cs" + + ``` + ![time_complexity_logarithmic_linear](time_complexity.assets/time_complexity_logarithmic_linear.png)

Fig. 线性对数阶的时间复杂度

@@ -828,7 +1248,7 @@ $$ === "Java" - ```java title="" title="time_complexity_types.java" + ```java title="time_complexity_types.java" /* 阶乘阶（递归实现） */ int factorialRecur(int n) { if (n == 0) return 1; @@ -869,6 +1289,36 @@ $$ return count ``` +=== "Go" + + ```go title="time_complexity_types.go" + + ``` + +=== "JavaScript" + + ```js title="time_complexity_types.js" + + ``` + +=== "TypeScript" + + ```typescript title="time_complexity_types.ts" + + ``` + +=== "C" + + ```c title="time_complexity_types.c" + + ``` + +=== "C#" + + ```csharp title="time_complexity_types.cs" + + ``` + ![time_complexity_factorial](time_complexity.assets/time_complexity_factorial.png)

Fig. 阶乘阶的时间复杂度

@@ -884,7 +1334,7 @@ $$ === "Java" - ```java title="" title="worst_best_time_complexity.java" + ```java title="worst_best_time_complexity.java" public class worst_best_time_complexity { /* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */ static int[] randomNumbers(int n) { @@ -994,6 +1444,36 @@ $$ print("数字 1 的索引为", index) ``` +=== "Go" + + ```go title="worst_best_time_complexity.go" + + ``` + +=== "JavaScript" + + ```js title="worst_best_time_complexity.js" + + ``` + +=== "TypeScript" + + ```typescript title="worst_best_time_complexity.ts" + + ``` + +=== "C" + + ```c title="worst_best_time_complexity.c" + + ``` + +=== "C#" + + ```csharp title="worst_best_time_complexity.cs" + + ``` + !!! tip 我们在实际应用中很少使用「最佳时间复杂度」，因为往往只有很小概率下才能达到，会带来一定的误导性。反之，「最差时间复杂度」最为实用，因为它给出了一个 “效率安全值” ，让我们可以放心地使用算法。 diff --git a/docs/chapter_data_structure/data_and_memory.md b/docs/chapter_data_structure/data_and_memory.md index 5e7da3902..198df88c3 100644 --- a/docs/chapter_data_structure/data_and_memory.md +++ b/docs/chapter_data_structure/data_and_memory.md @@ -46,7 +46,7 @@ comments: true === "Java" - ```java + ```java title="" /* 使用多种「基本数据类型」来初始化「数组」 */ int[] numbers = new int[5]; float[] decimals = new float[5]; @@ -66,6 +66,36 @@ comments: true ``` +=== "Go" + + ```go title="" + + ``` + +=== "JavaScript" + + ```js title="" + + ``` + +=== "TypeScript" + + ```typescript title="" + + ``` + +=== "C" + + ```c title="" + + ``` + +=== "C#" + + ```csharp title="" + + ``` + ## 计算机内存 在计算机中，内存和硬盘是两种主要的存储硬件设备。「硬盘」主要用于长期存储数据，容量较大（通常可达到 TB 级别）、速度较慢。「内存」用于运行程序时暂存数据，速度更快，但容量较小（通常为 GB 级别）。 diff --git a/docs/chapter_searching/binary_search.md b/docs/chapter_searching/binary_search.md index 59b7598bc..bd3b109b0 100644 --- a/docs/chapter_searching/binary_search.md +++ b/docs/chapter_searching/binary_search.md @@ -102,6 +102,42 @@ $$ } ``` +=== "Python" + + ```python title="binary_search.py" + + ``` + +=== "Go" + + ```go title="binary_search.go" + + ``` + +=== "JavaScript" + + ```js title="binary_search.js" + + ``` + +=== "TypeScript" + + ```typescript title="binary_search.ts" + + ``` + +=== "C" + + ```c title="binary_search.c" + + ``` + +=== "C#" + + ```csharp title="binary_search.cs" + + ``` + ### “左闭右开” 实现 当然，我们也可以使用 “左闭右开” 的表示方法，写出相同功能的二分查找代码。 @@ -150,6 +186,42 @@ $$ } ``` +=== "Python" + + ```python title="binary_search.py" + + ``` + +=== "Go" + + ```go title="binary_search.go" + + ``` + +=== "JavaScript" + + ```js title="binary_search.js" + + ``` + +=== "TypeScript" + + ```typescript title="binary_search.ts" + + ``` + +=== "C" + + ```c title="binary_search.c" + + ``` + +=== "C#" + + ```csharp title="binary_search.cs" + + ``` + ### 两种表示对比 对比下来，两种表示的代码写法有以下不同点： @@ -171,15 +243,16 @@ $$ === "Java" - ```java + ```java title="" // (i + j) 有可能超出 int 的取值范围 int m = (i + j) / 2; // 更换为此写法则不会越界 int m = i + (j - i) / 2; ``` + === "C++" - ```cpp + ```cpp title="" // (i + j) 有可能超出 int 的取值范围 int m = (i + j) / 2; // 更换为此写法则不会越界 @@ -188,11 +261,41 @@ $$ === "Python" - ```py + ```py title="" # Python 中的数字理论上可以无限大（取决于内存） # 因此无需考虑大数越界问题 ``` +=== "Go" + + ```go title="" + + ``` + +=== "JavaScript" + + ```js title="" + + ``` + +=== "TypeScript" + + ```typescript title="" + + ``` + +=== "C" + + ```c title="" + + ``` + +=== "C#" + + ```csharp title="" + + ``` + ## 复杂度分析 **时间复杂度 $O(\log n)$ ：** 其中 $n$ 为数组或链表长度；每轮排除一半的区间，因此循环轮数为 $\log_2 n$ ，使用 $O(\log n)$ 时间。 diff --git a/docs/chapter_searching/hashing_search.md b/docs/chapter_searching/hashing_search.md index ce5132cda..f269c4efa 100644 --- a/docs/chapter_searching/hashing_search.md +++ b/docs/chapter_searching/hashing_search.md @@ -40,6 +40,42 @@ comments: true } ``` +=== "Python" + + ```python title="hashing_search.py" + + ``` + +=== "Go" + + ```go title="hashing_search.go" + + ``` + +=== "JavaScript" + + ```js title="hashing_search.js" + + ``` + +=== "TypeScript" + + ```typescript title="hashing_search.ts" + + ``` + +=== "C" + + ```c title="hashing_search.c" + + ``` + +=== "C#" + + ```csharp title="hashing_search.cs" + + ``` + 再比如，如果我们想要给定一个目标结点值 `target` ，获取对应的链表结点对象，那么也可以使用哈希查找实现。 ![hash_search_listnode](hashing_search.assets/hash_search_listnode.png) @@ -68,6 +104,42 @@ comments: true } ``` +=== "Python" + + ```python title="hashing_search.py" + + ``` + +=== "Go" + + ```go title="hashing_search.go" + + ``` + +=== "JavaScript" + + ```js title="hashing_search.js" + + ``` + +=== "TypeScript" + + ```typescript title="hashing_search.ts" + + ``` + +=== "C" + + ```c title="hashing_search.c" + + ``` + +=== "C#" + + ```csharp title="hashing_search.cs" + + ``` + ## 复杂度分析 **时间复杂度：** $O(1)$ ，哈希表的查找操作使用 $O(1)$ 时间。 diff --git a/docs/chapter_searching/linear_search.md b/docs/chapter_searching/linear_search.md index 5186d1917..ba3024875 100644 --- a/docs/chapter_searching/linear_search.md +++ b/docs/chapter_searching/linear_search.md @@ -44,6 +44,42 @@ comments: true } ``` +=== "Python" + + ```python title="linear_search.py" + + ``` + +=== "Go" + + ```go title="linear_search.go" + + ``` + +=== "JavaScript" + + ```js title="linear_search.js" + + ``` + +=== "TypeScript" + + ```typescript title="linear_search.ts" + + ``` + +=== "C" + + ```c title="linear_search.c" + + ``` + +=== "C#" + + ```csharp title="linear_search.cs" + + ``` + 再比如，我们想要在给定一个目标结点值 `target` ，返回此结点对象，也可以在链表中进行线性查找。 === "Java" @@ -80,6 +116,42 @@ comments: true } ``` +=== "Python" + + ```python title="linear_search.py" + + ``` + +=== "Go" + + ```go title="linear_search.go" + + ``` + +=== "JavaScript" + + ```js title="linear_search.js" + + ``` + +=== "TypeScript" + + ```typescript title="linear_search.ts" + + ``` + +=== "C" + + ```c title="linear_search.c" + + ``` + +=== "C#" + + ```csharp title="linear_search.cs" + + ``` + ## 复杂度分析 **时间复杂度 $O(n)$ ：** 其中 $n$ 为数组或链表长度。 diff --git a/docs/chapter_searching/summary.md b/docs/chapter_searching/summary.md index 6d2fb0b3f..066d09af5 100644 --- a/docs/chapter_searching/summary.md +++ b/docs/chapter_searching/summary.md @@ -1,3 +1,7 @@ +--- +comments: true +--- + # 小结 - 线性查找是一种最基础的查找方法，通过遍历数据结构 + 判断条件实现查找。 diff --git a/docs/chapter_sorting/bubble_sort.md b/docs/chapter_sorting/bubble_sort.md index fe1d07140..05ef478b0 100644 --- a/docs/chapter_sorting/bubble_sort.md +++ b/docs/chapter_sorting/bubble_sort.md @@ -74,26 +74,6 @@ comments: true } ``` -=== "JavaScript" - - ```js title="bubble_sort.js" - /* 冒泡排序 */ - function bubbleSort(nums) { - // 外循环：待排序元素数量为 n-1, n-2, ..., 1 - for (let i = nums.length - 1; i > 0; i--) { - // 内循环：冒泡操作 - for (let j = 0; j < i; j++) { - if (nums[j] > nums[j + 1]) { - // 交换 nums[j] 与 nums[j + 1] - let tmp = nums[j]; - nums[j] = nums[j + 1]; - nums[j + 1] = tmp; - } - } - } - } - ``` - === "C++" ```cpp title="bubble_sort.cpp" @@ -129,6 +109,50 @@ comments: true nums[j], nums[j + 1] = nums[j + 1], nums[j] ``` +=== "Go" + + ```go title="bubble_sort.go" + + ``` + +=== "JavaScript" + + ```js title="bubble_sort.js" + /* 冒泡排序 */ + function bubbleSort(nums) { + // 外循环：待排序元素数量为 n-1, n-2, ..., 1 + for (let i = nums.length - 1; i > 0; i--) { + // 内循环：冒泡操作 + for (let j = 0; j < i; j++) { + if (nums[j] > nums[j + 1]) { + // 交换 nums[j] 与 nums[j + 1] + let tmp = nums[j]; + nums[j] = nums[j + 1]; + nums[j + 1] = tmp; + } + } + } + } + ``` + +=== "TypeScript" + + ```typescript title="bubble_sort.ts" + + ``` + +=== "C" + + ```c title="bubble_sort.c" + + ``` + +=== "C#" + + ```csharp title="bubble_sort.cs" + + ``` + ## 算法特性 **时间复杂度 $O(n^2)$ ：** 各轮「冒泡」遍历的数组长度为 $n - 1$ , $n - 2$ , $\cdots$ , $2$ , $1$ 次，求和为 $\frac{(n - 1) n}{2}$ ，因此使用 $O(n^2)$ 时间。 @@ -170,29 +194,6 @@ comments: true } ``` -=== "JavaScript" - - ```js title="bubble_sort.js" - /* 冒泡排序（标志优化）*/ - function bubbleSortWithFlag(nums) { - // 外循环：待排序元素数量为 n-1, n-2, ..., 1 - for (let i = nums.length - 1; i > 0; i--) { - let flag = false; // 初始化标志位 - // 内循环：冒泡操作 - for (let j = 0; j < i; j++) { - if (nums[j] > nums[j + 1]) { - // 交换 nums[j] 与 nums[j + 1] - let tmp = nums[j]; - nums[j] = nums[j + 1]; - nums[j + 1] = tmp; - flag = true; // 记录交换元素 - } - } - if (!flag) break; // 此轮冒泡未交换任何元素，直接跳出 - } - } - ``` - === "C++" ```cpp title="bubble_sort.cpp" @@ -234,3 +235,50 @@ comments: true if not flag: break # 此轮冒泡未交换任何元素，直接跳出 ``` + +=== "Go" + + ```go title="bubble_sort.go" + + ``` + +=== "JavaScript" + + ```js title="bubble_sort.js" + /* 冒泡排序（标志优化）*/ + function bubbleSortWithFlag(nums) { + // 外循环：待排序元素数量为 n-1, n-2, ..., 1 + for (let i = nums.length - 1; i > 0; i--) { + let flag = false; // 初始化标志位 + // 内循环：冒泡操作 + for (let j = 0; j < i; j++) { + if (nums[j] > nums[j + 1]) { + // 交换 nums[j] 与 nums[j + 1] + let tmp = nums[j]; + nums[j] = nums[j + 1]; + nums[j + 1] = tmp; + flag = true; // 记录交换元素 + } + } + if (!flag) break; // 此轮冒泡未交换任何元素，直接跳出 + } + } + ``` + +=== "TypeScript" + + ```typescript title="bubble_sort.ts" + + ``` + +=== "C" + + ```c title="bubble_sort.c" + + ``` + +=== "C#" + + ```csharp title="bubble_sort.cs" + + ``` diff --git a/docs/chapter_sorting/insertion_sort.md b/docs/chapter_sorting/insertion_sort.md index e220c2e0e..86debc625 100644 --- a/docs/chapter_sorting/insertion_sort.md +++ b/docs/chapter_sorting/insertion_sort.md @@ -42,24 +42,6 @@ comments: true } ``` -=== "JavaScript" - - ```js title="insertion_sort.js" - /* 插入排序 */ - function insertionSort(nums) { - // 外循环：base = nums[1], nums[2], ..., nums[n-1] - for (let i = 1; i < nums.length; i++) { - let base = nums[i], j = i - 1; - // 内循环：将 base 插入到左边的正确位置 - while (j >= 0 && nums[j] > base) { - nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位 - j--; - } - nums[j + 1] = base; // 2. 将 base 赋值到正确位置 - } - } - ``` - === "C++" ```cpp title="insertion_sort.cpp" @@ -94,6 +76,48 @@ comments: true nums[j + 1] = base # 2. 将 base 赋值到正确位置 ``` +=== "Go" + + ```go title="insertion_sort.go" + + ``` + +=== "JavaScript" + + ```js title="insertion_sort.js" + /* 插入排序 */ + function insertionSort(nums) { + // 外循环：base = nums[1], nums[2], ..., nums[n-1] + for (let i = 1; i < nums.length; i++) { + let base = nums[i], j = i - 1; + // 内循环：将 base 插入到左边的正确位置 + while (j >= 0 && nums[j] > base) { + nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位 + j--; + } + nums[j + 1] = base; // 2. 将 base 赋值到正确位置 + } + } + ``` + +=== "TypeScript" + + ```typescript title="insertion_sort.ts" + + ``` + +=== "C" + + ```c title="insertion_sort.c" + + ``` + +=== "C#" + + ```csharp title="insertion_sort.cs" + + ``` + ## 算法特性 **时间复杂度 $O(n^2)$ ：** 最差情况下，各轮插入操作循环 $n - 1$ , $n-2$ , $\cdots$ , $2$ , $1$ 次，求和为 $\frac{(n - 1) n}{2}$ ，使用 $O(n^2)$ 时间。 diff --git a/docs/chapter_sorting/merge_sort.md b/docs/chapter_sorting/merge_sort.md index 58a48c25c..64942f667 100644 --- a/docs/chapter_sorting/merge_sort.md +++ b/docs/chapter_sorting/merge_sort.md @@ -103,51 +103,6 @@ comments: true } ``` -=== "JavaScript" - - ```js title="merge_sort.js" - /** - * 合并左子数组和右子数组 - * 左子数组区间 [left, mid] - * 右子数组区间 [mid + 1, right] - */ - function merge(nums, left, mid, right) { - // 初始化辅助数组 - let tmp = nums.slice(left, right + 1); - // 左子数组的起始索引和结束索引 - let leftStart = left - left, leftEnd = mid - left; - // 右子数组的起始索引和结束索引 - let rightStart = mid + 1 - left, rightEnd = right - left; - // i, j 分别指向左子数组、右子数组的首元素 - let i = leftStart, j = rightStart; - // 通过覆盖原数组 nums 来合并左子数组和右子数组 - for (let k = left; k <= right; k++) { - // 若 “左子数组已全部合并完”，则选取右子数组元素，并且 j++ - if (i > leftEnd) { - nums[k] = tmp[j++]; - // 否则，若 “右子数组已全部合并完” 或 “左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++ - } else if (j > rightEnd || tmp[i] <= tmp[j]) { - nums[k] = tmp[i++]; - // 否则，若 “左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++ - } else { - nums[k] = tmp[j++]; - } - } - } - - /* 归并排序 */ - function mergeSort(nums, left, right) { - // 终止条件 - if (left >= right) return; // 当子数组长度为 1 时终止递归 - // 划分阶段 - let mid = Math.floor((left + right) / 2); // 计算中点 - mergeSort(nums, left, mid); // 递归左子数组 - mergeSort(nums, mid + 1, right); // 递归右子数组 - // 合并阶段 - merge(nums, left, mid, right); - } - ``` - === "C++" ```cpp title="merge_sort.cpp" @@ -237,6 +192,75 @@ comments: true merge(nums, left, mid, right) ``` +=== "Go" + + ```go title="merge_sort.go" + + ``` + +=== "JavaScript" + + ```js title="merge_sort.js" + /** + * 合并左子数组和右子数组 + * 左子数组区间 [left, mid] + * 右子数组区间 [mid + 1, right] + */ + function merge(nums, left, mid, right) { + // 初始化辅助数组 + let tmp = nums.slice(left, right + 1); + // 左子数组的起始索引和结束索引 + let leftStart = left - left, leftEnd = mid - left; + // 右子数组的起始索引和结束索引 + let rightStart = mid + 1 - left, rightEnd = right - left; + // i, j 分别指向左子数组、右子数组的首元素 + let i = leftStart, j = rightStart; + // 通过覆盖原数组 nums 来合并左子数组和右子数组 + for (let k = left; k <= right; k++) { + // 若 “左子数组已全部合并完”，则选取右子数组元素，并且 j++ + if (i > leftEnd) { + nums[k] = tmp[j++]; + // 否则，若 “右子数组已全部合并完” 或 “左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++ + } else if (j > rightEnd || tmp[i] <= tmp[j]) { + nums[k] = tmp[i++]; + // 否则，若 “左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++ + } else { + nums[k] = tmp[j++]; + } + } + } + + /* 归并排序 */ + function mergeSort(nums, left, right) { + // 终止条件 + if (left >= right) return; // 当子数组长度为 1 时终止递归 + // 划分阶段 + let mid = Math.floor((left + right) / 2); // 计算中点 + mergeSort(nums, left, mid); // 递归左子数组 + mergeSort(nums, mid + 1, right); // 递归右子数组 + // 合并阶段 + merge(nums, left, mid, right); + } + ``` + +=== "TypeScript" + + ```typescript title="merge_sort.ts" + + ``` + +=== "C" + + ```c title="merge_sort.c" + + ``` + +=== "C#" + + ```csharp title="merge_sort.cs" + + ``` + 下面重点解释一下合并方法 `merge()` 的流程： 1. 初始化一个辅助数组 `tmp` 暂存待合并区间 `[left, right]` 内的元素，后续通过覆盖原数组 `nums` 的元素来实现合并； diff --git a/docs/chapter_sorting/quick_sort.md b/docs/chapter_sorting/quick_sort.md index a0df18e7b..7934b595a 100644 --- a/docs/chapter_sorting/quick_sort.md +++ b/docs/chapter_sorting/quick_sort.md @@ -61,35 +61,6 @@ comments: true } ``` -=== "JavaScript" - - ``` js title="quick_sort.js" - /* 元素交换 */ - function swap(nums, i, j) { - let tmp = nums[i] - nums[i] = nums[j] - nums[j] = tmp - } - - /* 哨兵划分 */ - function partition(nums, left, right){ - // 以 nums[left] 作为基准数 - let i = left, j = right - while(i < j){ - while(i < j && nums[j] >= nums[left]){ - j -= 1 // 从右向左找首个小于基准数的元素 - } - while(i < j && nums[i] <= nums[left]){ - i += 1 // 从左向右找首个大于基准数的元素 - } - // 元素交换 - swap(nums, i, j) // 交换这两个元素 - } - swap(nums, i, left) // 将基准数交换至两子数组的分界线 - return i // 返回基准数的索引 - } - ``` - === "C++" ```cpp title="quick_sort.cpp" @@ -135,6 +106,59 @@ comments: true return i # 返回基准数的索引 ``` +=== "Go" + + ```go title="quick_sort.go" + + ``` + +=== "JavaScript" + + ``` js title="quick_sort.js" + /* 元素交换 */ + function swap(nums, i, j) { + let tmp = nums[i] + nums[i] = nums[j] + nums[j] = tmp + } + + /* 哨兵划分 */ + function partition(nums, left, right){ + // 以 nums[left] 作为基准数 + let i = left, j = right + while(i < j){ + while(i < j && nums[j] >= nums[left]){ + j -= 1 // 从右向左找首个小于基准数的元素 + } + while(i < j && nums[i] <= nums[left]){ + i += 1 // 从左向右找首个大于基准数的元素 + } + // 元素交换 + swap(nums, i, j) // 交换这两个元素 + } + swap(nums, i, left) // 将基准数交换至两子数组的分界线 + return i // 返回基准数的索引 + } + ``` + +=== "TypeScript" + + ```typescript title="quick_sort.ts" + + ``` + +=== "C" + + ```c title="quick_sort.c" + + ``` + +=== "C#" + + ```csharp title="quick_sort.cs" + + ``` + !!! note "快速排序的分治思想" 哨兵划分的实质是将 **一个长数组的排序问题** 简化为 **两个短数组的排序问题**。 @@ -167,21 +191,6 @@ comments: true } ``` -=== "JavaScript" - - ```js title="quick_sort.js" - /* 快速排序 */ - function quickSort(nums, left, right){ - // 子数组长度为 1 时终止递归 - if(left >= right) return - // 哨兵划分 - const pivot = partition(nums, left, right) - // 递归左子数组、右子数组 - quick_sort(nums, left, pivot - 1) - quick_sort(nums, pivot + 1, right) - } - ``` - === "C++" ```cpp title="quick_sort.cpp" @@ -213,6 +222,45 @@ comments: true self.quick_sort(nums, pivot + 1, right) ``` +=== "Go" + + ```go title="quick_sort.go" + + ``` + +=== "JavaScript" + + ```js title="quick_sort.js" + /* 快速排序 */ + function quickSort(nums, left, right){ + // 子数组长度为 1 时终止递归 + if(left >= right) return + // 哨兵划分 + const pivot = partition(nums, left, right) + // 递归左子数组、右子数组 + quick_sort(nums, left, pivot - 1) + quick_sort(nums, pivot + 1, right) + } + ``` + +=== "TypeScript" + + ```typescript title="quick_sort.ts" + + ``` + +=== "C" + + ```c title="quick_sort.c" + + ``` + +=== "C#" + + ```csharp title="quick_sort.cs" + + ``` + ## 算法特性 **平均时间复杂度 $O(n \log n)$ ：** 平均情况下，哨兵划分的递归层数为 $\log n$ ，每层中的总循环数为 $n$ ，总体使用 $O(n \log n)$ 时间。 @@ -269,32 +317,6 @@ comments: true } ``` -=== "JavaScript" - - ```js title="quick_sort.js" - /* 选取三个元素的中位数 */ - function medianThree(nums, left, mid, right) { - // 使用了异或操作来简化代码 - // 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1 - if ((nums[left] > nums[mid]) ^ (nums[left] > nums[right])) - return left; - else if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right])) - return mid; - else - return right; - } - - /* 哨兵划分（三数取中值） */ - function partition(nums, left, right) { - // 选取三个候选元素的中位数 - let med = medianThree(nums, left, Math.floor((left + right) / 2), right); - // 将中位数交换至数组最左端 - swap(nums, left, med); - // 以 nums[left] 作为基准数 - // 下同省略... - } - ``` - === "C++" ```cpp title="quick_sort.cpp" @@ -344,6 +366,56 @@ comments: true # 下同省略... ``` +=== "Go" + + ```go title="quick_sort.go" + + ``` + +=== "JavaScript" + + ```js title="quick_sort.js" + /* 选取三个元素的中位数 */ + function medianThree(nums, left, mid, right) { + // 使用了异或操作来简化代码 + // 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1 + if ((nums[left] > nums[mid]) ^ (nums[left] > nums[right])) + return left; + else if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right])) + return mid; + else + return right; + } + + /* 哨兵划分（三数取中值） */ + function partition(nums, left, right) { + // 选取三个候选元素的中位数 + let med = medianThree(nums, left, Math.floor((left + right) / 2), right); + // 将中位数交换至数组最左端 + swap(nums, left, med); + // 以 nums[left] 作为基准数 + // 下同省略... + } + ``` + +=== "TypeScript" + + ```typescript title="quick_sort.ts" + + ``` + +=== "C" + + ```c title="quick_sort.c" + + ``` + +=== "C#" + + ```csharp title="quick_sort.cs" + + ``` + ## 尾递归优化 **普通快速排序在某些输入下的空间效率变差。** 仍然以完全倒序的输入数组为例，由于每轮哨兵划分后右子数组长度为 0 ，那么将形成一个高度为 $n - 1$ 的递归树，此时使用的栈帧空间大小劣化至 $O(n)$ 。 @@ -371,27 +443,6 @@ comments: true } ``` -=== "JavaScript" - - ```js title="quick_sort.js" - /* 快速排序（尾递归优化） */ - quickSort(nums, left, right) { - // 子数组长度为 1 时终止 - while (left < right) { - // 哨兵划分操作 - let pivot = partition(nums, left, right); - // 对两个子数组中较短的那个执行快排 - if (pivot - left < right - pivot) { - quickSort(nums, left, pivot - 1); // 递归排序左子数组 - left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right] - } else { - quickSort(nums, pivot + 1, right); // 递归排序右子数组 - right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1] - } - } - } - ``` - === "C++" ```cpp title="quick_sort.cpp" @@ -430,3 +481,48 @@ comments: true self.quick_sort(nums, pivot + 1, right) # 递归排序右子数组 right = pivot - 1 # 剩余待排序区间为 [left, pivot - 1] ``` + +=== "Go" + + ```go title="quick_sort.go" + + ``` + +=== "JavaScript" + + ```js title="quick_sort.js" + /* 快速排序（尾递归优化） */ + quickSort(nums, left, right) { + // 子数组长度为 1 时终止 + while (left < right) { + // 哨兵划分操作 + let pivot = partition(nums, left, right); + // 对两个子数组中较短的那个执行快排 + if (pivot - left < right - pivot) { + quickSort(nums, left, pivot - 1); // 递归排序左子数组 + left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right] + } else { + quickSort(nums, pivot + 1, right); // 递归排序右子数组 + right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1] + } + } + } + ``` + +=== "TypeScript" + + ```typescript title="quick_sort.ts" + + ``` + +=== "C" + + ```c title="quick_sort.c" + + ``` + +=== "C#" + + ```csharp title="quick_sort.cs" + + ``` diff --git a/docs/chapter_stack_and_queue/deque.md b/docs/chapter_stack_and_queue/deque.md index f9b45eca2..2ed2f289a 100644 --- a/docs/chapter_stack_and_queue/deque.md +++ b/docs/chapter_stack_and_queue/deque.md @@ -116,3 +116,33 @@ comments: true """ 判断双向队列是否为空 """ is_empty = len(duque) == 0 ``` + +=== "Go" + + ```go title="deque.go" + + ``` + +=== "JavaScript" + + ```js title="deque.js" + + ``` + +=== "TypeScript" + + ```typescript title="deque.ts" + + ``` + +=== "C" + + ```c title="deque.c" + + ``` + +=== "C#" + + ```csharp title="deque.cs" + + ``` diff --git a/docs/chapter_stack_and_queue/queue.md b/docs/chapter_stack_and_queue/queue.md index 825b58ed6..f443f21f0 100644 --- a/docs/chapter_stack_and_queue/queue.md +++ b/docs/chapter_stack_and_queue/queue.md @@ -112,6 +112,36 @@ comments: true is_empty = len(que) == 0 ``` +=== "Go" + + ```go title="queue.go" + + ``` + +=== "JavaScript" + + ```js title="queue.js" + + ``` + +=== "TypeScript" + + ```typescript title="queue.ts" + + ``` + +=== "C" + + ```c title="queue.c" + + ``` + +=== "C#" + + ```csharp title="queue.cs" + + ``` + ## 队列实现 队列需要一种可以在一端添加，并在另一端删除的数据结构，也可以使用链表或数组来实现。 @@ -276,6 +306,36 @@ comments: true return self.__front.val ``` +=== "Go" + + ```go title="linkedlist_queue.go" + + ``` + +=== "JavaScript" + + ```js title="linkedlist_queue.js" + + ``` + +=== "TypeScript" + + ```typescript title="linkedlist_queue.ts" + + ``` + +=== "C" + + ```c title="linkedlist_queue.c" + + ``` + +=== "C#" + + ```csharp title="linkedlist_queue.cs" + + ``` + ### 基于数组的实现 数组的删除首元素的时间复杂度为 $O(n)$ ，因此不适合直接用来实现队列。然而，我们可以借助两个指针 `front` , `rear` 来分别记录队首和队尾的索引位置，在入队 / 出队时分别将 `front` / `rear` 向后移动一位即可，这样每次仅需操作一个元素，时间复杂度降至 $O(1)$ 。 @@ -477,6 +537,36 @@ comments: true return res ``` +=== "Go" + + ```go title="array_queue.go" + + ``` + +=== "JavaScript" + + ```js title="array_queue.js" + + ``` + +=== "TypeScript" + + ```typescript title="array_queue.ts" + + ``` + +=== "C" + + ```c title="array_queue.c" + + ``` + +=== "C#" + + ```csharp title="array_queue.cs" + + ``` + ## 队列典型应用 - **淘宝订单。** 购物者下单后，订单就被加入到队列之中，随后系统再根据顺序依次处理队列中的订单。在双十一时，在短时间内会产生海量的订单，如何处理「高并发」则是工程师们需要重点思考的问题。 diff --git a/docs/chapter_stack_and_queue/stack.md b/docs/chapter_stack_and_queue/stack.md index 9991c51e3..c2a1ad14d 100644 --- a/docs/chapter_stack_and_queue/stack.md +++ b/docs/chapter_stack_and_queue/stack.md @@ -112,6 +112,36 @@ comments: true is_empty = len(stack) == 0 ``` +=== "Go" + + ```go title="stack.go" + + ``` + +=== "JavaScript" + + ```js title="stack.js" + + ``` + +=== "TypeScript" + + ```typescript title="stack.ts" + + ``` + +=== "C" + + ```c title="stack.c" + + ``` + +=== "C#" + + ```csharp title="stack.cs" + + ``` + ## 栈的实现 为了更加清晰地了解栈的运行机制，接下来我们来自己动手实现一个栈类。 @@ -249,6 +279,36 @@ comments: true return self.__peek.val ``` +=== "Go" + + ```go title="linkedlist_stack.go" + + ``` + +=== "JavaScript" + + ```js title="linkedlist_stack.js" + + ``` + +=== "TypeScript" + + ```typescript title="linkedlist_stack.ts" + + ``` + +=== "C" + + ```c title="linkedlist_stack.c" + + ``` + +=== "C#" + + ```csharp title="linkedlist_stack.cs" + + ``` + ### 基于数组的实现 使用「数组」实现栈时，将数组的尾部当作栈顶。准确地说，我们需要使用「列表」，因为入栈的元素可能是源源不断的，因此使用动态数组可以方便扩容。 @@ -363,6 +423,36 @@ comments: true return self.__stack[index] ``` +=== "Go" + + ```go title="array_stack.go" + + ``` + +=== "JavaScript" + + ```js title="array_stack.js" + + ``` + +=== "TypeScript" + + ```typescript title="array_stack.ts" + + ``` + +=== "C" + + ```c title="array_stack.c" + + ``` + +=== "C#" + + ```csharp title="array_stack.cs" + + ``` + !!! tip 实际编程中，我们一般直接将 `ArrayList` 或 `LinkedList` 当作「栈」来使用。我们仅需通过脑补来屏蔽无关操作，而不用专门去包装它。 diff --git a/docs/chapter_tree/binary_search_tree.md b/docs/chapter_tree/binary_search_tree.md index 8b0f9ba0d..a1554e96d 100644 --- a/docs/chapter_tree/binary_search_tree.md +++ b/docs/chapter_tree/binary_search_tree.md @@ -91,6 +91,30 @@ comments: true ``` +=== "JavaScript" + + ```js title="binary_search_tree.js" + + ``` + +=== "TypeScript" + + ```typescript title="binary_search_tree.ts" + + ``` + +=== "C" + + ```c title="binary_search_tree.c" + + ``` + +=== "C#" + + ```csharp title="binary_search_tree.cs" + + ``` + ### 插入结点 给定一个待插入元素 `num` ，为了保持二叉搜索树 “左子树 < 根结点 < 右子树” 的性质，插入操作分为两步： @@ -166,6 +190,30 @@ comments: true ``` +=== "JavaScript" + + ```js title="binary_search_tree.js" + + ``` + +=== "TypeScript" + + ```typescript title="binary_search_tree.ts" + + ``` + +=== "C" + + ```c title="binary_search_tree.c" + + ``` + +=== "C#" + + ```csharp title="binary_search_tree.cs" + + ``` + 为了插入结点，需要借助 **辅助结点 `prev`** 保存上一轮循环的结点，这样在遍历到 $\text{null}$ 时，我们也可以获取到其父结点，从而完成结点插入操作。 与查找结点相同，插入结点使用 $O(\log n)$ 时间。 @@ -320,6 +368,30 @@ comments: true ``` +=== "JavaScript" + + ```js title="binary_search_tree.js" + + ``` + +=== "TypeScript" + + ```typescript title="binary_search_tree.ts" + + ``` + +=== "C" + + ```c title="binary_search_tree.c" + + ``` + +=== "C#" + + ```csharp title="binary_search_tree.cs" + + ``` + ## 二叉搜索树的优势 假设给定 $n$ 个数字，最常用的存储方式是「数组」，那么对于这串乱序的数字，常见操作的效率为： diff --git a/docs/chapter_tree/binary_tree.md b/docs/chapter_tree/binary_tree.md index 58034b18e..2fd44c3cc 100644 --- a/docs/chapter_tree/binary_tree.md +++ b/docs/chapter_tree/binary_tree.md @@ -8,7 +8,7 @@ comments: true === "Java" - ```java + ```java title="" /* 链表结点类 */ class TreeNode { int val; // 结点值 @@ -20,7 +20,7 @@ comments: true === "C++" - ```cpp + ```cpp title="" /* 链表结点结构体 */ struct TreeNode { int val; // 结点值 @@ -32,7 +32,7 @@ comments: true === "Python" - ```python + ```python title="" """ 链表结点类 """ class TreeNode: def __init__(self, val=0, left=None, right=None): @@ -43,7 +43,31 @@ comments: true === "Go" - ```go + ```go title="" + + ``` + +=== "JavaScript" + + ```js title="" + + ``` + +=== "TypeScript" + + ```typescript title="" + + ``` + +=== "C" + + ```c title="" + + ``` + +=== "C#" + + ```csharp title="" ``` @@ -142,6 +166,30 @@ comments: true ``` +=== "JavaScript" + + ```js title="binary_tree.js" + + ``` + +=== "TypeScript" + + ```typescript title="binary_tree.ts" + + ``` + +=== "C" + + ```c title="binary_tree.c" + + ``` + +=== "C#" + + ```csharp title="binary_tree.cs" + + ``` + **插入与删除结点。** 与链表类似，插入与删除结点都可以通过修改指针实现。 ![binary_tree_add_remove](binary_tree.assets/binary_tree_add_remove.png) @@ -183,6 +231,30 @@ comments: true ``` +=== "JavaScript" + + ```js title="binary_tree.js" + + ``` + +=== "TypeScript" + + ```typescript title="binary_tree.ts" + + ``` + +=== "C" + + ```c title="binary_tree.c" + + ``` + +=== "C#" + + ```csharp title="binary_tree.cs" + + ``` + !!! note 插入结点会改变二叉树的原有逻辑结构，删除结点往往意味着删除了该结点的所有子树。因此，二叉树中的插入与删除一般都是由一套操作配合完成的，这样才能实现有意义的操作。 @@ -259,6 +331,30 @@ comments: true ``` +=== "JavaScript" + + ```js title="binary_tree_bfs.js" + + ``` + +=== "TypeScript" + + ```typescript title="binary_tree_bfs.ts" + + ``` + +=== "C" + + ```c title="binary_tree_bfs.c" + + ``` + +=== "C#" + + ```csharp title="binary_tree_bfs.cs" + + ``` + ### 前序、中序、后序遍历 相对地，前、中、后序遍历皆属于「深度优先遍历 Depth-First Traversal」，其体现着一种 “先走到尽头，再回头继续” 的回溯遍历方式。 @@ -353,6 +449,30 @@ comments: true ``` +=== "JavaScript" + + ```js title="binary_tree_dfs.js" + + ``` + +=== "TypeScript" + + ```typescript title="binary_tree_dfs.ts" + + ``` + +=== "C" + + ```c title="binary_tree_dfs.c" + + ``` + +=== "C#" + + ```csharp title="binary_tree_dfs.cs" + + ``` + !!! note 使用循环一样可以实现前、中、后序遍历，但代码相对繁琐，有兴趣的同学可以自行实现。 diff --git a/docs/chapter_tree/binary_tree_types.md b/docs/chapter_tree/binary_tree_types.md index af0112bc7..7e1c523a1 100644 --- a/docs/chapter_tree/binary_tree_types.md +++ b/docs/chapter_tree/binary_tree_types.md @@ -16,7 +16,8 @@ comments: true 完美二叉树的性质有： -- 若树高度 $= h$ ，则结点总数 $= 2^h$ - 1； +- 若树高度 $= h$ ，则结点总数 $= 2^h - 1$； +- （TODO） ## 完全二叉树 @@ -26,7 +27,7 @@ comments: true 完全二叉树有一个很好的性质，可以用「数组」来表示。 -- +- （TODO） ## 完满二叉树 @@ -39,3 +40,5 @@ comments: true **「平衡二叉树 Balanced Binary Tree」，又称「AVL 树」** ，其任意结点的左子树和右子树的高度之差的绝对值 $\leq 1$ 。 ![balanced_binary_tree](binary_tree_types.assets/balanced_binary_tree.png) + +- （TODO） From 28c134c15f21717eafce28612939c734ef7abe19 Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Sat, 3 Dec 2022 01:58:23 +0800 Subject: [PATCH 44/67] =?UTF-8?q?Correct=20the=20usage=20of=20=E5=9C=B0=20?= =?UTF-8?q?and=20=E5=BE=97.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/chapter_computational_complexity/performance_evaluation.md | 2 +- docs/chapter_computational_complexity/time_complexity.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/chapter_computational_complexity/performance_evaluation.md b/docs/chapter_computational_complexity/performance_evaluation.md index e4fadff69..84c3dc80d 100644 --- a/docs/chapter_computational_complexity/performance_evaluation.md +++ b/docs/chapter_computational_complexity/performance_evaluation.md @@ -16,7 +16,7 @@ comments: true - **时间效率** ，即算法的运行速度的快慢。 - **空间效率** ，即算法占用的内存空间大小。 -数据结构与算法追求 “运行地快、内存占用少” ，而如何去评价算法效率则是非常重要的问题。 +数据结构与算法追求 “运行得快、内存占用少” ，而如何去评价算法效率则是非常重要的问题。 ## 效率评估方法 diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md index df0ea51a7..555525207 100644 --- a/docs/chapter_computational_complexity/time_complexity.md +++ b/docs/chapter_computational_complexity/time_complexity.md @@ -862,7 +862,7 @@ $$ 生物学科中的 “细胞分裂” 即是指数阶增长：初始状态为 $1$ 个细胞，分裂一轮后为 $2$ 个，分裂两轮后为 $4$ 个，……，分裂 $n$ 轮后有 $2^n$ 个细胞。 -指数阶增长地非常快，在实际应用中一般是不能被接受的。若一个问题使用「暴力枚举」求解的时间复杂度是 $O(2^n)$ ，那么一般都需要使用「动态规划」或「贪心算法」等算法来求解。 +指数阶增长得非常快，在实际应用中一般是不能被接受的。若一个问题使用「暴力枚举」求解的时间复杂度是 $O(2^n)$ ，那么一般都需要使用「动态规划」或「贪心算法」等算法来求解。 === "Java" From 1d9a076cdd064184d25da60c4689d5b7218b6b35 Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Sat, 3 Dec 2022 03:25:39 +0800 Subject: [PATCH 45/67] Update README.md --- README.md | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index a006289c5..d495c0a7b 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@

- +

@@ -15,7 +15,9 @@

- + +   +

From ebf902413684e8a18205a11252c824872ae38b46 Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Sat, 3 Dec 2022 20:25:24 +0800 Subject: [PATCH 46/67] Add Go codes to docs, including the chapter of stack and queue, the chapter of tree. --- codes/cpp/chapter_stack_and_queue/deque.cpp | 2 +- .../leetcode_two_sum_test.go | 5 +- .../chapter_searching/linear_search_test.go | 5 +- .../go/chapter_stack_and_queue/array_queue.go | 59 +++----- .../go/chapter_stack_and_queue/array_stack.go | 27 +--- codes/go/chapter_stack_and_queue/deque.go | 26 ---- .../go/chapter_stack_and_queue/deque_test.go | 69 ++++++++-- .../linkedlist_deque.go | 60 +++------ .../linkedlist_queue.go | 43 ++---- .../linkedlist_stack.go | 43 ++---- codes/go/chapter_stack_and_queue/queue.go | 20 --- .../go/chapter_stack_and_queue/queue_test.go | 83 +++++++++--- codes/go/chapter_stack_and_queue/stack.go | 20 --- .../go/chapter_stack_and_queue/stack_test.go | 78 ++++++++--- codes/go/chapter_tree/binary_search_tree.go | 13 +- .../chapter_tree/binary_search_tree_test.go | 21 +-- codes/go/chapter_tree/binary_tree.go | 23 ---- codes/go/chapter_tree/binary_tree_bfs.go | 5 +- codes/go/chapter_tree/binary_tree_bfs_test.go | 5 +- codes/go/chapter_tree/binary_tree_dfs.go | 71 ++++------ codes/go/chapter_tree/binary_tree_dfs_test.go | 18 ++- codes/go/chapter_tree/binary_tree_test.go | 18 +-- codes/go/pkg/list_node.go | 20 --- codes/go/pkg/list_node_test.go | 7 +- codes/go/pkg/print_utils.go | 98 ++++++++++++++ codes/go/pkg/tree_node.go | 56 -------- codes/go/pkg/tree_node_test.go | 7 +- codes/java/chapter_stack_and_queue/deque.java | 2 +- .../chapter_array_and_linkedlist/array.js | 2 +- .../chapter_sorting/insertion_sort.js | 2 +- .../chapter_array_and_linkedlist/list.py | 2 +- .../python/chapter_sorting/insertion_sort.py | 2 +- codes/python/chapter_stack_and_queue/deque.py | 2 +- docs/chapter_array_and_linkedlist/array.md | 2 +- .../space_complexity.md | 2 +- .../time_complexity.md | 2 +- docs/chapter_stack_and_queue/deque.md | 29 +++- docs/chapter_stack_and_queue/queue.md | 126 ++++++++++++++++++ docs/chapter_stack_and_queue/stack.md | 113 ++++++++++++++++ docs/chapter_tree/binary_search_tree.md | 106 ++++++++++++++- docs/chapter_tree/binary_tree.md | 90 ++++++++++++- 41 files changed, 898 insertions(+), 486 deletions(-) delete mode 100644 codes/go/chapter_stack_and_queue/deque.go delete mode 100644 codes/go/chapter_stack_and_queue/queue.go delete mode 100644 codes/go/chapter_stack_and_queue/stack.go delete mode 100644 codes/go/chapter_tree/binary_tree.go create mode 100644 codes/go/pkg/print_utils.go diff --git a/codes/cpp/chapter_stack_and_queue/deque.cpp b/codes/cpp/chapter_stack_and_queue/deque.cpp index 820dd4af2..96cf58111 100644 --- a/codes/cpp/chapter_stack_and_queue/deque.cpp +++ b/codes/cpp/chapter_stack_and_queue/deque.cpp @@ -21,7 +21,7 @@ int main() { cout << "双向队列 deque = "; PrintUtil::printDeque(deque); - /* 访问队首元素 */ + /* 访问元素 */ int front = deque.front(); cout << "队首元素 front = " << front << endl; int back = deque.back(); diff --git a/codes/go/chapter_computational_complexity/leetcode_two_sum_test.go b/codes/go/chapter_computational_complexity/leetcode_two_sum_test.go index b787c65b2..6e44eef98 100644 --- a/codes/go/chapter_computational_complexity/leetcode_two_sum_test.go +++ b/codes/go/chapter_computational_complexity/leetcode_two_sum_test.go @@ -5,6 +5,7 @@ package chapter_computational_complexity import ( + "fmt" "testing" ) @@ -16,8 +17,8 @@ func TestTwoSum(t *testing.T) { // ====== Driver Code ====== // 方法一：暴力解法 res := twoSumBruteForce(nums, target) - t.Log("方法一 res =", res) + fmt.Println("方法一 res =", res) // 方法二：哈希表 res = twoSumHashTable(nums, target) - t.Log("方法二 res =", res) + fmt.Println("方法二 res =", res) } diff --git a/codes/go/chapter_searching/linear_search_test.go b/codes/go/chapter_searching/linear_search_test.go index c24064424..79525aace 100644 --- a/codes/go/chapter_searching/linear_search_test.go +++ b/codes/go/chapter_searching/linear_search_test.go @@ -5,6 +5,7 @@ package chapter_searching import ( + "fmt" "testing" . "github.com/krahets/hello-algo/pkg" @@ -16,10 +17,10 @@ func TestLinearSearch(t *testing.T) { // 在数组中执行线性查找 index := linerSearchArray(nums, target) - t.Log("目标元素 3 的索引 =", index) + fmt.Println("目标元素 3 的索引 =", index) // 在链表中执行线性查找 head := ArrayToLinkedList(nums) node := linerSearchLinkedList(head, target) - t.Log("目标结点值 3 的对应结点对象为", node) + fmt.Println("目标结点值 3 的对应结点对象为", node) } diff --git a/codes/go/chapter_stack_and_queue/array_queue.go b/codes/go/chapter_stack_and_queue/array_queue.go index fd41f8bae..863768ba8 100644 --- a/codes/go/chapter_stack_and_queue/array_queue.go +++ b/codes/go/chapter_stack_and_queue/array_queue.go @@ -4,50 +4,45 @@ package chapter_stack_and_queue -import ( - "fmt" - "strings" -) - -// ArrayQueue 基于环形数组实现的队列, 不支持扩容 +/* 基于环形数组实现的队列 */ type ArrayQueue struct { - data []any // 用于存储队列元素的数组 + data []int // 用于存储队列元素的数组 capacity int // 队列容量（即最多容量的元素个数） - head int // 头指针，指向队首 - tail int // 尾指针，指向队尾 + 1 + front int // 头指针，指向队首 + rear int // 尾指针，指向队尾 + 1 } // NewArrayQueue 基于环形数组实现的队列 func NewArrayQueue(capacity int) *ArrayQueue { return &ArrayQueue{ - data: make([]any, capacity), + data: make([]int, capacity), capacity: capacity, - head: 0, - tail: 0, + front: 0, + rear: 0, } } // Size 获取队列的长度 func (q *ArrayQueue) Size() int { - size := (q.capacity + q.tail - q.head) % q.capacity + size := (q.capacity + q.rear - q.front) % q.capacity return size } // IsEmpty 判断队列是否为空 func (q *ArrayQueue) IsEmpty() bool { - return q.tail-q.head == 0 + return q.rear-q.front == 0 } // Offer 入队 -func (q *ArrayQueue) Offer(v any) { - // 当 tail == capacity 表示队列已满 +func (q *ArrayQueue) Offer(v int) { + // 当 rear == capacity 表示队列已满 if q.Size() == q.capacity { return } // 尾结点后添加 - q.data[q.tail] = v + q.data[q.rear] = v // 尾指针向后移动一位，越过尾部后返回到数组头部 - q.tail = (q.tail + 1) % q.capacity + q.rear = (q.rear + 1) % q.capacity } // Poll 出队 @@ -55,9 +50,9 @@ func (q *ArrayQueue) Poll() any { if q.IsEmpty() { return nil } - v := q.data[q.head] + v := q.data[q.front] // 队头指针向后移动一位，若越过尾部则返回到数组头部 - q.head = (q.head + 1) % q.capacity + q.front = (q.front + 1) % q.capacity return v } @@ -66,27 +61,11 @@ func (q *ArrayQueue) Peek() any { if q.IsEmpty() { return nil } - v := q.data[q.head] + v := q.data[q.front] return v } -func (q *ArrayQueue) Print() { - fmt.Println(q.toString()) -} - -// toString 通过字符串的方式输出 -func (q *ArrayQueue) toString() string { - // 为空时 - if q.IsEmpty() { - return "empty items" - } - var builder strings.Builder - size := q.Size() - str := fmt.Sprintf("%+v", q.data[q.head]) - for i := 1; i < size; i++ { - builder.WriteString(str + " -> ") - str = fmt.Sprintf("%+v", q.data[(i+q.head)%q.capacity]) - } - builder.WriteString(str) - return builder.String() +// 获取 Slice 用于打印 +func (s *ArrayQueue) toSlice() []int { + return s.data[s.front:s.rear] } diff --git a/codes/go/chapter_stack_and_queue/array_stack.go b/codes/go/chapter_stack_and_queue/array_stack.go index f3a8a287d..dca97404d 100644 --- a/codes/go/chapter_stack_and_queue/array_stack.go +++ b/codes/go/chapter_stack_and_queue/array_stack.go @@ -4,13 +4,7 @@ package chapter_stack_and_queue -import ( - "fmt" - "strconv" - "strings" -) - -// ArrayStack 基于数组实现的栈 +/* 基于数组实现的栈 */ type ArrayStack struct { data []int // 数据 } @@ -38,6 +32,7 @@ func (s *ArrayStack) Push(v int) { s.data = append(s.data, v) } +// Pop 出栈 func (s *ArrayStack) Pop() any { // 弹出栈前，先判断是否为空 if s.IsEmpty() { @@ -48,6 +43,7 @@ func (s *ArrayStack) Pop() any { return val } +// Peek 获取栈顶元素 func (s *ArrayStack) Peek() any { if s.IsEmpty() { return nil @@ -56,18 +52,7 @@ func (s *ArrayStack) Peek() any { return val } -func (s *ArrayStack) Print() { - fmt.Println(s.toString()) -} - -func (s *ArrayStack) toString() string { - var builder strings.Builder - if s.IsEmpty() { - return "empty stack" - } - for i := len(s.data) - 1; i > 0; i-- { - builder.WriteString(strconv.Itoa(s.data[i]) + " -> ") - } - builder.WriteString(strconv.Itoa(s.data[0])) - return builder.String() +// 获取 Slice 用于打印 +func (s *ArrayStack) toSlice() []int { + return s.data } diff --git a/codes/go/chapter_stack_and_queue/deque.go b/codes/go/chapter_stack_and_queue/deque.go deleted file mode 100644 index 3ac070e1a..000000000 --- a/codes/go/chapter_stack_and_queue/deque.go +++ /dev/null @@ -1,26 +0,0 @@ -// File: deque.go -// Created Time: 2022-11-29 -// Author: Reanon (793584285@qq.com) - -package chapter_stack_and_queue - -type Deque interface { - // OfferFirst 元素入队 - OfferFirst(num any) - // OfferLast 元素入队 - OfferLast(num any) - // PeekFirst 访问首元素 - PeekFirst() any - // PeekLast 访问尾元素 - PeekLast() any - // PollFirst 元素出队 - PollFirst() any - // PollLast 元素出队 - PollLast() any - // Size 获取队列长度 - Size() int - // IsEmpty 队列是否为空 - IsEmpty() bool - // toString 队列输出为字符串 - toString() string -} diff --git a/codes/go/chapter_stack_and_queue/deque_test.go b/codes/go/chapter_stack_and_queue/deque_test.go index c0eaf089e..647ac642e 100644 --- a/codes/go/chapter_stack_and_queue/deque_test.go +++ b/codes/go/chapter_stack_and_queue/deque_test.go @@ -4,12 +4,54 @@ package chapter_stack_and_queue -import "testing" +import ( + "container/list" + "fmt" + "testing" + + . "github.com/krahets/hello-algo/pkg" +) + +func TestDeque(t *testing.T) { + /* 初始化双向队列 */ + // 在 Go 中，将 list 作为双向队列使用 + deque := list.New() + + /* 元素入队 */ + deque.PushBack(2) + deque.PushBack(5) + deque.PushBack(4) + deque.PushFront(3) + deque.PushFront(1) + fmt.Print("双向队列 deque = ") + PrintList(deque) + + /* 访问元素 */ + front := deque.Front() + fmt.Println("队首元素 front =", front.Value) + rear := deque.Back() + fmt.Println("队尾元素 rear =", rear.Value) + + /* 元素出队 */ + deque.Remove(front) + fmt.Print("队首出队元素 front = ", front.Value, "，队首出队后 deque = ") + PrintList(deque) + deque.Remove(rear) + fmt.Print("队尾出队元素 rear = ", rear.Value, "，队尾出队后 deque = ") + PrintList(deque) + + /* 获取双向队列的长度 */ + size := deque.Len() + fmt.Println("双向队列长度 size =", size) + + /* 判断双向队列是否为空 */ + isEmpty := deque.Len() == 0 + fmt.Println("双向队列是否为空 =", isEmpty) +} func TestLinkedListDeque(t *testing.T) { // 初始化队列 - var deque Deque - deque = NewLinkedListDeque() + deque := NewLinkedListDeque() // 元素入队 deque.OfferLast(2) @@ -17,27 +59,30 @@ func TestLinkedListDeque(t *testing.T) { deque.OfferLast(4) deque.OfferFirst(3) deque.OfferFirst(1) - t.Log("队列 deque = ", deque.toString()) + fmt.Print("队列 deque = ") + PrintList(deque.toList()) // 访问队首元素 - peekFirst := deque.PeekFirst() - t.Log("队首元素 peek = ", peekFirst) - peekLast := deque.PeekLast() - t.Log("队尾元素 peek = ", peekLast) + front := deque.PeekFirst() + fmt.Println("队首元素 front =", front) + rear := deque.PeekLast() + fmt.Println("队尾元素 rear =", rear) // 元素出队 pollFirst := deque.PollFirst() - t.Log("队首出队元素 pollFirst = ", pollFirst, "，队首出队后 deque = ", deque.toString()) + fmt.Print("队首出队元素 pollFirst = ", pollFirst, "，队首出队后 deque = ") + PrintList(deque.toList()) pollLast := deque.PollLast() - t.Log("队尾出队元素 pollLast = ", pollLast, "，队尾出队后 deque = ", deque.toString()) + fmt.Print("队尾出队元素 pollLast = ", pollLast, "，队尾出队后 deque = ") + PrintList(deque.toList()) // 获取队的长度 size := deque.Size() - t.Log("队的长度 size = ", size) + fmt.Println("队的长度 size =", size) // 判断是否为空 isEmpty := deque.IsEmpty() - t.Log("队是否为空 = ", isEmpty) + fmt.Println("队是否为空 =", isEmpty) } // BenchmarkArrayQueue 67.92 ns/op in Mac M1 Pro diff --git a/codes/go/chapter_stack_and_queue/linkedlist_deque.go b/codes/go/chapter_stack_and_queue/linkedlist_deque.go index 62a614910..019aa778b 100644 --- a/codes/go/chapter_stack_and_queue/linkedlist_deque.go +++ b/codes/go/chapter_stack_and_queue/linkedlist_deque.go @@ -6,97 +6,79 @@ package chapter_stack_and_queue import ( "container/list" - "fmt" - "strings" ) // LinkedListDeque 基于链表实现的双端队列, 使用内置包 list 来实现栈 type LinkedListDeque struct { - list *list.List + data *list.List } // NewLinkedListDeque 初始化双端队列 func NewLinkedListDeque() *LinkedListDeque { return &LinkedListDeque{ - list: list.New(), + data: list.New(), } } -// OfferFirst 元素入队 +// OfferFirst 队首元素入队 func (s *LinkedListDeque) OfferFirst(value any) { - s.list.PushFront(value) + s.data.PushFront(value) } -// OfferLast 元素入队 +// OfferLast 队尾元素入队 func (s *LinkedListDeque) OfferLast(value any) { - s.list.PushBack(value) + s.data.PushBack(value) } -// PollFirst 元素出队 +// PollFirst 队首元素出队 func (s *LinkedListDeque) PollFirst() any { if s.IsEmpty() { return nil } - e := s.list.Front() - s.list.Remove(e) + e := s.data.Front() + s.data.Remove(e) return e.Value } -// PollLast 元素出队 +// PollLast 队尾元素出队 func (s *LinkedListDeque) PollLast() any { if s.IsEmpty() { return nil } - e := s.list.Back() - s.list.Remove(e) + e := s.data.Back() + s.data.Remove(e) return e.Value } -// PeekFirst 访问首元素 +// PeekFirst 访问队首元素 func (s *LinkedListDeque) PeekFirst() any { if s.IsEmpty() { return nil } - e := s.list.Front() + e := s.data.Front() return e.Value } -// PeekLast 访问尾元素 +// PeekLast 访问队尾元素 func (s *LinkedListDeque) PeekLast() any { if s.IsEmpty() { return nil } - e := s.list.Back() + e := s.data.Back() return e.Value } // Size 获取队列的长度 func (s *LinkedListDeque) Size() int { - return s.list.Len() + return s.data.Len() } // IsEmpty 判断队列是否为空 func (s *LinkedListDeque) IsEmpty() bool { - return s.list.Len() == 0 + return s.data.Len() == 0 } -func (s *LinkedListDeque) Print() { - fmt.Println(s.toString()) -} - -func (s *LinkedListDeque) toString() string { - var builder strings.Builder - if s.IsEmpty() { - fmt.Println("empty stack") - } - e := s.list.Front() - // 强转为 string, 会影响效率 - str := fmt.Sprintf("%v", e.Value) - for e.Next() != nil { - builder.WriteString(str + " -> ") - e = e.Next() - str = fmt.Sprintf("%v", e.Value) - } - builder.WriteString(str) - return builder.String() +// 获取 List 用于打印 +func (s *LinkedListDeque) toList() *list.List { + return s.data } diff --git a/codes/go/chapter_stack_and_queue/linkedlist_queue.go b/codes/go/chapter_stack_and_queue/linkedlist_queue.go index 5b62ac311..d30461805 100644 --- a/codes/go/chapter_stack_and_queue/linkedlist_queue.go +++ b/codes/go/chapter_stack_and_queue/linkedlist_queue.go @@ -6,25 +6,24 @@ package chapter_stack_and_queue import ( "container/list" - "fmt" - "strings" ) -// LinkedListQueue 基于链表实现的队列, 使用内置包 list 来实现栈 +/* 基于链表实现的队列 */ type LinkedListQueue struct { - list *list.List + // 使用内置包 list 来实现队列 + data *list.List } // NewLinkedListQueue 初始化链表 func NewLinkedListQueue() *LinkedListQueue { return &LinkedListQueue{ - list: list.New(), + data: list.New(), } } // Offer 入队 func (s *LinkedListQueue) Offer(value any) { - s.list.PushBack(value) + s.data.PushBack(value) } // Poll 出队 @@ -32,8 +31,8 @@ func (s *LinkedListQueue) Poll() any { if s.IsEmpty() { return nil } - e := s.list.Front() - s.list.Remove(e) + e := s.data.Front() + s.data.Remove(e) return e.Value } @@ -42,37 +41,21 @@ func (s *LinkedListQueue) Peek() any { if s.IsEmpty() { return nil } - e := s.list.Front() + e := s.data.Front() return e.Value } // Size 获取队列的长度 func (s *LinkedListQueue) Size() int { - return s.list.Len() + return s.data.Len() } // IsEmpty 判断队列是否为空 func (s *LinkedListQueue) IsEmpty() bool { - return s.list.Len() == 0 + return s.data.Len() == 0 } -func (s *LinkedListQueue) Print() { - fmt.Println(s.toString()) -} - -func (s *LinkedListQueue) toString() string { - var builder strings.Builder - if s.IsEmpty() { - fmt.Println("empty stack") - } - e := s.list.Front() - // 强转为 string, 会影响效率 - str := fmt.Sprintf("%v", e.Value) - for e.Next() != nil { - builder.WriteString(str + " -> ") - e = e.Next() - str = fmt.Sprintf("%v", e.Value) - } - builder.WriteString(str) - return builder.String() +// 获取 List 用于打印 +func (s *LinkedListQueue) toList() *list.List { + return s.data } diff --git a/codes/go/chapter_stack_and_queue/linkedlist_stack.go b/codes/go/chapter_stack_and_queue/linkedlist_stack.go index 24f46acb5..ab8a06284 100644 --- a/codes/go/chapter_stack_and_queue/linkedlist_stack.go +++ b/codes/go/chapter_stack_and_queue/linkedlist_stack.go @@ -6,25 +6,24 @@ package chapter_stack_and_queue import ( "container/list" - "fmt" - "strings" ) -// LinkedListStack 基于链表实现的栈, 使用内置包 list 来实现栈 +/* 基于链表实现的栈 */ type LinkedListStack struct { - list *list.List + // 使用内置包 list 来实现栈 + data *list.List } // NewLinkedListStack 初始化链表 func NewLinkedListStack() *LinkedListStack { return &LinkedListStack{ - list: list.New(), + data: list.New(), } } // Push 入栈 func (s *LinkedListStack) Push(value int) { - s.list.PushBack(value) + s.data.PushBack(value) } // Pop 出栈 @@ -32,8 +31,8 @@ func (s *LinkedListStack) Pop() any { if s.IsEmpty() { return nil } - e := s.list.Back() - s.list.Remove(e) + e := s.data.Back() + s.data.Remove(e) return e.Value } @@ -42,37 +41,21 @@ func (s *LinkedListStack) Peek() any { if s.IsEmpty() { return nil } - e := s.list.Back() + e := s.data.Back() return e.Value } // Size 获取栈的长度 func (s *LinkedListStack) Size() int { - return s.list.Len() + return s.data.Len() } // IsEmpty 判断栈是否为空 func (s *LinkedListStack) IsEmpty() bool { - return s.list.Len() == 0 + return s.data.Len() == 0 } -func (s *LinkedListStack) Print() { - fmt.Println(s.toString()) -} - -func (s *LinkedListStack) toString() string { - var builder strings.Builder - if s.IsEmpty() { - fmt.Println("empty stack") - } - e := s.list.Back() - // 强转为 string, 会影响效率 - str := fmt.Sprintf("%v", e.Value) - for e.Prev() != nil { - builder.WriteString(str + " -> ") - e = e.Prev() - str = fmt.Sprintf("%v", e.Value) - } - builder.WriteString(str) - return builder.String() +// 获取 List 用于打印 +func (s *LinkedListStack) toList() *list.List { + return s.data } diff --git a/codes/go/chapter_stack_and_queue/queue.go b/codes/go/chapter_stack_and_queue/queue.go deleted file mode 100644 index 03b97e5a6..000000000 --- a/codes/go/chapter_stack_and_queue/queue.go +++ /dev/null @@ -1,20 +0,0 @@ -// File: queue.go -// Created Time: 2022-11-29 -// Author: Reanon (793584285@qq.com) - -package chapter_stack_and_queue - -type Queue interface { - // Offer 元素入队 - Offer(num any) - // Peek 访问首元素 - Peek() any - // Poll 元素出队 - Poll() any - // Size 获取队列长度 - Size() int - // IsEmpty 队列是否为空 - IsEmpty() bool - // toString 队列输出为字符串 - toString() string -} diff --git a/codes/go/chapter_stack_and_queue/queue_test.go b/codes/go/chapter_stack_and_queue/queue_test.go index e8c74ecba..368becbc7 100644 --- a/codes/go/chapter_stack_and_queue/queue_test.go +++ b/codes/go/chapter_stack_and_queue/queue_test.go @@ -4,67 +4,108 @@ package chapter_stack_and_queue -import "testing" +import ( + "container/list" + "fmt" + "testing" + + . "github.com/krahets/hello-algo/pkg" +) + +func TestQueue(t *testing.T) { + /* 初始化队列 */ + // 在 Go 中，将 list 作为队列来使用 + queue := list.New() + + /* 元素入队 */ + queue.PushBack(1) + queue.PushBack(3) + queue.PushBack(2) + queue.PushBack(5) + queue.PushBack(4) + fmt.Print("队列 queue = ") + PrintList(queue) + + /* 访问队首元素 */ + peek := queue.Front() + fmt.Println("队首元素 peek =", peek.Value) + + /* 元素出队 */ + poll := queue.Front() + queue.Remove(poll) + fmt.Print("出队元素 poll = ", poll.Value, "，出队后 queue = ") + PrintList(queue) + + /* 获取队列的长度 */ + size := queue.Len() + fmt.Println("队列长度 size =", size) + + /* 判断队列是否为空 */ + isEmpty := queue.Len() == 0 + fmt.Println("队列是否为空 =", isEmpty) +} func TestArrayQueue(t *testing.T) { // 初始化队列，使用队列的通用接口 - var queue Queue capacity := 10 - queue = NewArrayQueue(capacity) + queue := NewArrayQueue(capacity) // 元素入队 queue.Offer(1) - queue.Offer(2) queue.Offer(3) - queue.Offer(4) + queue.Offer(2) queue.Offer(5) - t.Log("队列 queue = ", queue.toString()) + queue.Offer(4) + fmt.Print("队列 queue = ") + PrintSlice(queue.toSlice()) // 访问队首元素 peek := queue.Peek() - t.Log("队首元素 peek = ", peek) + fmt.Println("队首元素 peek =", peek) // 元素出队 - pop := queue.Poll() - t.Log("出队元素 pop = ", pop, ", 出队后 queue =", queue.toString()) + poll := queue.Poll() + fmt.Print("出队元素 poll = ", poll, ", 出队后 queue = ") + PrintSlice(queue.toSlice()) // 获取队的长度 size := queue.Size() - t.Log("队的长度 size = ", size) + fmt.Println("队的长度 size =", size) // 判断是否为空 isEmpty := queue.IsEmpty() - t.Log("队是否为空 = ", isEmpty) + fmt.Println("队是否为空 =", isEmpty) } func TestLinkedListQueue(t *testing.T) { // 初始化队 - var queue Queue - queue = NewLinkedListQueue() + queue := NewLinkedListQueue() // 元素入队 queue.Offer(1) - queue.Offer(2) queue.Offer(3) - queue.Offer(4) + queue.Offer(2) queue.Offer(5) - t.Log("队列 queue = ", queue.toString()) + queue.Offer(4) + fmt.Print("队列 queue = ") + PrintList(queue.toList()) // 访问队首元素 peek := queue.Peek() - t.Log("队首元素 peek = ", peek) + fmt.Println("队首元素 peek =", peek) // 元素出队 - pop := queue.Poll() - t.Log("出队元素 pop = ", pop, ", 出队后 queue =", queue.toString()) + poll := queue.Poll() + fmt.Print("出队元素 poll = ", poll, ", 出队后 queue = ") + PrintList(queue.toList()) // 获取队的长度 size := queue.Size() - t.Log("队的长度 size = ", size) + fmt.Println("队的长度 size =", size) // 判断是否为空 isEmpty := queue.IsEmpty() - t.Log("队是否为空 = ", isEmpty) + fmt.Println("队是否为空 =", isEmpty) } // BenchmarkArrayQueue 8 ns/op in Mac M1 Pro diff --git a/codes/go/chapter_stack_and_queue/stack.go b/codes/go/chapter_stack_and_queue/stack.go deleted file mode 100644 index 779538784..000000000 --- a/codes/go/chapter_stack_and_queue/stack.go +++ /dev/null @@ -1,20 +0,0 @@ -// File: stack.go -// Created Time: 2022-11-26 -// Author: Reanon (793584285@qq.com) - -package chapter_stack_and_queue - -type Stack interface { - // Push 元素入栈 - Push(num int) - // Peek 访问栈顶元素 - Peek() any - // Pop 元素出栈 - Pop() any - // Size 栈的长度 - Size() int - // IsEmpty 栈是否为空 - IsEmpty() bool - // toString 栈输出为字符串 - toString() string -} diff --git a/codes/go/chapter_stack_and_queue/stack_test.go b/codes/go/chapter_stack_and_queue/stack_test.go index 95c6d2410..9dc97e697 100644 --- a/codes/go/chapter_stack_and_queue/stack_test.go +++ b/codes/go/chapter_stack_and_queue/stack_test.go @@ -4,65 +4,105 @@ package chapter_stack_and_queue -import "testing" +import ( + "fmt" + "testing" + + . "github.com/krahets/hello-algo/pkg" +) + +func TestStack(t *testing.T) { + /* 初始化栈 */ + // 在 Go 中，推荐将 Slice 当作栈来使用 + var stack []int + + /* 元素入栈 */ + stack = append(stack, 1) + stack = append(stack, 3) + stack = append(stack, 2) + stack = append(stack, 5) + stack = append(stack, 4) + fmt.Print("栈 = ") + PrintSlice(stack) + + /* 访问栈顶元素 */ + peek := stack[len(stack)-1] + fmt.Println("栈顶元素 peek =", peek) + + /* 元素出栈 */ + pop := stack[len(stack)-1] + stack = stack[:len(stack)-1] + fmt.Print("出栈元素 pop = ", pop, "，出栈后 stack = ") + PrintSlice(stack) + + /* 获取栈的长度 */ + size := len(stack) + fmt.Println("栈的长度 size =", size) + + /* 判断是否为空 */ + isEmpty := len(stack) == 0 + fmt.Println("栈是否为空 =", isEmpty) +} func TestArrayStack(t *testing.T) { // 初始化栈, 使用接口承接 - var stack Stack - stack = NewArrayStack() + stack := NewArrayStack() // 元素入栈 stack.Push(1) - stack.Push(2) stack.Push(3) - stack.Push(4) + stack.Push(2) stack.Push(5) - t.Log("栈 stack = ", stack.toString()) + stack.Push(4) + fmt.Print("栈 stack = ") + PrintSlice(stack.toSlice()) // 访问栈顶元素 peek := stack.Peek() - t.Log("栈顶元素 peek = ", peek) + fmt.Println("栈顶元素 peek =", peek) // 元素出栈 pop := stack.Pop() - t.Log("出栈元素 pop = ", pop, ", 出栈后 stack =", stack.toString()) + fmt.Print("出栈元素 pop = ", pop, ", 出栈后 stack = ") + PrintSlice(stack.toSlice()) // 获取栈的长度 size := stack.Size() - t.Log("栈的长度 size = ", size) + fmt.Println("栈的长度 size =", size) // 判断是否为空 isEmpty := stack.IsEmpty() - t.Log("栈是否为空 = ", isEmpty) + fmt.Println("栈是否为空 =", isEmpty) } func TestLinkedListStack(t *testing.T) { // 初始化栈 - var stack Stack - stack = NewLinkedListStack() + stack := NewLinkedListStack() // 元素入栈 stack.Push(1) - stack.Push(2) stack.Push(3) - stack.Push(4) + stack.Push(2) stack.Push(5) - t.Log("栈 stack = ", stack.toString()) + stack.Push(4) + fmt.Print("栈 stack = ") + PrintList(stack.toList()) // 访问栈顶元素 peek := stack.Peek() - t.Log("栈顶元素 peek = ", peek) + fmt.Println("栈顶元素 peek =", peek) // 元素出栈 pop := stack.Pop() - t.Log("出栈元素 pop = ", pop, ", 出栈后 stack =", stack.toString()) + fmt.Print("出栈元素 pop = ", pop, ", 出栈后 stack = ") + PrintList(stack.toList()) // 获取栈的长度 size := stack.Size() - t.Log("栈的长度 size = ", size) + fmt.Println("栈的长度 size =", size) // 判断是否为空 isEmpty := stack.IsEmpty() - t.Log("栈是否为空 = ", isEmpty) + fmt.Println("栈是否为空 =", isEmpty) } // BenchmarkArrayStack 8 ns/op in Mac M1 Pro diff --git a/codes/go/chapter_tree/binary_search_tree.go b/codes/go/chapter_tree/binary_search_tree.go index ac14e798d..2af2e7be0 100644 --- a/codes/go/chapter_tree/binary_search_tree.go +++ b/codes/go/chapter_tree/binary_search_tree.go @@ -53,7 +53,7 @@ func (bst *BinarySearchTree) GetInorderNext(node *TreeNode) *TreeNode { return node } -// Search node of binary search tree +/* 查找结点 */ func (bst *BinarySearchTree) Search(num int) *TreeNode { node := bst.root // 循环查找，越过叶结点后跳出 @@ -73,7 +73,7 @@ func (bst *BinarySearchTree) Search(num int) *TreeNode { return node } -// Insert node of binary search tree +/* 插入结点 */ func (bst *BinarySearchTree) Insert(num int) *TreeNode { cur := bst.root // 若树为空，直接提前返回 @@ -104,7 +104,7 @@ func (bst *BinarySearchTree) Insert(num int) *TreeNode { return cur } -// Remove node of binary search tree +/* 删除结点 */ func (bst *BinarySearchTree) Remove(num int) *TreeNode { cur := bst.root // 若树为空，直接提前返回 @@ -119,8 +119,8 @@ func (bst *BinarySearchTree) Remove(num int) *TreeNode { break } prev = cur - // 待删除结点在右子树中 if cur.Val < num { + // 待删除结点在右子树中 cur = cur.Right } else { // 待删除结点在左子树中 @@ -146,8 +146,8 @@ func (bst *BinarySearchTree) Remove(num int) *TreeNode { } else { prev.Right = child } - - } else { // 子结点数为 2 + // 子结点数为 2 + } else { // 获取中序遍历中待删除结点 cur 的下一个结点 next := bst.GetInorderNext(cur) temp := next.Val @@ -156,7 +156,6 @@ func (bst *BinarySearchTree) Remove(num int) *TreeNode { // 将 next 的值复制给 cur cur.Val = temp } - // TODO: add error handler, don't return node return cur } diff --git a/codes/go/chapter_tree/binary_search_tree_test.go b/codes/go/chapter_tree/binary_search_tree_test.go index 5ae932b07..0d0369a78 100644 --- a/codes/go/chapter_tree/binary_search_tree_test.go +++ b/codes/go/chapter_tree/binary_search_tree_test.go @@ -4,38 +4,41 @@ package chapter_tree -import "testing" +import ( + "fmt" + "testing" +) func TestBinarySearchTree(t *testing.T) { nums := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15} bst := NewBinarySearchTree(nums) - t.Log("初始化的二叉树为:") + fmt.Println("初始化的二叉树为:") bst.Print() // 获取根结点 node := bst.GetRoot() - t.Log("二叉树的根结点为:", node.Val) + fmt.Println("二叉树的根结点为:", node.Val) // 获取最小的结点 node = bst.GetMin(bst.GetRoot()) - t.Log("二叉树的最小结点为:", node.Val) + fmt.Println("二叉树的最小结点为:", node.Val) // 查找结点 node = bst.Search(5) - t.Log("查找到的结点对象为", node, "，结点值 =", node.Val) + fmt.Println("查找到的结点对象为", node, "，结点值 =", node.Val) // 插入结点 node = bst.Insert(16) - t.Log("插入结点后 16 的二叉树为:") + fmt.Println("插入结点后 16 的二叉树为:") bst.Print() // 删除结点 bst.Remove(1) - t.Log("删除结点 1 后的二叉树为:") + fmt.Println("删除结点 1 后的二叉树为:") bst.Print() bst.Remove(2) - t.Log("删除结点 2 后的二叉树为:") + fmt.Println("删除结点 2 后的二叉树为:") bst.Print() bst.Remove(4) - t.Log("删除结点 4 后的二叉树为:") + fmt.Println("删除结点 4 后的二叉树为:") bst.Print() } diff --git a/codes/go/chapter_tree/binary_tree.go b/codes/go/chapter_tree/binary_tree.go deleted file mode 100644 index 72143cd9a..000000000 --- a/codes/go/chapter_tree/binary_tree.go +++ /dev/null @@ -1,23 +0,0 @@ -// File: binary_tree.go -// Created Time: 2022-11-25 -// Author: Reanon (793584285@qq.com) - -package chapter_tree - -import ( - . "github.com/krahets/hello-algo/pkg" -) - -type BinaryTree struct { - root *TreeNode -} - -func NewBinaryTree(node *TreeNode) *BinaryTree { - return &BinaryTree{ - root: node, - } -} - -func (tree *BinaryTree) Print() { - PrintTree(tree.root) -} diff --git a/codes/go/chapter_tree/binary_tree_bfs.go b/codes/go/chapter_tree/binary_tree_bfs.go index 5c07a96bc..d77bc97b1 100644 --- a/codes/go/chapter_tree/binary_tree_bfs.go +++ b/codes/go/chapter_tree/binary_tree_bfs.go @@ -10,11 +10,10 @@ import ( . "github.com/krahets/hello-algo/pkg" ) -// levelOrder Breadth First Search +/* 层序遍历 */ func levelOrder(root *TreeNode) []int { - // Let container.list as queue - queue := list.New() // 初始化队列，加入根结点 + queue := list.New() queue.PushBack(root) // 初始化一个切片，用于保存遍历序列 nums := make([]int, 0) diff --git a/codes/go/chapter_tree/binary_tree_bfs_test.go b/codes/go/chapter_tree/binary_tree_bfs_test.go index c06cd9e77..8d5c0aaff 100644 --- a/codes/go/chapter_tree/binary_tree_bfs_test.go +++ b/codes/go/chapter_tree/binary_tree_bfs_test.go @@ -5,6 +5,7 @@ package chapter_tree import ( + "fmt" "testing" . "github.com/krahets/hello-algo/pkg" @@ -14,10 +15,10 @@ func TestLevelOrder(t *testing.T) { /* 初始化二叉树 */ // 这里借助了一个从数组直接生成二叉树的函数 root := ArrayToTree([]int{1, 2, 3, 4, 5, 6, 7}) - t.Log("初始化二叉树: ") + fmt.Println("初始化二叉树: ") PrintTree(root) // 层序遍历 nums := levelOrder(root) - t.Log("层序遍历的结点打印序列 =", nums) + fmt.Println("层序遍历的结点打印序列 =", nums) } diff --git a/codes/go/chapter_tree/binary_tree_dfs.go b/codes/go/chapter_tree/binary_tree_dfs.go index c97aa17df..1a857ebae 100644 --- a/codes/go/chapter_tree/binary_tree_dfs.go +++ b/codes/go/chapter_tree/binary_tree_dfs.go @@ -8,56 +8,37 @@ import ( . "github.com/krahets/hello-algo/pkg" ) -// preOrder 前序遍历 -func preOrder(root *TreeNode) (nums []int) { - var preOrderHelper func(node *TreeNode) - // 匿名函数 - preOrderHelper = func(node *TreeNode) { - if node == nil { - return - } - // 访问优先级：根结点 -> 左子树 -> 右子树 - nums = append(nums, node.Val) - preOrderHelper(node.Left) - preOrderHelper(node.Right) +var nums []int + +/* 前序遍历 */ +func preOrder(node *TreeNode) { + if node == nil { + return } - // 函数调用 - preOrderHelper(root) - return + // 访问优先级：根结点 -> 左子树 -> 右子树 + nums = append(nums, node.Val) + preOrder(node.Left) + preOrder(node.Right) } -// inOrder 中序遍历 -func inOrder(root *TreeNode) (nums []int) { - var inOrderHelper func(node *TreeNode) - // 匿名函数 - inOrderHelper = func(node *TreeNode) { - if node == nil { - return - } - // 访问优先级：左子树 -> 根结点 -> 右子树 - inOrderHelper(node.Left) - nums = append(nums, node.Val) - inOrderHelper(node.Right) +/* 中序遍历 */ +func inOrder(node *TreeNode) { + if node == nil { + return } - // 函数调用 - inOrderHelper(root) - return + // 访问优先级：左子树 -> 根结点 -> 右子树 + inOrder(node.Left) + nums = append(nums, node.Val) + inOrder(node.Right) } -// postOrder 后序遍历 -func postOrder(root *TreeNode) (nums []int) { - var postOrderHelper func(node *TreeNode) - // 匿名函数 - postOrderHelper = func(node *TreeNode) { - if node == nil { - return - } - // 访问优先级：左子树 -> 右子树 -> 根结点 - postOrderHelper(node.Left) - postOrderHelper(node.Right) - nums = append(nums, node.Val) +/* 后序遍历 */ +func postOrder(node *TreeNode) { + if node == nil { + return } - // 函数调用 - postOrderHelper(root) - return + // 访问优先级：左子树 -> 右子树 -> 根结点 + postOrder(node.Left) + postOrder(node.Right) + nums = append(nums, node.Val) } diff --git a/codes/go/chapter_tree/binary_tree_dfs_test.go b/codes/go/chapter_tree/binary_tree_dfs_test.go index 2ee6295f6..67a3e1f3a 100644 --- a/codes/go/chapter_tree/binary_tree_dfs_test.go +++ b/codes/go/chapter_tree/binary_tree_dfs_test.go @@ -5,6 +5,7 @@ package chapter_tree import ( + "fmt" "testing" . "github.com/krahets/hello-algo/pkg" @@ -14,18 +15,21 @@ func TestPreInPostOrderTraversal(t *testing.T) { /* 初始化二叉树 */ // 这里借助了一个从数组直接生成二叉树的函数 root := ArrayToTree([]int{1, 2, 3, 4, 5, 6, 7}) - t.Log("初始化二叉树: ") + fmt.Println("初始化二叉树: ") PrintTree(root) // 前序遍历 - nums := preOrder(root) - t.Log("前序遍历的结点打印序列 =", nums) + nums = nil + preOrder(root) + fmt.Println("前序遍历的结点打印序列 =", nums) // 中序遍历 - nums = inOrder(root) - t.Log("中序遍历的结点打印序列 =", nums) + nums = nil + inOrder(root) + fmt.Println("中序遍历的结点打印序列 =", nums) // 后序遍历 - nums = postOrder(root) - t.Log("后序遍历的结点打印序列 =", nums) + nums = nil + postOrder(root) + fmt.Println("后序遍历的结点打印序列 =", nums) } diff --git a/codes/go/chapter_tree/binary_tree_test.go b/codes/go/chapter_tree/binary_tree_test.go index 03a85539a..f91e816fb 100644 --- a/codes/go/chapter_tree/binary_tree_test.go +++ b/codes/go/chapter_tree/binary_tree_test.go @@ -5,6 +5,7 @@ package chapter_tree import ( + "fmt" "testing" . "github.com/krahets/hello-algo/pkg" @@ -18,24 +19,23 @@ func TestBinaryTree(t *testing.T) { n3 := NewTreeNode(3) n4 := NewTreeNode(4) n5 := NewTreeNode(5) - - tree := NewBinaryTree(n1) + // 构建引用指向（即指针） n1.Left = n2 n1.Right = n3 n2.Left = n4 n2.Right = n5 - t.Log("初始化二叉树") - tree.Print() + fmt.Println("初始化二叉树") + PrintTree(n1) /* 插入与删除结点 */ + // 插入结点 p := NewTreeNode(0) n1.Left = p p.Left = n2 - t.Log("插入结点 P 后") - tree.Print() - + fmt.Println("插入结点 P 后") + PrintTree(n1) // 删除结点 n1.Left = n2 - t.Log("删除结点 P 后") - tree.Print() + fmt.Println("删除结点 P 后") + PrintTree(n1) } diff --git a/codes/go/pkg/list_node.go b/codes/go/pkg/list_node.go index 6795111ea..f1c152de1 100644 --- a/codes/go/pkg/list_node.go +++ b/codes/go/pkg/list_node.go @@ -4,12 +4,6 @@ package pkg -import ( - "fmt" - "strconv" - "strings" -) - // ListNode Definition for a singly-linked list node type ListNode struct { Next *ListNode @@ -43,17 +37,3 @@ func GetListNode(node *ListNode, val int) *ListNode { } return node } - -// PrintLinkedList Print a linked list -func PrintLinkedList(node *ListNode) { - if node == nil { - return - } - var builder strings.Builder - for node.Next != nil { - builder.WriteString(strconv.Itoa(node.Val) + " -> ") - node = node.Next - } - builder.WriteString(strconv.Itoa(node.Val)) - fmt.Println(builder.String()) -} diff --git a/codes/go/pkg/list_node_test.go b/codes/go/pkg/list_node_test.go index 5bc33d99d..31b99618f 100644 --- a/codes/go/pkg/list_node_test.go +++ b/codes/go/pkg/list_node_test.go @@ -4,7 +4,10 @@ package pkg -import "testing" +import ( + "fmt" + "testing" +) func TestListNode(t *testing.T) { arr := []int{2, 3, 5, 6, 7} @@ -12,5 +15,5 @@ func TestListNode(t *testing.T) { PrintLinkedList(head) node := GetListNode(head, 5) - t.Log("Find node: ", node.Val) + fmt.Println("Find node: ", node.Val) } diff --git a/codes/go/pkg/print_utils.go b/codes/go/pkg/print_utils.go new file mode 100644 index 000000000..e42d40684 --- /dev/null +++ b/codes/go/pkg/print_utils.go @@ -0,0 +1,98 @@ +// File: print_utils.go +// Created Time: 2022-12-03 +// Author: Reanon (793584285@qq.com), Krahets (krahets@163.com) + +package pkg + +import ( + "container/list" + "fmt" + "strconv" + "strings" +) + +func PrintSlice(nums []int) { + fmt.Printf("%v", nums) + fmt.Println() +} + +// PrintList Print a list +func PrintList(list *list.List) { + e := list.Front() + // 强转为 string, 会影响效率 + fmt.Print("[") + for e.Next() != nil { + fmt.Print(e.Value, " ") + e = e.Next() + } + fmt.Print(e.Value, "]\n") +} + +// PrintLinkedList Print a linked list +func PrintLinkedList(node *ListNode) { + if node == nil { + return + } + var builder strings.Builder + for node.Next != nil { + builder.WriteString(strconv.Itoa(node.Val) + " -> ") + node = node.Next + } + builder.WriteString(strconv.Itoa(node.Val)) + fmt.Println(builder.String()) +} + +// PrintTree Print a binary tree +func PrintTree(root *TreeNode) { + printTreeHelper(root, nil, false) +} + +// printTreeHelper Help to print a binary tree, hide more details +// This tree printer is borrowed from TECHIE DELIGHT +// https://www.techiedelight.com/c-program-print-binary-tree/ +func printTreeHelper(root *TreeNode, prev *trunk, isLeft bool) { + if root == nil { + return + } + prevStr := " " + trunk := newTrunk(prev, prevStr) + printTreeHelper(root.Right, trunk, true) + if prev == nil { + trunk.str = "———" + } else if isLeft { + trunk.str = "/———" + prevStr = " |" + } else { + trunk.str = "\\———" + prev.str = prevStr + } + showTrunk(trunk) + fmt.Println(root.Val) + if prev != nil { + prev.str = prevStr + } + trunk.str = " |" + printTreeHelper(root.Left, trunk, false) +} + +// trunk Help to Print tree structure +type trunk struct { + prev *trunk + str string +} + +func newTrunk(prev *trunk, str string) *trunk { + return &trunk{ + prev: prev, + str: str, + } +} + +func showTrunk(t *trunk) { + if t == nil { + return + } + + showTrunk(t.prev) + fmt.Print(t.str) +} diff --git a/codes/go/pkg/tree_node.go b/codes/go/pkg/tree_node.go index b62dc6056..2511a7655 100644 --- a/codes/go/pkg/tree_node.go +++ b/codes/go/pkg/tree_node.go @@ -6,7 +6,6 @@ package pkg import ( "container/list" - "fmt" ) type TreeNode struct { @@ -71,58 +70,3 @@ func TreeToArray(root *TreeNode) []any { } return arr } - -// PrintTree Print a binary tree -func PrintTree(root *TreeNode) { - printTreeHelper(root, nil, false) -} - -// printTreeHelper Help to print a binary tree, hide more details -// This tree printer is borrowed from TECHIE DELIGHT -// https://www.techiedelight.com/c-program-print-binary-tree/ -func printTreeHelper(root *TreeNode, prev *trunk, isLeft bool) { - if root == nil { - return - } - prevStr := " " - trunk := newTrunk(prev, prevStr) - printTreeHelper(root.Right, trunk, true) - if prev == nil { - trunk.str = "———" - } else if isLeft { - trunk.str = "/———" - prevStr = " |" - } else { - trunk.str = "\\———" - prev.str = prevStr - } - showTrunk(trunk) - fmt.Println(root.Val) - if prev != nil { - prev.str = prevStr - } - trunk.str = " |" - printTreeHelper(root.Left, trunk, false) -} - -// trunk Help to Print tree structure -type trunk struct { - prev *trunk - str string -} - -func newTrunk(prev *trunk, str string) *trunk { - return &trunk{ - prev: prev, - str: str, - } -} - -func showTrunk(t *trunk) { - if t == nil { - return - } - - showTrunk(t.prev) - fmt.Print(t.str) -} diff --git a/codes/go/pkg/tree_node_test.go b/codes/go/pkg/tree_node_test.go index ffbdf6ff0..b4c8e0773 100644 --- a/codes/go/pkg/tree_node_test.go +++ b/codes/go/pkg/tree_node_test.go @@ -4,7 +4,10 @@ package pkg -import "testing" +import ( + "fmt" + "testing" +) func TestTreeNode(t *testing.T) { arr := []int{2, 3, 5, 6, 7} @@ -14,5 +17,5 @@ func TestTreeNode(t *testing.T) { PrintTree(node) // tree to arr - t.Log(TreeToArray(node)) + fmt.Println(TreeToArray(node)) } diff --git a/codes/java/chapter_stack_and_queue/deque.java b/codes/java/chapter_stack_and_queue/deque.java index cdfe65bf7..a29e6e7c3 100644 --- a/codes/java/chapter_stack_and_queue/deque.java +++ b/codes/java/chapter_stack_and_queue/deque.java @@ -21,7 +21,7 @@ public class deque { deque.offerFirst(1); System.out.println("双向队列 deque = " + deque); - /* 访问队首元素 */ + /* 访问元素 */ int peekFirst = deque.peekFirst(); System.out.println("队首元素 peekFirst = " + peekFirst); int peekLast = deque.peekLast(); diff --git a/codes/javascript/chapter_array_and_linkedlist/array.js b/codes/javascript/chapter_array_and_linkedlist/array.js index a8294cc24..4cf1b29fa 100644 --- a/codes/javascript/chapter_array_and_linkedlist/array.js +++ b/codes/javascript/chapter_array_and_linkedlist/array.js @@ -7,7 +7,7 @@ /* 随机访问元素 */ function randomAccess(nums){ // 在区间 [0, nums.length) 中随机抽取一个数字 - const random_index = Math.floor(Math.random() * nums.length) + const random_index = Math.floor(Math.random() * nums.length) // 获取并返回随机元素 random_num = nums[random_index] return random_num diff --git a/codes/javascript/chapter_sorting/insertion_sort.js b/codes/javascript/chapter_sorting/insertion_sort.js index 9a6f119ba..02c45a237 100644 --- a/codes/javascript/chapter_sorting/insertion_sort.js +++ b/codes/javascript/chapter_sorting/insertion_sort.js @@ -21,4 +21,4 @@ function insertionSort(nums) { /* Driver Code */ var nums = [4, 1, 3, 1, 5, 2] insertionSort(nums) -console.log("排序后数组 nums = ", nums) +console.log("排序后数组 nums =", nums) diff --git a/codes/python/chapter_array_and_linkedlist/list.py b/codes/python/chapter_array_and_linkedlist/list.py index 4cd9b0312..ac71b98b8 100644 --- a/codes/python/chapter_array_and_linkedlist/list.py +++ b/codes/python/chapter_array_and_linkedlist/list.py @@ -33,7 +33,7 @@ if __name__ == "__main__": list.append(2) list.append(5) list.append(4) - print("添加元素后 list = ", list) + print("添加元素后 list =", list) """ 中间插入元素 """ list.insert(3, 6) diff --git a/codes/python/chapter_sorting/insertion_sort.py b/codes/python/chapter_sorting/insertion_sort.py index 9f3267388..db85515d1 100644 --- a/codes/python/chapter_sorting/insertion_sort.py +++ b/codes/python/chapter_sorting/insertion_sort.py @@ -25,4 +25,4 @@ def insertion_sort(nums): if __name__ == '__main__': nums = [4, 1, 3, 1, 5, 2] insertion_sort(nums) - print("排序后数组 nums = ", nums) + print("排序后数组 nums =", nums) diff --git a/codes/python/chapter_stack_and_queue/deque.py b/codes/python/chapter_stack_and_queue/deque.py index 8a68fe76f..7881a965e 100644 --- a/codes/python/chapter_stack_and_queue/deque.py +++ b/codes/python/chapter_stack_and_queue/deque.py @@ -26,7 +26,7 @@ if __name__ == "__main__": duque.appendleft(1) print("双向队列 duque =", duque) - """ 访问队首元素 """ + """ 访问元素 """ front = duque[0] # 队首元素 print("队首元素 front =", front) rear = duque[-1] # 队尾元素 diff --git a/docs/chapter_array_and_linkedlist/array.md b/docs/chapter_array_and_linkedlist/array.md index 74e2063f0..fcd7e450b 100644 --- a/docs/chapter_array_and_linkedlist/array.md +++ b/docs/chapter_array_and_linkedlist/array.md @@ -138,7 +138,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex /* 随机返回一个数组元素 */ function randomAccess(nums){ // 在区间 [0, nums.length) 中随机抽取一个数字 - const random_index = Math.floor(Math.random() * nums.length) + const random_index = Math.floor(Math.random() * nums.length) // 获取并返回随机元素 random_num = nums[random_index] return random_num diff --git a/docs/chapter_computational_complexity/space_complexity.md b/docs/chapter_computational_complexity/space_complexity.md index eda90137c..ac2c9df48 100644 --- a/docs/chapter_computational_complexity/space_complexity.md +++ b/docs/chapter_computational_complexity/space_complexity.md @@ -520,7 +520,7 @@ $$ ```python title="space_complexity_types.py" """ 线性阶（递归实现） """ def linearRecur(n): - print("递归 n = ", n) + print("递归 n =", n) if n == 1: return linearRecur(n - 1) ``` diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md index 555525207..9ee13d8db 100644 --- a/docs/chapter_computational_complexity/time_complexity.md +++ b/docs/chapter_computational_complexity/time_complexity.md @@ -15,7 +15,7 @@ comments: true 例如以下代码，输入数据大小为 $n$ ，根据以上方法，可以得到算法运行时间为 $6n + 12$ ns 。 $$ -1 + 1 + 10 + (1 + 5) \times n = 6n + 12 +1 + 1 + 10 + (1 + 5) \times n = 6n + 12 $$ === "Java" diff --git a/docs/chapter_stack_and_queue/deque.md b/docs/chapter_stack_and_queue/deque.md index 2ed2f289a..c764ca68b 100644 --- a/docs/chapter_stack_and_queue/deque.md +++ b/docs/chapter_stack_and_queue/deque.md @@ -46,7 +46,7 @@ comments: true deque.offerFirst(3); // 添加至队首 deque.offerFirst(1); - /* 访问队首元素 */ + /* 访问元素 */ int peekFirst = deque.peekFirst(); // 队首元素 int peekLast = deque.peekLast(); // 队尾元素 @@ -74,7 +74,7 @@ comments: true deque.push_front(3); // 添加至队首 deque.push_front(1); - /* 访问队首元素 */ + /* 访问元素 */ int front = deque.front(); // 队首元素 int back = deque.back(); // 队尾元素 @@ -102,7 +102,7 @@ comments: true duque.appendleft(3) # 添加至队首 duque.appendleft(1) - """ 访问队首元素 """ + """ 访问元素 """ front = duque[0] # 队首元素 rear = duque[-1] # 队尾元素 @@ -120,7 +120,30 @@ comments: true === "Go" ```go title="deque.go" + /* 初始化双向队列 */ + // 在 Go 中，将 list 作为双向队列使用 + deque := list.New() + /* 元素入队 */ + deque.PushBack(2) // 添加至队尾 + deque.PushBack(5) + deque.PushBack(4) + deque.PushFront(3) // 添加至队首 + deque.PushFront(1) + + /* 访问元素 */ + front := deque.Front() // 队首元素 + rear := deque.Back() // 队尾元素 + + /* 元素出队 */ + deque.Remove(front) // 队首元素出队 + deque.Remove(rear) // 队尾元素出队 + + /* 获取双向队列的长度 */ + size := deque.Len() + + /* 判断双向队列是否为空 */ + isEmpty := deque.Len() == 0 ``` === "JavaScript" diff --git a/docs/chapter_stack_and_queue/queue.md b/docs/chapter_stack_and_queue/queue.md index f443f21f0..a663b9745 100644 --- a/docs/chapter_stack_and_queue/queue.md +++ b/docs/chapter_stack_and_queue/queue.md @@ -115,7 +115,29 @@ comments: true === "Go" ```go title="queue.go" + /* 初始化队列 */ + // 在 Go 中，将 list 作为队列来使用 + queue := list.New() + /* 元素入队 */ + queue.PushBack(1) + queue.PushBack(3) + queue.PushBack(2) + queue.PushBack(5) + queue.PushBack(4) + + /* 访问队首元素 */ + peek := queue.Front() + + /* 元素出队 */ + poll := queue.Front() + queue.Remove(poll) + + /* 获取队列的长度 */ + size := queue.Len() + + /* 判断队列是否为空 */ + isEmpty := queue.Len() == 0 ``` === "JavaScript" @@ -309,7 +331,52 @@ comments: true === "Go" ```go title="linkedlist_queue.go" + /* 基于链表实现的队列 */ + type LinkedListQueue struct { + // 使用内置包 list 来实现队列 + data *list.List + } + // NewLinkedListQueue 初始化链表 + func NewLinkedListQueue() *LinkedListQueue { + return &LinkedListQueue{ + data: list.New(), + } + } + + // Offer 入队 + func (s *LinkedListQueue) Offer(value any) { + s.data.PushBack(value) + } + + // Poll 出队 + func (s *LinkedListQueue) Poll() any { + if s.IsEmpty() { + return nil + } + e := s.data.Front() + s.data.Remove(e) + return e.Value + } + + // Peek 访问队首元素 + func (s *LinkedListQueue) Peek() any { + if s.IsEmpty() { + return nil + } + e := s.data.Front() + return e.Value + } + + // Size 获取队列的长度 + func (s *LinkedListQueue) Size() int { + return s.data.Len() + } + + // IsEmpty 判断队列是否为空 + func (s *LinkedListQueue) IsEmpty() bool { + return s.data.Len() == 0 + } ``` === "JavaScript" @@ -540,7 +607,66 @@ comments: true === "Go" ```go title="array_queue.go" + /* 基于环形数组实现的队列 */ + type ArrayQueue struct { + data []int // 用于存储队列元素的数组 + capacity int // 队列容量（即最多容量的元素个数） + front int // 头指针，指向队首 + rear int // 尾指针，指向队尾 + 1 + } + // NewArrayQueue 基于环形数组实现的队列 + func NewArrayQueue(capacity int) *ArrayQueue { + return &ArrayQueue{ + data: make([]int, capacity), + capacity: capacity, + front: 0, + rear: 0, + } + } + + // Size 获取队列的长度 + func (q *ArrayQueue) Size() int { + size := (q.capacity + q.rear - q.front) % q.capacity + return size + } + + // IsEmpty 判断队列是否为空 + func (q *ArrayQueue) IsEmpty() bool { + return q.rear-q.front == 0 + } + + // Offer 入队 + func (q *ArrayQueue) Offer(v int) { + // 当 rear == capacity 表示队列已满 + if q.Size() == q.capacity { + return + } + // 尾结点后添加 + q.data[q.rear] = v + // 尾指针向后移动一位，越过尾部后返回到数组头部 + q.rear = (q.rear + 1) % q.capacity + } + + // Poll 出队 + func (q *ArrayQueue) Poll() any { + if q.IsEmpty() { + return nil + } + v := q.data[q.front] + // 队头指针向后移动一位，若越过尾部则返回到数组头部 + q.front = (q.front + 1) % q.capacity + return v + } + + // Peek 访问队首元素 + func (q *ArrayQueue) Peek() any { + if q.IsEmpty() { + return nil + } + v := q.data[q.front] + return v + } ``` === "JavaScript" diff --git a/docs/chapter_stack_and_queue/stack.md b/docs/chapter_stack_and_queue/stack.md index c2a1ad14d..80870a078 100644 --- a/docs/chapter_stack_and_queue/stack.md +++ b/docs/chapter_stack_and_queue/stack.md @@ -115,7 +115,29 @@ comments: true === "Go" ```go title="stack.go" + /* 初始化栈 */ + // 在 Go 中，推荐将 Slice 当作栈来使用 + var stack []int + /* 元素入栈 */ + stack = append(stack, 1) + stack = append(stack, 3) + stack = append(stack, 2) + stack = append(stack, 5) + stack = append(stack, 4) + + /* 访问栈顶元素 */ + peek := stack[len(stack)-1] + + /* 元素出栈 */ + pop := stack[len(stack)-1] + stack = stack[:len(stack)-1] + + /* 获取栈的长度 */ + size := len(stack) + + /* 判断是否为空 */ + isEmpty := len(stack) == 0 ``` === "JavaScript" @@ -282,7 +304,52 @@ comments: true === "Go" ```go title="linkedlist_stack.go" + /* 基于链表实现的栈 */ + type LinkedListStack struct { + // 使用内置包 list 来实现栈 + data *list.List + } + // NewLinkedListStack 初始化链表 + func NewLinkedListStack() *LinkedListStack { + return &LinkedListStack{ + data: list.New(), + } + } + + // Push 入栈 + func (s *LinkedListStack) Push(value int) { + s.data.PushBack(value) + } + + // Pop 出栈 + func (s *LinkedListStack) Pop() any { + if s.IsEmpty() { + return nil + } + e := s.data.Back() + s.data.Remove(e) + return e.Value + } + + // Peek 访问栈顶元素 + func (s *LinkedListStack) Peek() any { + if s.IsEmpty() { + return nil + } + e := s.data.Back() + return e.Value + } + + // Size 获取栈的长度 + func (s *LinkedListStack) Size() int { + return s.data.Len() + } + + // IsEmpty 判断栈是否为空 + func (s *LinkedListStack) IsEmpty() bool { + return s.data.Len() == 0 + } ``` === "JavaScript" @@ -426,7 +493,53 @@ comments: true === "Go" ```go title="array_stack.go" + /* 基于数组实现的栈 */ + type ArrayStack struct { + data []int // 数据 + } + func NewArrayStack() *ArrayStack { + return &ArrayStack{ + // 设置栈的长度为 0，容量为 16 + data: make([]int, 0, 16), + } + } + + // Size 栈的长度 + func (s *ArrayStack) Size() int { + return len(s.data) + } + + // IsEmpty 栈是否为空 + func (s *ArrayStack) IsEmpty() bool { + return s.Size() == 0 + } + + // Push 入栈 + func (s *ArrayStack) Push(v int) { + // 切片会自动扩容 + s.data = append(s.data, v) + } + + // Pop 出栈 + func (s *ArrayStack) Pop() any { + // 弹出栈前，先判断是否为空 + if s.IsEmpty() { + return nil + } + val := s.Peek() + s.data = s.data[:len(s.data)-1] + return val + } + + // Peek 获取栈顶元素 + func (s *ArrayStack) Peek() any { + if s.IsEmpty() { + return nil + } + val := s.data[len(s.data)-1] + return val + } ``` === "JavaScript" diff --git a/docs/chapter_tree/binary_search_tree.md b/docs/chapter_tree/binary_search_tree.md index a1554e96d..30d392999 100644 --- a/docs/chapter_tree/binary_search_tree.md +++ b/docs/chapter_tree/binary_search_tree.md @@ -88,7 +88,25 @@ comments: true === "Go" ```go title="binary_search_tree.go" - + /* 查找结点 */ + func (bst *BinarySearchTree) Search(num int) *TreeNode { + node := bst.root + // 循环查找，越过叶结点后跳出 + for node != nil { + if node.Val < num { + // 目标结点在 root 的右子树中 + node = node.Right + } else if node.Val > num { + // 目标结点在 root 的左子树中 + node = node.Left + } else { + // 找到目标结点，跳出循环 + break + } + } + // 返回目标结点 + return node + } ``` === "JavaScript" @@ -187,7 +205,36 @@ comments: true === "Go" ```go title="binary_search_tree.go" - + /* 插入结点 */ + func (bst *BinarySearchTree) Insert(num int) *TreeNode { + cur := bst.root + // 若树为空，直接提前返回 + if cur == nil { + return nil + } + // 待插入结点之前的结点位置 + var prev *TreeNode = nil + // 循环查找，越过叶结点后跳出 + for cur != nil { + if cur.Val == num { + return nil + } + prev = cur + if cur.Val < num { + cur = cur.Right + } else { + cur = cur.Left + } + } + // 插入结点 + node := NewTreeNode(num) + if prev.Val < num { + prev.Right = node + } else { + prev.Left = node + } + return cur + } ``` === "JavaScript" @@ -365,7 +412,60 @@ comments: true === "Go" ```go title="binary_search_tree.go" - + /* 删除结点 */ + func (bst *BinarySearchTree) Remove(num int) *TreeNode { + cur := bst.root + // 若树为空，直接提前返回 + if cur == nil { + return nil + } + // 待删除结点之前的结点位置 + var prev *TreeNode = nil + // 循环查找，越过叶结点后跳出 + for cur != nil { + if cur.Val == num { + break + } + prev = cur + if cur.Val < num { + // 待删除结点在右子树中 + cur = cur.Right + } else { + // 待删除结点在左子树中 + cur = cur.Left + } + } + // 若无待删除结点，则直接返回 + if cur == nil { + return nil + } + // 子结点数为 0 或 1 + if cur.Left == nil || cur.Right == nil { + var child *TreeNode = nil + // 取出待删除结点的子结点 + if cur.Left != nil { + child = cur.Left + } else { + child = cur.Right + } + // 将子结点替换为待删除结点 + if prev.Left == cur { + prev.Left = child + } else { + prev.Right = child + } + // 子结点数为 2 + } else { + // 获取中序遍历中待删除结点 cur 的下一个结点 + next := bst.GetInorderNext(cur) + temp := next.Val + // 递归删除结点 next + bst.Remove(next.Val) + // 将 next 的值复制给 cur + cur.Val = temp + } + return cur + } ``` === "JavaScript" diff --git a/docs/chapter_tree/binary_tree.md b/docs/chapter_tree/binary_tree.md index 2fd44c3cc..d7c35d928 100644 --- a/docs/chapter_tree/binary_tree.md +++ b/docs/chapter_tree/binary_tree.md @@ -44,7 +44,20 @@ comments: true === "Go" ```go title="" - + """ 链表结点类 """ + type TreeNode struct { + Val int + Left *TreeNode + Right *TreeNode + } + """ 结点初始化方法 """ + func NewTreeNode(v int) *TreeNode { + return &TreeNode{ + Left: nil, + Right: nil, + Val: v, + } + } ``` === "JavaScript" @@ -163,7 +176,18 @@ comments: true === "Go" ```go title="binary_tree.go" - + /* 初始化二叉树 */ + // 初始化结点 + n1 := NewTreeNode(1) + n2 := NewTreeNode(2) + n3 := NewTreeNode(3) + n4 := NewTreeNode(4) + n5 := NewTreeNode(5) + // 构建引用指向（即指针） + n1.Left = n2 + n1.Right = n3 + n2.Left = n4 + n2.Right = n5 ``` === "JavaScript" @@ -228,7 +252,14 @@ comments: true === "Go" ```go title="binary_tree.go" + /* 插入与删除结点 */ + // 在 n1 -> n2 中间插入结点 P + p := NewTreeNode(0) + n1.Left = p + p.Left = n2 + // 删除结点 P + n1.Left = n2 ``` === "JavaScript" @@ -328,7 +359,29 @@ comments: true === "Go" ```go title="binary_tree_bfs.go" - + /* 层序遍历 */ + func levelOrder(root *TreeNode) []int { + // 初始化队列，加入根结点 + queue := list.New() + queue.PushBack(root) + // 初始化一个切片，用于保存遍历序列 + nums := make([]int, 0) + for queue.Len() > 0 { + // poll + node := queue.Remove(queue.Front()).(*TreeNode) + // 保存结点 + nums = append(nums, node.Val) + if node.Left != nil { + // 左子结点入队 + queue.PushBack(node.Left) + } + if node.Right != nil { + // 右子结点入队 + queue.PushBack(node.Right) + } + } + return nums + } ``` === "JavaScript" @@ -446,7 +499,38 @@ comments: true === "Go" ```go title="binary_tree_dfs.go" + /* 前序遍历 */ + func preOrder(node *TreeNode) { + if node == nil { + return + } + // 访问优先级：根结点 -> 左子树 -> 右子树 + nums = append(nums, node.Val) + preOrder(node.Left) + preOrder(node.Right) + } + /* 中序遍历 */ + func inOrder(node *TreeNode) { + if node == nil { + return + } + // 访问优先级：左子树 -> 根结点 -> 右子树 + inOrder(node.Left) + nums = append(nums, node.Val) + inOrder(node.Right) + } + + /* 后序遍历 */ + func postOrder(node *TreeNode) { + if node == nil { + return + } + // 访问优先级：左子树 -> 右子树 -> 根结点 + postOrder(node.Left) + postOrder(node.Right) + nums = append(nums, node.Val) + } ``` === "JavaScript" From 2876d3ac90632d48d7f4f9c7dbd205b71116396d Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Sat, 3 Dec 2022 21:36:51 +0800 Subject: [PATCH 47/67] Update readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index d495c0a7b..bac0bf373 100644 --- a/README.md +++ b/README.md @@ -58,7 +58,7 @@ ## To-Dos -- [x] [代码翻译](https://github.com/krahets/hello-algo/issues/15)（JavaScript, TypeScript, C, C++, C#, ... 寻求大佬帮助） +- [x] [代码翻译](https://github.com/krahets/hello-algo/issues/15)：Java, C++, Python, Go, JavaScript 正在进行中，其他语言请求大佬挑大梁 - [ ] 数据结构：散列表、堆（优先队列）、图 - [ ] 算法：搜索与回溯、选择 / 堆排序、动态规划、贪心、分治 From 5b051fd48a9803bc8b9fb5850f0a58fac49339ea Mon Sep 17 00:00:00 2001 From: timi <63904151+Boy-timi@users.noreply.github.com> Date: Sat, 3 Dec 2022 22:52:58 +0800 Subject: [PATCH 48/67] Update binary_search.py --- .../python/chapter_searching/binary_search.py | 46 ++++++++++++++++++- 1 file changed, 44 insertions(+), 2 deletions(-) diff --git a/codes/python/chapter_searching/binary_search.py b/codes/python/chapter_searching/binary_search.py index 709a2b698..915573f62 100644 --- a/codes/python/chapter_searching/binary_search.py +++ b/codes/python/chapter_searching/binary_search.py @@ -1,10 +1,52 @@ ''' File: binary_search.py -Created Time: 2022-11-25 -Author: Krahets (krahets@163.com) +Created Time: 2022-11-26 +Author: timi (xisunyy@163.com) ''' import sys, os.path as osp + sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__)))) from include import * +""" 二分查找（双闭区间） """ +def binary_search(nums, target): + # 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素 + i, j = 0, len(nums) - 1 + while i <= j: + m = (i + j) // 2 # 计算中点索引 m + if nums[m] < target: # 此情况说明 target 在区间 [m+1, j] 中 + i = m + 1 + elif nums[m] > target: # 此情况说明 target 在区间 [i, m-1] 中 + j = m - 1 + else: + return m # 找到目标元素，返回其索引 + return -1 # 未找到目标元素，返回 -1 + + +""" 二分查找（左闭右开） """ +def binary_search1(nums, target): + # 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1 + i, j = 0, len(nums) + # 循环，当搜索区间为空时跳出（当 i = j 时为空） + while i < j: + m = (i + j) // 2 # 计算中点索引 m + if nums[m] < target: # 此情况说明 target 在区间 [m+1, j) 中 + i = m + 1 + elif nums[m] > target: # 此情况说明 target 在区间 [i, m) 中 + j = m + else: # 找到目标元素，返回其索引 + return m + return -1 # 未找到目标元素，返回 -1 + + +if __name__ == '__main__': + target = 6 + nums = [1, 3, 6, 8, 12, 15, 23, 67, 70, 92] + + # 二分查找（双闭区间） + index = binary_search(nums, target) + print("目标元素 6 的索引 = ", index) + # 二分查找（左闭右开） + index = binary_search1(nums, target) + print("目标元素 6 的索引 = ", index) From 255701db90d1d1d011ff7b46b374fc51c3d9d8d2 Mon Sep 17 00:00:00 2001 From: timi <63904151+Boy-timi@users.noreply.github.com> Date: Sat, 3 Dec 2022 22:53:53 +0800 Subject: [PATCH 49/67] Update hashing_search.py --- .../chapter_searching/hashing_search.py | 35 +++++++++++++++++-- 1 file changed, 33 insertions(+), 2 deletions(-) diff --git a/codes/python/chapter_searching/hashing_search.py b/codes/python/chapter_searching/hashing_search.py index 90de74f22..fab8f3480 100644 --- a/codes/python/chapter_searching/hashing_search.py +++ b/codes/python/chapter_searching/hashing_search.py @@ -1,10 +1,41 @@ ''' File: hashing_search.py -Created Time: 2022-11-25 -Author: Krahets (krahets@163.com) +Created Time: 2022-11-26 +Author: timi (xisunyy@163.com) ''' import sys, os.path as osp sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__)))) from include import * +""" 哈希查找（数组） """ +def hashing_search(map,target): + # 哈希表的 key: 目标元素，value: 索引 + # 若哈希表中无此 key ，返回 -1 + return map.get(target,-1) + +""" 哈希查找（链表） """ +def hashing_search1(map,target): + # 哈希表的 key: 目标元素，value: 节点对象 + # 若哈希表中无此 key ，返回 -1 + return map.get(target,-1) + +if __name__=='__main__': + target=3 + # 哈希查找（数组） + nums=[1, 5, 3, 2, 4, 7, 5, 9, 10, 8] + map=dict() # 初始化哈希表 + for i in range(len(nums)): + map[nums[i]]=i # key: 元素，value: 索引 + index=hashing_search(map,target) + print("目标元素 3 的索引 = " ,index) + + # 哈希查找（链表） + head=list_to_linked_list(nums) + map1=dict() # 初始化哈希表 + while head: + map1[head.val]=head # key: 结点值，value: 结点 + head=head.next + + node=hashing_search1(map1,target) + print("目标结点值 3 的对应结点对象为 " , node) From 91200f0add62d4b4bb09b29484eb1c543f444b40 Mon Sep 17 00:00:00 2001 From: timi <63904151+Boy-timi@users.noreply.github.com> Date: Sat, 3 Dec 2022 22:54:19 +0800 Subject: [PATCH 50/67] Update linear_search.py --- .../python/chapter_searching/linear_search.py | 32 +++++++++++++++++-- 1 file changed, 30 insertions(+), 2 deletions(-) diff --git a/codes/python/chapter_searching/linear_search.py b/codes/python/chapter_searching/linear_search.py index 961e75fb0..d423dadb8 100644 --- a/codes/python/chapter_searching/linear_search.py +++ b/codes/python/chapter_searching/linear_search.py @@ -1,10 +1,38 @@ ''' File: linear_search.py -Created Time: 2022-11-25 -Author: Krahets (krahets@163.com) +Created Time: 2022-11-26 +Author: timi (xisunyy@163.com) ''' import sys, os.path as osp sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__)))) from include import * +""" 线性查找（数组） """ +def linear_search(nums,target): + # 遍历数组 + for i in range(len(nums)): + if nums[i]==target: # 找到目标元素，返回其索引 + return i + return -1 # 未找到目标元素，返回 -1 + +""" 线性查找（链表） """ +def linear_search_by_link(head,target): + # 遍历链表 + while head: + if head.val==target: # 找到目标结点，返回之 + return head + head=head.next + return None # 未找到目标结点，返回 None (Python为None) + +if __name__=='__main__': + target=3 + # 在数组中执行线性查找 + nums=[1, 5, 3, 2, 4, 7, 5, 9, 10, 8] + index=linear_search(nums,target) + print("目标元素 3 的索引 = " ,index) + + # 在链表中执行线性查找 + head=list_to_linked_list(nums) + node=linear_search_by_link(head,target) + print("目标结点值 3 的对应结点对象为 " ,node) From 7e880d47f11cbc23c3ab58ffd5aefc75d23c1ec1 Mon Sep 17 00:00:00 2001 From: timi <63904151+Boy-timi@users.noreply.github.com> Date: Sat, 3 Dec 2022 22:57:05 +0800 Subject: [PATCH 51/67] Update binary_search.py --- codes/python/chapter_searching/binary_search.py | 1 - 1 file changed, 1 deletion(-) diff --git a/codes/python/chapter_searching/binary_search.py b/codes/python/chapter_searching/binary_search.py index 915573f62..0f3747843 100644 --- a/codes/python/chapter_searching/binary_search.py +++ b/codes/python/chapter_searching/binary_search.py @@ -5,7 +5,6 @@ Author: timi (xisunyy@163.com) ''' import sys, os.path as osp - sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__)))) from include import * From cf628007c85fa45f69dc8970aa106d995d515ea3 Mon Sep 17 00:00:00 2001 From: S-N-O-R-L-A-X <10195101536@stu.ecnu.edu.cn> Date: Sat, 3 Dec 2022 23:00:13 +0800 Subject: [PATCH 52/67] Update stack.md add javascript and typescript for stack --- docs/chapter_stack_and_queue/stack.md | 42 +++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/docs/chapter_stack_and_queue/stack.md b/docs/chapter_stack_and_queue/stack.md index 80870a078..317bfe66b 100644 --- a/docs/chapter_stack_and_queue/stack.md +++ b/docs/chapter_stack_and_queue/stack.md @@ -143,13 +143,55 @@ comments: true === "JavaScript" ```js title="stack.js" + /* 初始化栈 */ + // Javascript 没有内置的栈类，可以把 Array 当作栈来使用 + const stack = []; + /* 元素入栈 */ + stack.push(1); + stack.push(3); + stack.push(2); + stack.push(5); + stack.push(4); + + /* 访问栈顶元素 */ + peek = stack[stack.length-1]; + + /* 元素出栈 */ + pop = stack.pop(); + + /* 获取栈的长度 */ + size = stack.length; + + /* 判断是否为空 */ + is_empty = stack.length === 0; ``` === "TypeScript" ```typescript title="stack.ts" + /* 初始化栈 */ + // Typescript 没有内置的栈类，可以把 Array 当作栈来使用 + const stack:number[] = []; + /* 元素入栈 */ + stack.push(1); + stack.push(3); + stack.push(2); + stack.push(5); + stack.push(4); + + /* 访问栈顶元素 */ + peek = stack[stack.length-1]; + + /* 元素出栈 */ + pop = stack.pop(); + + /* 获取栈的长度 */ + size = stack.length; + + /* 判断是否为空 */ + is_empty = stack.length === 0; ``` === "C" From 8e34be06413e75010f3b96c34fafecb0b24317a2 Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Sun, 4 Dec 2022 01:43:58 +0800 Subject: [PATCH 53/67] Add Python code (Chapter of searching) to the docs. --- .../python/chapter_searching/binary_search.py | 18 ++++---- .../chapter_searching/hashing_search.py | 42 ++++++++++--------- .../python/chapter_searching/linear_search.py | 35 +++++++++------- docs/chapter_searching/binary_search.md | 33 +++++++++++++-- docs/chapter_searching/hashing_search.md | 12 +++++- docs/chapter_searching/linear_search.md | 17 +++++++- 6 files changed, 106 insertions(+), 51 deletions(-) diff --git a/codes/python/chapter_searching/binary_search.py b/codes/python/chapter_searching/binary_search.py index 0f3747843..3d9ee0ffc 100644 --- a/codes/python/chapter_searching/binary_search.py +++ b/codes/python/chapter_searching/binary_search.py @@ -13,14 +13,14 @@ def binary_search(nums, target): # 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素 i, j = 0, len(nums) - 1 while i <= j: - m = (i + j) // 2 # 计算中点索引 m - if nums[m] < target: # 此情况说明 target 在区间 [m+1, j] 中 + m = (i + j) // 2 # 计算中点索引 m + if nums[m] < target: # 此情况说明 target 在区间 [m+1, j] 中 i = m + 1 elif nums[m] > target: # 此情况说明 target 在区间 [i, m-1] 中 j = m - 1 else: - return m # 找到目标元素，返回其索引 - return -1 # 未找到目标元素，返回 -1 + return m # 找到目标元素，返回其索引 + return -1 # 未找到目标元素，返回 -1 """ 二分查找（左闭右开） """ @@ -29,16 +29,17 @@ def binary_search1(nums, target): i, j = 0, len(nums) # 循环，当搜索区间为空时跳出（当 i = j 时为空） while i < j: - m = (i + j) // 2 # 计算中点索引 m - if nums[m] < target: # 此情况说明 target 在区间 [m+1, j) 中 + m = (i + j) // 2 # 计算中点索引 m + if nums[m] < target: # 此情况说明 target 在区间 [m+1, j) 中 i = m + 1 elif nums[m] > target: # 此情况说明 target 在区间 [i, m) 中 j = m - else: # 找到目标元素，返回其索引 + else: # 找到目标元素，返回其索引 return m - return -1 # 未找到目标元素，返回 -1 + return -1 # 未找到目标元素，返回 -1 +""" Driver Code """ if __name__ == '__main__': target = 6 nums = [1, 3, 6, 8, 12, 15, 23, 67, 70, 92] @@ -46,6 +47,7 @@ if __name__ == '__main__': # 二分查找（双闭区间） index = binary_search(nums, target) print("目标元素 6 的索引 = ", index) + # 二分查找（左闭右开） index = binary_search1(nums, target) print("目标元素 6 的索引 = ", index) diff --git a/codes/python/chapter_searching/hashing_search.py b/codes/python/chapter_searching/hashing_search.py index fab8f3480..68cffe64a 100644 --- a/codes/python/chapter_searching/hashing_search.py +++ b/codes/python/chapter_searching/hashing_search.py @@ -9,33 +9,37 @@ sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__)))) from include import * """ 哈希查找（数组） """ -def hashing_search(map,target): +def hashing_search(mapp, target): # 哈希表的 key: 目标元素，value: 索引 # 若哈希表中无此 key ，返回 -1 - return map.get(target,-1) + return mapp.get(target, -1) """ 哈希查找（链表） """ -def hashing_search1(map,target): - # 哈希表的 key: 目标元素，value: 节点对象 +def hashing_search1(mapp, target): + # 哈希表的 key: 目标元素，value: 结点对象 # 若哈希表中无此 key ，返回 -1 - return map.get(target,-1) + return mapp.get(target, -1) -if __name__=='__main__': - target=3 + +""" Driver Code """ +if __name__ == '__main__': + target = 3 + # 哈希查找（数组） - nums=[1, 5, 3, 2, 4, 7, 5, 9, 10, 8] - map=dict() # 初始化哈希表 + nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8] + # 初始化哈希表 + mapp = {} for i in range(len(nums)): - map[nums[i]]=i # key: 元素，value: 索引 - index=hashing_search(map,target) - print("目标元素 3 的索引 = " ,index) + mapp[nums[i]] = i # key: 元素，value: 索引 + index = hashing_search(mapp, target) + print("目标元素 3 的索引 =", index) # 哈希查找（链表） - head=list_to_linked_list(nums) - map1=dict() # 初始化哈希表 + head = list_to_linked_list(nums) + # 初始化哈希表 + map1 = {} while head: - map1[head.val]=head # key: 结点值，value: 结点 - head=head.next - - node=hashing_search1(map1,target) - print("目标结点值 3 的对应结点对象为 " , node) + map1[head.val] = head # key: 结点值，value: 结点 + head = head.next + node = hashing_search1(map1, target) + print("目标结点值 3 的对应结点对象为", node) diff --git a/codes/python/chapter_searching/linear_search.py b/codes/python/chapter_searching/linear_search.py index d423dadb8..933095653 100644 --- a/codes/python/chapter_searching/linear_search.py +++ b/codes/python/chapter_searching/linear_search.py @@ -9,30 +9,33 @@ sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__)))) from include import * """ 线性查找（数组） """ -def linear_search(nums,target): +def linear_search(nums, target): # 遍历数组 for i in range(len(nums)): - if nums[i]==target: # 找到目标元素，返回其索引 + if nums[i] == target: # 找到目标元素，返回其索引 return i - return -1 # 未找到目标元素，返回 -1 + return -1 # 未找到目标元素，返回 -1 """ 线性查找（链表） """ -def linear_search_by_link(head,target): +def linear_search1(head, target): # 遍历链表 while head: - if head.val==target: # 找到目标结点，返回之 - return head - head=head.next - return None # 未找到目标结点，返回 None (Python为None) + if head.val == target: # 找到目标结点，返回之 + return head + head = head.next + return None # 未找到目标结点，返回 None -if __name__=='__main__': - target=3 + +""" Driver Code """ +if __name__ == '__main__': + target = 3 + # 在数组中执行线性查找 - nums=[1, 5, 3, 2, 4, 7, 5, 9, 10, 8] - index=linear_search(nums,target) - print("目标元素 3 的索引 = " ,index) + nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8] + index = linear_search(nums, target) + print("目标元素 3 的索引 =", index) # 在链表中执行线性查找 - head=list_to_linked_list(nums) - node=linear_search_by_link(head,target) - print("目标结点值 3 的对应结点对象为 " ,node) + head = list_to_linked_list(nums) + node = linear_search1(head, target) + print("目标结点值 3 的对应结点对象为", node) diff --git a/docs/chapter_searching/binary_search.md b/docs/chapter_searching/binary_search.md index bd3b109b0..1333faf0f 100644 --- a/docs/chapter_searching/binary_search.md +++ b/docs/chapter_searching/binary_search.md @@ -105,7 +105,19 @@ $$ === "Python" ```python title="binary_search.py" - + """ 二分查找（双闭区间） """ + def binary_search(nums, target): + # 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素 + i, j = 0, len(nums) - 1 + while i <= j: + m = (i + j) // 2 # 计算中点索引 m + if nums[m] < target: # 此情况说明 target 在区间 [m+1, j] 中 + i = m + 1 + elif nums[m] > target: # 此情况说明 target 在区间 [i, m-1] 中 + j = m - 1 + else: + return m # 找到目标元素，返回其索引 + return -1 # 未找到目标元素，返回 -1 ``` === "Go" @@ -189,7 +201,20 @@ $$ === "Python" ```python title="binary_search.py" - + """ 二分查找（左闭右开） """ + def binary_search1(nums, target): + # 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1 + i, j = 0, len(nums) + # 循环，当搜索区间为空时跳出（当 i = j 时为空） + while i < j: + m = (i + j) // 2 # 计算中点索引 m + if nums[m] < target: # 此情况说明 target 在区间 [m+1, j) 中 + i = m + 1 + elif nums[m] > target: # 此情况说明 target 在区间 [i, m) 中 + j = m + else: # 找到目标元素，返回其索引 + return m + return -1 # 未找到目标元素，返回 -1 ``` === "Go" @@ -262,8 +287,8 @@ $$ === "Python" ```py title="" - # Python 中的数字理论上可以无限大（取决于内存） - # 因此无需考虑大数越界问题 + # Python 中的数字理论上可以无限大（取决于内存大小） + # 因此无需考虑大数越界问题 ``` === "Go" diff --git a/docs/chapter_searching/hashing_search.md b/docs/chapter_searching/hashing_search.md index f269c4efa..d00fc21bd 100644 --- a/docs/chapter_searching/hashing_search.md +++ b/docs/chapter_searching/hashing_search.md @@ -43,7 +43,11 @@ comments: true === "Python" ```python title="hashing_search.py" - + """ 哈希查找（数组） """ + def hashing_search(mapp, target): + # 哈希表的 key: 目标元素，value: 索引 + # 若哈希表中无此 key ，返回 -1 + return mapp.get(target, -1) ``` === "Go" @@ -107,7 +111,11 @@ comments: true === "Python" ```python title="hashing_search.py" - + """ 哈希查找（链表） """ + def hashing_search1(mapp, target): + # 哈希表的 key: 目标元素，value: 结点对象 + # 若哈希表中无此 key ，返回 -1 + return mapp.get(target, -1) ``` === "Go" diff --git a/docs/chapter_searching/linear_search.md b/docs/chapter_searching/linear_search.md index ba3024875..e635c7d0e 100644 --- a/docs/chapter_searching/linear_search.md +++ b/docs/chapter_searching/linear_search.md @@ -47,7 +47,13 @@ comments: true === "Python" ```python title="linear_search.py" - + """ 线性查找（数组） """ + def linear_search(nums, target): + # 遍历数组 + for i in range(len(nums)): + if nums[i] == target: # 找到目标元素，返回其索引 + return i + return -1 # 未找到目标元素，返回 -1 ``` === "Go" @@ -119,7 +125,14 @@ comments: true === "Python" ```python title="linear_search.py" - + """ 线性查找（链表） """ + def linear_search1(head, target): + # 遍历链表 + while head: + if head.val == target: # 找到目标结点，返回之 + return head + head = head.next + return None # 未找到目标结点，返回 None ``` === "Go" From 33fd86cf6006a1ee36526bbf16142dc700c6debb Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Sun, 4 Dec 2022 03:46:28 +0800 Subject: [PATCH 54/67] Correct a concept. --- docs/chapter_tree/binary_tree_types.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/chapter_tree/binary_tree_types.md b/docs/chapter_tree/binary_tree_types.md index 7e1c523a1..b5879b4ec 100644 --- a/docs/chapter_tree/binary_tree_types.md +++ b/docs/chapter_tree/binary_tree_types.md @@ -37,7 +37,7 @@ comments: true ## 平衡二叉树 -**「平衡二叉树 Balanced Binary Tree」，又称「AVL 树」** ，其任意结点的左子树和右子树的高度之差的绝对值 $\leq 1$ 。 +**「平衡二叉树 Balanced Binary Tree」** ，其任意结点的左子树和右子树的高度之差的绝对值 $\leq 1$ 。 ![balanced_binary_tree](binary_tree_types.assets/balanced_binary_tree.png) From 75fa643113df0f08a4c8adaf00a7abbb5e9f4664 Mon Sep 17 00:00:00 2001 From: S-N-O-R-L-A-X Date: Sun, 4 Dec 2022 10:14:51 +0800 Subject: [PATCH 55/67] feat: add code in js --- .../chapter_stack_and_queue/stack.js | 28 +++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 codes/javascript/chapter_stack_and_queue/stack.js diff --git a/codes/javascript/chapter_stack_and_queue/stack.js b/codes/javascript/chapter_stack_and_queue/stack.js new file mode 100644 index 000000000..1b2e83b0e --- /dev/null +++ b/codes/javascript/chapter_stack_and_queue/stack.js @@ -0,0 +1,28 @@ +/** + * File: stack.js + * Created Time: 2022-12-04 + * Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com) + */ + +/* 初始化栈 */ +// Javascript 没有内置的栈类，可以把 Array 当作栈来使用 +const stack = []; + +/* 元素入栈 */ +stack.push(1); +stack.push(3); +stack.push(2); +stack.push(5); +stack.push(4); + +/* 访问栈顶元素 */ +peek = stack[stack.length - 1]; + +/* 元素出栈 */ +pop = stack.pop(); + +/* 获取栈的长度 */ +size = stack.length; + +/* 判断是否为空 */ +is_empty = stack.length === 0; From b4991254dfe6bb77a8b31dc21ad53552979b0cf2 Mon Sep 17 00:00:00 2001 From: S-N-O-R-L-A-X Date: Sun, 4 Dec 2022 10:17:18 +0800 Subject: [PATCH 56/67] feat: add code in ts --- .../chapter_stack_and_queue/stack.ts | 30 +++++++++++++++++++ docs/chapter_stack_and_queue/stack.md | 10 +++---- 2 files changed, 35 insertions(+), 5 deletions(-) create mode 100644 codes/typescript/chapter_stack_and_queue/stack.ts diff --git a/codes/typescript/chapter_stack_and_queue/stack.ts b/codes/typescript/chapter_stack_and_queue/stack.ts new file mode 100644 index 000000000..a6d2a5188 --- /dev/null +++ b/codes/typescript/chapter_stack_and_queue/stack.ts @@ -0,0 +1,30 @@ +/** + * File: stack.ts + * Created Time: 2022-12-04 + * Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com) + */ + +/* 初始化栈 */ +// Typescript 没有内置的栈类，可以把 Array 当作栈来使用 +const stack: number[] = []; + +/* 元素入栈 */ +stack.push(1); +stack.push(3); +stack.push(2); +stack.push(5); +stack.push(4); + +/* 访问栈顶元素 */ +const peek = stack[stack.length - 1]; + +/* 元素出栈 */ +const pop = stack.pop(); + +/* 获取栈的长度 */ +const size = stack.length; + +/* 判断是否为空 */ +const is_empty = stack.length === 0; + +export { }; \ No newline at end of file diff --git a/docs/chapter_stack_and_queue/stack.md b/docs/chapter_stack_and_queue/stack.md index 317bfe66b..d738598d5 100644 --- a/docs/chapter_stack_and_queue/stack.md +++ b/docs/chapter_stack_and_queue/stack.md @@ -172,7 +172,7 @@ comments: true ```typescript title="stack.ts" /* 初始化栈 */ // Typescript 没有内置的栈类，可以把 Array 当作栈来使用 - const stack:number[] = []; + const stack: number[] = []; /* 元素入栈 */ stack.push(1); @@ -182,16 +182,16 @@ comments: true stack.push(4); /* 访问栈顶元素 */ - peek = stack[stack.length-1]; + const peek = stack[stack.length - 1]; /* 元素出栈 */ - pop = stack.pop(); + const pop = stack.pop(); /* 获取栈的长度 */ - size = stack.length; + const size = stack.length; /* 判断是否为空 */ - is_empty = stack.length === 0; + const is_empty = stack.length === 0; ``` === "C" From a841a6fe42b54e22789cce4deddb1eea4a601560 Mon Sep 17 00:00:00 2001 From: S-N-O-R-L-A-X Date: Sun, 4 Dec 2022 10:22:18 +0800 Subject: [PATCH 57/67] fix: use const to declare variables in js --- codes/javascript/chapter_stack_and_queue/stack.js | 8 ++++---- docs/chapter_stack_and_queue/stack.md | 8 ++++---- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/codes/javascript/chapter_stack_and_queue/stack.js b/codes/javascript/chapter_stack_and_queue/stack.js index 1b2e83b0e..9afbdc2c1 100644 --- a/codes/javascript/chapter_stack_and_queue/stack.js +++ b/codes/javascript/chapter_stack_and_queue/stack.js @@ -16,13 +16,13 @@ stack.push(5); stack.push(4); /* 访问栈顶元素 */ -peek = stack[stack.length - 1]; +const peek = stack[stack.length - 1]; /* 元素出栈 */ -pop = stack.pop(); +const pop = stack.pop(); /* 获取栈的长度 */ -size = stack.length; +const size = stack.length; /* 判断是否为空 */ -is_empty = stack.length === 0; +const is_empty = stack.length === 0; diff --git a/docs/chapter_stack_and_queue/stack.md b/docs/chapter_stack_and_queue/stack.md index d738598d5..eed703353 100644 --- a/docs/chapter_stack_and_queue/stack.md +++ b/docs/chapter_stack_and_queue/stack.md @@ -155,16 +155,16 @@ comments: true stack.push(4); /* 访问栈顶元素 */ - peek = stack[stack.length-1]; + const peek = stack[stack.length-1]; /* 元素出栈 */ - pop = stack.pop(); + const pop = stack.pop(); /* 获取栈的长度 */ - size = stack.length; + const size = stack.length; /* 判断是否为空 */ - is_empty = stack.length === 0; + const is_empty = stack.length === 0; ``` === "TypeScript" From db416cf4bb94f563cd9cfb5d63856a678c406e7f Mon Sep 17 00:00:00 2001 From: IsChristina <315644507@qq.com> Date: Sun, 4 Dec 2022 12:26:09 +0800 Subject: [PATCH 58/67] add JavaScript codes for Tree --- .../chapter_tree/binary_search_tree.js | 145 ++++++++++++++++++ codes/javascript/chapter_tree/binary_tree.js | 34 ++++ .../chapter_tree/binary_tree_bfs.js | 36 +++++ .../chapter_tree/binary_tree_dfs.js | 60 ++++++++ codes/javascript/include/TreeNode.js | 47 ++++++ docs/chapter_tree/binary_search_tree.md | 76 ++++++++- docs/chapter_tree/binary_tree.md | 69 ++++++++- 7 files changed, 462 insertions(+), 5 deletions(-) create mode 100644 codes/javascript/chapter_tree/binary_search_tree.js create mode 100644 codes/javascript/chapter_tree/binary_tree.js create mode 100644 codes/javascript/chapter_tree/binary_tree_bfs.js create mode 100644 codes/javascript/chapter_tree/binary_tree_dfs.js create mode 100644 codes/javascript/include/TreeNode.js diff --git a/codes/javascript/chapter_tree/binary_search_tree.js b/codes/javascript/chapter_tree/binary_search_tree.js new file mode 100644 index 000000000..e97c3c926 --- /dev/null +++ b/codes/javascript/chapter_tree/binary_search_tree.js @@ -0,0 +1,145 @@ +/** + * File: binary_tree.js + * Created Time: 2022-12-04 + * Author: IsChristina (christinaxia77@foxmail.com) + */ + +const Tree = require("../include/TreeNode"); + + /* 二叉搜索树 */ +var root; + +function BinarySearchTree(nums) { + nums.sort((a,b) => { return a-b }); // 排序数组 + root = buildTree(nums, 0, nums.length - 1); // 构建二叉搜索树 +} + +/* 获取二叉树根结点 */ +function getRoot() { + return root; +} + +/* 构建二叉搜索树 */ +function buildTree(nums, i, j) { + if (i > j) return null; + // 将数组中间结点作为根结点 + let mid = Math.floor((i + j) / 2); + let root = new Tree.TreeNode(nums[mid]); + // 递归建立左子树和右子树 + root.left = buildTree(nums, i, mid - 1); + root.right = buildTree(nums, mid + 1, j); + return root; +} + +/* 查找结点 */ +function search(num) { + let cur = root; + // 循环查找，越过叶结点后跳出 + while (cur !== null) { + // 目标结点在 root 的右子树中 + if (cur.val < num) cur = cur.right; + // 目标结点在 root 的左子树中 + else if (cur.val > num) cur = cur.left; + // 找到目标结点，跳出循环 + else break; + } + // 返回目标结点 + return cur; +} + +/* 插入结点 */ +function insert(num) { + // 若树为空，直接提前返回 + if (root === null) return null; + let cur = root, pre = null; + // 循环查找，越过叶结点后跳出 + while (cur !== null) { + // 找到重复结点，直接返回 + if (cur.val === num) return null; + pre = cur; + // 插入位置在 root 的右子树中 + if (cur.val < num) cur = cur.right; + // 插入位置在 root 的左子树中 + else cur = cur.left; + } + // 插入结点 val + let node = new Tree.TreeNode(num); + if (pre.val < num) pre.right = node; + else pre.left = node; + return node; +} + +/* 删除结点 */ +function remove(num) { + // 若树为空，直接提前返回 + if (root === null) return null; + let cur = root, pre = null; + // 循环查找，越过叶结点后跳出 + while (cur !== null) { + // 找到待删除结点，跳出循环 + if (cur.val === num) break; + pre = cur; + // 待删除结点在 root 的右子树中 + if (cur.val < num) cur = cur.right; + // 待删除结点在 root 的左子树中 + else cur = cur.left; + } + // 若无待删除结点，则直接返回 + if (cur === null) return null; + // 子结点数量 = 0 or 1 + if (cur.left === null || cur.right === null) { + // 当子结点数量 = 0 / 1 时， child = null / 该子结点 + let child = cur.left !== null ? cur.left : cur.right; + // 删除结点 cur + if (pre.left === cur) pre.left = child; + else pre.right = child; + } + // 子结点数量 = 2 + else { + // 获取中序遍历中 cur 的下一个结点 + let nex = min(cur.right); + let tmp = nex.val; + // 递归删除结点 nex + remove(nex.val); + // 将 nex 的值复制给 cur + cur.val = tmp; + } + return cur; +} + +/* 获取最小结点 */ +function min(root) { + if (root === null) return root; + // 循环访问左子结点，直到叶结点时为最小结点，跳出 + while (root.left !== null) { + root = root.left; + } + return root; +} + +/* Driver Code */ +/* 初始化二叉搜索树 */ +var nums = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 ]; +BinarySearchTree(nums) +console.log("\n初始化的二叉树为\n"); +console.log(getRoot()); + +/* 查找结点 */ +let node = search(5); +console.log("\n查找到的结点对象为 " + node + "，结点值 = " + node.val); + +/* 插入结点 */ +node = insert(16); +console.log("\n插入结点 16 后，二叉树为\n"); +console.log(getRoot()); + +/* 删除结点 */ +remove(1); +console.log("\n删除结点 1 后，二叉树为\n"); +console.log(getRoot()); +remove(2); +console.log("\n删除结点 2 后，二叉树为\n"); +console.log(getRoot()); +remove(4); +console.log("\n删除结点 4 后，二叉树为\n"); +console.log(getRoot()); \ No newline at end of file diff --git a/codes/javascript/chapter_tree/binary_tree.js b/codes/javascript/chapter_tree/binary_tree.js new file mode 100644 index 000000000..7cf94414c --- /dev/null +++ b/codes/javascript/chapter_tree/binary_tree.js @@ -0,0 +1,34 @@ +/** + * File: binary_tree.js + * Created Time: 2022-12-04 + * Author: IsChristina (christinaxia77@foxmail.com) + */ + +const Tree = require("../include/TreeNode"); + +/* 初始化二叉树 */ +// 初始化结点 +let n1 = new Tree.TreeNode(1), +n2 = new Tree.TreeNode(2), +n3 = new Tree.TreeNode(3), +n4 = new Tree.TreeNode(4), +n5 = new Tree.TreeNode(5); +// 构建引用指向（即指针） +n1.left = n2; +n1.right = n3; +n2.left = n4; +n2.right = n5; +console.log("\n初始化二叉树\n") +console.log(n1) + +/* 插入与删除结点 */ +let P = new Tree.TreeNode(0); +// 在 n1 -> n2 中间插入结点 P +n1.left = P; +P.left = n2; +console.log("\n插入结点 P 后\n"); +console.log(n1); +// 删除结点 P +n1.left = n2; +console.log("\n删除结点 P 后\n"); +console.log(n1); diff --git a/codes/javascript/chapter_tree/binary_tree_bfs.js b/codes/javascript/chapter_tree/binary_tree_bfs.js new file mode 100644 index 000000000..8d8bb0943 --- /dev/null +++ b/codes/javascript/chapter_tree/binary_tree_bfs.js @@ -0,0 +1,36 @@ +/** + * File: binary_tree.js + * Created Time: 2022-12-04 + * Author: IsChristina (christinaxia77@foxmail.com) + */ + +let { arrToTree } = require("../include/TreeNode"); + +/* 层序遍历 */ +function hierOrder(root) { + // 初始化队列，加入根结点 + let queue = [root]; + // 初始化一个列表，用于保存遍历序列 + let list = []; + while (queue.length) { + let node = queue.shift(); // 队列出队 + list.push(node.val); // 保存结点 + if (node.left) + queue.push(node.left); // 左子结点入队 + if (node.right) + queue.push(node.right); // 右子结点入队 + + } + return list; +} + +/* Driver Code */ +/* 初始化二叉树 */ +// 这里借助了一个从数组直接生成二叉树的函数 +var root = arrToTree([1, 2, 3, 4, 5, 6, 7, null, null, null, null, null, null, null, null ]); +console.log("\n初始化二叉树\n"); +console.log(root); + +/* 层序遍历 */ +let list = hierOrder(root); +console.log("\n层序遍历的结点打印序列 = " + list); \ No newline at end of file diff --git a/codes/javascript/chapter_tree/binary_tree_dfs.js b/codes/javascript/chapter_tree/binary_tree_dfs.js new file mode 100644 index 000000000..072d95f89 --- /dev/null +++ b/codes/javascript/chapter_tree/binary_tree_dfs.js @@ -0,0 +1,60 @@ +/** + * File: binary_tree.js + * Created Time: 2022-12-04 + * Author: IsChristina (christinaxia77@foxmail.com) + */ + +let { arrToTree } = require("../include/TreeNode"); + +// 初始化列表，用于存储遍历序列 +var list = [] + +/* 前序遍历 */ +function preOrder(root){ + if (root === null) return; + // 访问优先级：根结点 -> 左子树 -> 右子树 + list.push(root.val); + preOrder(root.left); + preOrder(root.right); + } + +/* 中序遍历 */ +function inOrder(root) { + if (root === null) return; + // 访问优先级：左子树 -> 根结点 -> 右子树 + inOrder(root.left); + list.push(root.val); + inOrder(root.right); +} + +/* 后序遍历 */ +function postOrder(root) { + if (root === null) return; + // 访问优先级：左子树 -> 右子树 -> 根结点 + postOrder(root.left); + postOrder(root.right); + list.push(root.val); +} + +/* Driver Code */ +/* 初始化二叉树 */ +// 这里借助了一个从数组直接生成二叉树的函数 +var root = arrToTree([1, 2, 3, 4, 5, 6, 7, null, null, null, null, null, null, null, null]); +console.log("\n初始化二叉树\n"); +console.log(root); + +/* 前序遍历 */ +list.length = 0; +preOrder(root); +console.log("\n前序遍历的结点打印序列 = " + list); + +/* 中序遍历 */ +list.length = 0; +inOrder(root); +console.log("\n中序遍历的结点打印序列 = " + list); + +/* 后序遍历 */ +list.length = 0; +postOrder(root); +console.log("\n后序遍历的结点打印序列 = " + list); + diff --git a/codes/javascript/include/TreeNode.js b/codes/javascript/include/TreeNode.js new file mode 100644 index 000000000..20c709e96 --- /dev/null +++ b/codes/javascript/include/TreeNode.js @@ -0,0 +1,47 @@ +/** + * File: TreeNode.js + * Created Time: 2022-12-04 + * Author: IsChristina (christinaxia77@foxmail.com) + */ + +/** + * Definition for a binary tree node. + */ +function TreeNode(val, left, right) { + this.val = (val === undefined ? 0 : val) // 结点值 + this.left = (left === undefined ? null : left) // 左子结点指针 + this.right = (right === undefined ? null : right) // 右子结点指针 +} + +/** +* Generate a binary tree with an array +* @param arr +* @return +*/ +function arrToTree(arr) { + if (arr.length === 0) + return null; + + let root = new TreeNode(arr[0]); + let queue = [root] + let i = 1; + while(queue.length) { + let node = queue.shift(); + if(arr[i] !== null) { + node.left = new TreeNode(arr[i]); + queue.push(node.left); + } + i++; + if(arr[i] !== null) { + node.right = new TreeNode(arr[i]); + queue.push(node.right); + } + i++; + } + return root; +} + +module.exports = { + TreeNode, + arrToTree, +} \ No newline at end of file diff --git a/docs/chapter_tree/binary_search_tree.md b/docs/chapter_tree/binary_search_tree.md index 30d392999..8901b769d 100644 --- a/docs/chapter_tree/binary_search_tree.md +++ b/docs/chapter_tree/binary_search_tree.md @@ -112,7 +112,21 @@ comments: true === "JavaScript" ```js title="binary_search_tree.js" - + /* 查找结点 */ + function search(num) { + let cur = root; + // 循环查找，越过叶结点后跳出 + while (cur !== null) { + // 目标结点在 root 的右子树中 + if (cur.val < num) cur = cur.right; + // 目标结点在 root 的左子树中 + else if (cur.val > num) cur = cur.left; + // 找到目标结点，跳出循环 + else break; + } + // 返回目标结点 + return cur; + } ``` === "TypeScript" @@ -240,7 +254,27 @@ comments: true === "JavaScript" ```js title="binary_search_tree.js" - + /* 插入结点 */ + function insert(num) { + // 若树为空，直接提前返回 + if (root === null) return null; + let cur = root, pre = null; + // 循环查找，越过叶结点后跳出 + while (cur !== null) { + // 找到重复结点，直接返回 + if (cur.val === num) return null; + pre = cur; + // 插入位置在 root 的右子树中 + if (cur.val < num) cur = cur.right; + // 插入位置在 root 的左子树中 + else cur = cur.left; + } + // 插入结点 val + let node = new Tree.TreeNode(num); + if (pre.val < num) pre.right = node; + else pre.left = node; + return node; + } ``` === "TypeScript" @@ -471,7 +505,43 @@ comments: true === "JavaScript" ```js title="binary_search_tree.js" - + /* 删除结点 */ + function remove(num) { + // 若树为空，直接提前返回 + if (root === null) return null; + let cur = root, pre = null; + // 循环查找，越过叶结点后跳出 + while (cur !== null) { + // 找到待删除结点，跳出循环 + if (cur.val === num) break; + pre = cur; + // 待删除结点在 root 的右子树中 + if (cur.val < num) cur = cur.right; + // 待删除结点在 root 的左子树中 + else cur = cur.left; + } + // 若无待删除结点，则直接返回 + if (cur === null) return null; + // 子结点数量 = 0 or 1 + if (cur.left === null || cur.right === null) { + // 当子结点数量 = 0 / 1 时， child = null / 该子结点 + let child = cur.left !== null ? cur.left : cur.right; + // 删除结点 cur + if (pre.left === cur) pre.left = child; + else pre.right = child; + } + // 子结点数量 = 2 + else { + // 获取中序遍历中 cur 的下一个结点 + let nex = min(cur.right); + let tmp = nex.val; + // 递归删除结点 nex + remove(nex.val); + // 将 nex 的值复制给 cur + cur.val = tmp; + } + return cur; + } ``` === "TypeScript" diff --git a/docs/chapter_tree/binary_tree.md b/docs/chapter_tree/binary_tree.md index d7c35d928..cf6cad46e 100644 --- a/docs/chapter_tree/binary_tree.md +++ b/docs/chapter_tree/binary_tree.md @@ -63,6 +63,12 @@ comments: true === "JavaScript" ```js title="" + /* 链表结点类 */ + function TreeNode(val, left, right) { + this.val = (val === undefined ? 0 : val) // 结点值 + this.left = (left === undefined ? null : left) // 左子结点指针 + this.right = (right === undefined ? null : right) // 右子结点指针 + } ``` @@ -193,7 +199,18 @@ comments: true === "JavaScript" ```js title="binary_tree.js" - + /* 初始化二叉树 */ + // 初始化结点 + let n1 = new TreeNode(1), + n2 = new TreeNode(2), + n3 = new TreeNode(3), + n4 = new TreeNode(4), + n5 = new TreeNode(5); + // 构建引用指向（即指针） + n1.left = n2; + n1.right = n3; + n2.left = n4; + n2.right = n5; ``` === "TypeScript" @@ -265,7 +282,14 @@ comments: true === "JavaScript" ```js title="binary_tree.js" + /* 插入与删除结点 */ + let P = new TreeNode(0); + // 在 n1 -> n2 中间插入结点 P + n1.left = P; + P.left = n2; + // 删除结点 P + n1.left = n2; ``` === "TypeScript" @@ -387,7 +411,23 @@ comments: true === "JavaScript" ```js title="binary_tree_bfs.js" - + /* 层序遍历 */ + function hierOrder(root) { + // 初始化队列，加入根结点 + let queue = [root]; + // 初始化一个列表，用于保存遍历序列 + let list = []; + while (queue.length) { + let node = queue.shift(); // 队列出队 + list.push(node.val); // 保存结点 + if (node.left) + queue.push(node.left); // 左子结点入队 + if (node.right) + queue.push(node.right); // 右子结点入队 + + } + return list; + } ``` === "TypeScript" @@ -536,7 +576,32 @@ comments: true === "JavaScript" ```js title="binary_tree_dfs.js" + /* 前序遍历 */ + function preOrder(root){ + if (root === null) return; + // 访问优先级：根结点 -> 左子树 -> 右子树 + list.push(root.val); + preOrder(root.left); + preOrder(root.right); + } + /* 中序遍历 */ + function inOrder(root) { + if (root === null) return; + // 访问优先级：左子树 -> 根结点 -> 右子树 + inOrder(root.left); + list.push(root.val); + inOrder(root.right); + } + + /* 后序遍历 */ + function postOrder(root) { + if (root === null) return; + // 访问优先级：左子树 -> 右子树 -> 根结点 + postOrder(root.left); + postOrder(root.right); + list.push(root.val); + } ``` === "TypeScript" From 3252b829e1ea3c40da3ed34c6dfb67436cbad3da Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Sun, 4 Dec 2022 16:25:40 +0800 Subject: [PATCH 59/67] Add installation steps for Go and JavaScript. --- .../chapter_stack_and_queue/stack.js | 6 ++++++ docs/chapter_preface/installation.md | 21 ++++++++++++++----- 2 files changed, 22 insertions(+), 5 deletions(-) diff --git a/codes/javascript/chapter_stack_and_queue/stack.js b/codes/javascript/chapter_stack_and_queue/stack.js index 9afbdc2c1..1d4944946 100644 --- a/codes/javascript/chapter_stack_and_queue/stack.js +++ b/codes/javascript/chapter_stack_and_queue/stack.js @@ -14,15 +14,21 @@ stack.push(3); stack.push(2); stack.push(5); stack.push(4); +console.log("栈 stack =", stack) /* 访问栈顶元素 */ const peek = stack[stack.length - 1]; +console.log("栈顶元素 peek =", peek) /* 元素出栈 */ const pop = stack.pop(); +console.log("出栈元素 pop =", pop) +console.log("出栈后 stack =", stack) /* 获取栈的长度 */ const size = stack.length; +console.log("栈的长度 size =", size) /* 判断是否为空 */ const is_empty = stack.length === 0; +console.log("栈是否为空 =", is_empty) diff --git a/docs/chapter_preface/installation.md b/docs/chapter_preface/installation.md index 51e9567b2..05919c3f4 100644 --- a/docs/chapter_preface/installation.md +++ b/docs/chapter_preface/installation.md @@ -10,11 +10,6 @@ comments: true 本书推荐使用开源轻量的 VSCode 作为本地 IDE ，下载并安装 [VSCode](https://code.visualstudio.com/) 。 -## Python 环境 - -1. 下载并安装 [Miniconda3](https://docs.conda.io/en/latest/miniconda.html) ，获取 Python 运行环境。 -2. 在 VSCode 的插件市场中搜索 `python` ，安装 Python Extension Pack 。 - ## Java 环境 1. 下载并安装 [OpenJDK](https://jdk.java.net/18/) ，获取 Java 运行环境。 @@ -24,3 +19,19 @@ comments: true 1. Windows 系统需要安装 [MinGW](https://www.mingw-w64.org/downloads/) ，MacOS 自带 Clang 无需安装。 2. 在 VSCode 的插件市场中搜索 `c++` ，安装 C/C++ Extension Pack 。 + +## Python 环境 + +1. 下载并安装 [Miniconda3](https://docs.conda.io/en/latest/miniconda.html) ，获取 Python 运行环境。 +2. 在 VSCode 的插件市场中搜索 `python` ，安装 Python Extension Pack 。 + +## Go 环境 + +1. 下载并安装 [go](https://go.dev/dl/) ，获取 Go 运行环境。 +2. 在 VSCode 的插件市场中搜索 `go` ，安装 Go 。 +3. 快捷键 `Ctrl + Shift + P` 呼出命令栏，输入 go ，选择 `Go: Install/Update Tools` ，全部勾选并安装即可。 + +## JavaScript 环境 + +1. 下载并安装 [node.js](https://nodejs.org/en/) ，获取 JavaScript 运行环境。 +2. 在 VSCode 的插件市场中搜索 `javascript` ，安装 JavaScript (ES6) code snippets 。 From c97cb9bac121b6c99a00cc386faababf015a1eef Mon Sep 17 00:00:00 2001 From: justin Date: Sun, 4 Dec 2022 17:49:57 +0800 Subject: [PATCH 60/67] Add TypeScript code (Chapter of Array) --- .../chapter_array_and_linkedlist/array.ts | 101 ++++++++++++++++++ 1 file changed, 101 insertions(+) create mode 100644 codes/typescript/chapter_array_and_linkedlist/array.ts diff --git a/codes/typescript/chapter_array_and_linkedlist/array.ts b/codes/typescript/chapter_array_and_linkedlist/array.ts new file mode 100644 index 000000000..53a892eae --- /dev/null +++ b/codes/typescript/chapter_array_and_linkedlist/array.ts @@ -0,0 +1,101 @@ +/* + * File: array.ts + * Created Time: 2022-12-04 + * Author: Justin (xiefahit@gmail.com) + */ + +/* 随机返回一个数组元素 */ +function randomAccess(nums: number[]): number { + // 在区间 [0, nums.length) 中随机抽取一个数字 + const random_index = Math.floor(Math.random() * nums.length) + // 获取并返回随机元素 + const random_num = nums[random_index] + return random_num +} + +/* 扩展数组长度 */ +// 请注意，TypeScript 的 Array 是动态数组，可以直接扩展 +// 为了方便学习，本函数将 Array 看作是长度不可变的数组 +function extend(nums: number[], enlarge: number): number[] { + // 初始化一个扩展长度后的数组 + const res = new Array(nums.length + enlarge).fill(0) + // 将原数组中的所有元素复制到新数组 + for (let i = 0; i < nums.length; i++){ + res[i] = nums[i] + } + // 返回扩展后的新数组 + return res +} + +/* 在数组的索引 index 处插入元素 num */ +function insert(nums: number[], num: number, index: number): void { + // 把索引 index 以及之后的所有元素向后移动一位 + for (let i = nums.length - 1; i >= index; i--) { + nums[i] = nums[i - 1] + } + // 将 num 赋给 index 处元素 + nums[index] = num +} + +/* 删除索引 index 处元素 */ +function remove(nums: number[], index: number): void { + // 把索引 index 之后的所有元素向前移动一位 + for (let i = index; i < nums.length - 1; i++) { + nums[i] = nums[i + 1] + } +} + +/* 遍历数组 */ +function traverse(nums: number[]): void { + let count = 0 + // 通过索引遍历数组 + for (let i = 0; i < nums.length; i++) { + count++ + } + // 直接遍历数组 + for(let num of nums){ + count += 1 + } +} + +/* 在数组中查找指定元素 */ +function find(nums: number[], target: number): number { + for (let i = 0; i < nums.length; i++) { + if (nums[i] === target) { + return i + } + } + return -1 +} + +/* Driver Codes*/ +/* 初始化数组 */ +let arr: number[] = new Array(5).fill(0) +console.log("数组 arr =", arr) +let nums: number[] = [1, 3, 2, 5, 4] +console.log("数组 nums =", nums) + +/* 随机访问 */ +const random_num = randomAccess(nums) +console.log("在 nums 中获取随机元素", random_num) + +/* 长度扩展 */ +nums = extend(nums, 3) +console.log("将数组长度扩展至 8 ，得到 nums =", nums) + +/* 插入元素 */ +insert(nums, 6, 3) +console.log("在索引 3 处插入数字 6 ，得到 nums =", nums) + +/* 删除元素 */ +remove(nums, 2) +console.log("删除索引 2 处的元素，得到 nums =", nums) + +/* 遍历数组 */ +traverse(nums) + +/* 查找元素 */ +var index: number = find(nums, 3) +console.log("在 nums 中查找元素 3 ，得到索引 =", index) + +export { } From 47db74892d56c3b397f42fce7c74185946896791 Mon Sep 17 00:00:00 2001 From: justin Date: Sun, 4 Dec 2022 18:00:44 +0800 Subject: [PATCH 61/67] Add TypeScript code to docs (Chapter of Array) --- docs/chapter_array_and_linkedlist/array.md | 64 ++++++++++++++++++++-- 1 file changed, 59 insertions(+), 5 deletions(-) diff --git a/docs/chapter_array_and_linkedlist/array.md b/docs/chapter_array_and_linkedlist/array.md index fcd7e450b..bba71f06b 100644 --- a/docs/chapter_array_and_linkedlist/array.md +++ b/docs/chapter_array_and_linkedlist/array.md @@ -57,7 +57,9 @@ comments: true === "TypeScript" ```typescript title="array.ts" - + /* 初始化数组 */ + let arr: number[] = new Array(5).fill(0) + let nums: number[] = [1, 3, 2, 5, 4] ``` === "C" @@ -148,7 +150,14 @@ elementAddr = firtstElementAddr + elementLength * elementIndex === "TypeScript" ```typescript title="array.ts" - + /* 随机返回一个数组元素 */ + function randomAccess(nums: number[]): number { + // 在区间 [0, nums.length) 中随机抽取一个数字 + const random_index = Math.floor(Math.random() * nums.length) + // 获取并返回随机元素 + const random_num = nums[random_index] + return random_num + } ``` === "C" @@ -240,7 +249,17 @@ elementAddr = firtstElementAddr + elementLength * elementIndex === "TypeScript" ```typescript title="array.ts" - + /* 扩展数组长度 */ + function extend(nums: number[], enlarge: number): number[] { + // 初始化一个扩展长度后的数组 + const res = new Array(nums.length + enlarge).fill(0) + // 将原数组中的所有元素复制到新数组 + for (let i = 0; i < nums.length; i++){ + res[i] = nums[i] + } + // 返回扩展后的新数组 + return res + } ``` === "C" @@ -358,7 +377,23 @@ elementAddr = firtstElementAddr + elementLength * elementIndex === "TypeScript" ```typescript title="array.ts" + /* 在数组的索引 index 处插入元素 num */ + function insert(nums: number[], num: number, index: number): void { + // 把索引 index 以及之后的所有元素向后移动一位 + for (let i = nums.length - 1; i >= index; i--) { + nums[i] = nums[i - 1] + } + // 将 num 赋给 index 处元素 + nums[index] = num + } + /* 删除索引 index 处元素 */ + function remove(nums: number[], index: number): void { + // 把索引 index 之后的所有元素向前移动一位 + for (let i = index; i < nums.length - 1; i++) { + nums[i] = nums[i + 1] + } + } ``` === "C" @@ -447,7 +482,18 @@ elementAddr = firtstElementAddr + elementLength * elementIndex === "TypeScript" ```typescript title="array.ts" - + /* 遍历数组 */ + function traverse(nums: number[]): void { + let count = 0 + // 通过索引遍历数组 + for (let i = 0; i < nums.length; i++) { + count++ + } + // 直接遍历数组 + for(let num of nums){ + count += 1 + } + } ``` === "C" @@ -523,7 +569,15 @@ elementAddr = firtstElementAddr + elementLength * elementIndex === "TypeScript" ```typescript title="array.ts" - + /* 在数组中查找指定元素 */ + function find(nums: number[], target: number): number { + for (let i = 0; i < nums.length; i++) { + if (nums[i] === target) { + return i + } + } + return -1 + } ``` === "C" From 31732e5690aae27b7fe1901c57bf53c7c3e4fe79 Mon Sep 17 00:00:00 2001 From: justin Date: Sun, 4 Dec 2022 18:55:51 +0800 Subject: [PATCH 62/67] Update TypeScript style (Chapter of Array) --- .../chapter_array_and_linkedlist/array.ts | 74 +++++++++---------- 1 file changed, 37 insertions(+), 37 deletions(-) diff --git a/codes/typescript/chapter_array_and_linkedlist/array.ts b/codes/typescript/chapter_array_and_linkedlist/array.ts index 53a892eae..e9b31b0a0 100644 --- a/codes/typescript/chapter_array_and_linkedlist/array.ts +++ b/codes/typescript/chapter_array_and_linkedlist/array.ts @@ -6,67 +6,67 @@ /* 随机返回一个数组元素 */ function randomAccess(nums: number[]): number { - // 在区间 [0, nums.length) 中随机抽取一个数字 - const random_index = Math.floor(Math.random() * nums.length) - // 获取并返回随机元素 - const random_num = nums[random_index] - return random_num + // 在区间 [0, nums.length) 中随机抽取一个数字 + const random_index = Math.floor(Math.random() * nums.length) + // 获取并返回随机元素 + const random_num = nums[random_index] + return random_num } /* 扩展数组长度 */ // 请注意，TypeScript 的 Array 是动态数组，可以直接扩展 // 为了方便学习，本函数将 Array 看作是长度不可变的数组 function extend(nums: number[], enlarge: number): number[] { - // 初始化一个扩展长度后的数组 - const res = new Array(nums.length + enlarge).fill(0) - // 将原数组中的所有元素复制到新数组 - for (let i = 0; i < nums.length; i++){ - res[i] = nums[i] - } - // 返回扩展后的新数组 - return res + // 初始化一个扩展长度后的数组 + const res = new Array(nums.length + enlarge).fill(0) + // 将原数组中的所有元素复制到新数组 + for (let i = 0; i < nums.length; i++){ + res[i] = nums[i] + } + // 返回扩展后的新数组 + return res } /* 在数组的索引 index 处插入元素 num */ function insert(nums: number[], num: number, index: number): void { - // 把索引 index 以及之后的所有元素向后移动一位 - for (let i = nums.length - 1; i >= index; i--) { - nums[i] = nums[i - 1] - } - // 将 num 赋给 index 处元素 - nums[index] = num + // 把索引 index 以及之后的所有元素向后移动一位 + for (let i = nums.length - 1; i >= index; i--) { + nums[i] = nums[i - 1] + } + // 将 num 赋给 index 处元素 + nums[index] = num } /* 删除索引 index 处元素 */ function remove(nums: number[], index: number): void { - // 把索引 index 之后的所有元素向前移动一位 - for (let i = index; i < nums.length - 1; i++) { - nums[i] = nums[i + 1] - } + // 把索引 index 之后的所有元素向前移动一位 + for (let i = index; i < nums.length - 1; i++) { + nums[i] = nums[i + 1] + } } /* 遍历数组 */ function traverse(nums: number[]): void { - let count = 0 - // 通过索引遍历数组 - for (let i = 0; i < nums.length; i++) { - count++ - } - // 直接遍历数组 - for(let num of nums){ - count += 1 - } + let count = 0 + // 通过索引遍历数组 + for (let i = 0; i < nums.length; i++) { + count++ + } + // 直接遍历数组 + for(let num of nums){ + count += 1 + } } /* 在数组中查找指定元素 */ function find(nums: number[], target: number): number { - for (let i = 0; i < nums.length; i++) { - if (nums[i] === target) { - return i + for (let i = 0; i < nums.length; i++) { + if (nums[i] === target) { + return i + } } + return -1 } - return -1 -} /* Driver Codes*/ /* 初始化数组 */ From aa8f24f34f8ca9cfba1986676484931cd6c0de8e Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Sun, 4 Dec 2022 18:58:12 +0800 Subject: [PATCH 63/67] Update array.ts --- codes/typescript/chapter_array_and_linkedlist/array.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/codes/typescript/chapter_array_and_linkedlist/array.ts b/codes/typescript/chapter_array_and_linkedlist/array.ts index e9b31b0a0..2905087ce 100644 --- a/codes/typescript/chapter_array_and_linkedlist/array.ts +++ b/codes/typescript/chapter_array_and_linkedlist/array.ts @@ -66,7 +66,7 @@ function find(nums: number[], target: number): number { } } return -1 - } +} /* Driver Codes*/ /* 初始化数组 */ From 003dcc56f48fc886be0240d2bab39ce96762b89d Mon Sep 17 00:00:00 2001 From: IsChristina <315644507@qq.com> Date: Sun, 4 Dec 2022 23:14:09 +0800 Subject: [PATCH 64/67] add JavaScript codes for PrintUtil --- .../chapter_tree/binary_search_tree.js | 11 +-- codes/javascript/chapter_tree/binary_tree.js | 9 +- .../chapter_tree/binary_tree_bfs.js | 5 +- .../chapter_tree/binary_tree_dfs.js | 5 +- codes/javascript/include/PrintUtil.js | 88 +++++++++++++++++++ 5 files changed, 105 insertions(+), 13 deletions(-) create mode 100644 codes/javascript/include/PrintUtil.js diff --git a/codes/javascript/chapter_tree/binary_search_tree.js b/codes/javascript/chapter_tree/binary_search_tree.js index e97c3c926..332525f2a 100644 --- a/codes/javascript/chapter_tree/binary_search_tree.js +++ b/codes/javascript/chapter_tree/binary_search_tree.js @@ -5,6 +5,7 @@ */ const Tree = require("../include/TreeNode"); +const { printTree } = require("../include/PrintUtil"); /* 二叉搜索树 */ var root; @@ -122,7 +123,7 @@ function min(root) { var nums = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 ]; BinarySearchTree(nums) console.log("\n初始化的二叉树为\n"); -console.log(getRoot()); +printTree(getRoot()); /* 查找结点 */ let node = search(5); @@ -131,15 +132,15 @@ console.log("\n查找到的结点对象为 " + node + "，结点值 = " + node.v /* 插入结点 */ node = insert(16); console.log("\n插入结点 16 后，二叉树为\n"); -console.log(getRoot()); +printTree(getRoot()); /* 删除结点 */ remove(1); console.log("\n删除结点 1 后，二叉树为\n"); -console.log(getRoot()); +printTree(getRoot()); remove(2); console.log("\n删除结点 2 后，二叉树为\n"); -console.log(getRoot()); +printTree(getRoot()); remove(4); console.log("\n删除结点 4 后，二叉树为\n"); -console.log(getRoot()); \ No newline at end of file +printTree(getRoot()); \ No newline at end of file diff --git a/codes/javascript/chapter_tree/binary_tree.js b/codes/javascript/chapter_tree/binary_tree.js index 7cf94414c..1b91ef5a9 100644 --- a/codes/javascript/chapter_tree/binary_tree.js +++ b/codes/javascript/chapter_tree/binary_tree.js @@ -5,7 +5,8 @@ */ const Tree = require("../include/TreeNode"); - +const { printTree } = require("../include/PrintUtil"); + /* 初始化二叉树 */ // 初始化结点 let n1 = new Tree.TreeNode(1), @@ -19,7 +20,7 @@ n1.right = n3; n2.left = n4; n2.right = n5; console.log("\n初始化二叉树\n") -console.log(n1) +printTree(n1) /* 插入与删除结点 */ let P = new Tree.TreeNode(0); @@ -27,8 +28,8 @@ let P = new Tree.TreeNode(0); n1.left = P; P.left = n2; console.log("\n插入结点 P 后\n"); -console.log(n1); +printTree(n1); // 删除结点 P n1.left = n2; console.log("\n删除结点 P 后\n"); -console.log(n1); +printTree(n1); diff --git a/codes/javascript/chapter_tree/binary_tree_bfs.js b/codes/javascript/chapter_tree/binary_tree_bfs.js index 8d8bb0943..f7e6aa0e3 100644 --- a/codes/javascript/chapter_tree/binary_tree_bfs.js +++ b/codes/javascript/chapter_tree/binary_tree_bfs.js @@ -4,7 +4,8 @@ * Author: IsChristina (christinaxia77@foxmail.com) */ -let { arrToTree } = require("../include/TreeNode"); +const { arrToTree } = require("../include/TreeNode"); +const { printTree } = require("../include/PrintUtil"); /* 层序遍历 */ function hierOrder(root) { @@ -29,7 +30,7 @@ function hierOrder(root) { // 这里借助了一个从数组直接生成二叉树的函数 var root = arrToTree([1, 2, 3, 4, 5, 6, 7, null, null, null, null, null, null, null, null ]); console.log("\n初始化二叉树\n"); -console.log(root); +printTree(root); /* 层序遍历 */ let list = hierOrder(root); diff --git a/codes/javascript/chapter_tree/binary_tree_dfs.js b/codes/javascript/chapter_tree/binary_tree_dfs.js index 072d95f89..9dd3083ff 100644 --- a/codes/javascript/chapter_tree/binary_tree_dfs.js +++ b/codes/javascript/chapter_tree/binary_tree_dfs.js @@ -4,7 +4,8 @@ * Author: IsChristina (christinaxia77@foxmail.com) */ -let { arrToTree } = require("../include/TreeNode"); +const { arrToTree } = require("../include/TreeNode"); +const { printTree } = require("../include/PrintUtil"); // 初始化列表，用于存储遍历序列 var list = [] @@ -41,7 +42,7 @@ function postOrder(root) { // 这里借助了一个从数组直接生成二叉树的函数 var root = arrToTree([1, 2, 3, 4, 5, 6, 7, null, null, null, null, null, null, null, null]); console.log("\n初始化二叉树\n"); -console.log(root); +printTree(root); /* 前序遍历 */ list.length = 0; diff --git a/codes/javascript/include/PrintUtil.js b/codes/javascript/include/PrintUtil.js new file mode 100644 index 000000000..daeb24a7d --- /dev/null +++ b/codes/javascript/include/PrintUtil.js @@ -0,0 +1,88 @@ +/** + * File: PrintUtil.js + * Created Time: 2022-12-04 + * Author: IsChristina (christinaxia77@foxmail.com) + */ + +function Trunk(prev, str) { + this.prev = prev; + this.str = str; +} + +/** + * Print a linked list + * @param head + */ +function printLinkedList(head) { + let list = []; + while (head !== null) { + list.push(head.val.toString()); + head = head.next; + } + console.log(list.join(" -> ")); +} + +/** + * The interface of the tree printer + * This tree printer is borrowed from TECHIE DELIGHT + * https://www.techiedelight.com/c-program-print-binary-tree/ + * @param root + */ +function printTree(root) { + printTree(root, null, false); +} + +/** + * Print a binary tree + * @param root + * @param prev + * @param isLeft + */ +function printTree(root, prev, isLeft) { + if (root === null) { + return; + } + + let prev_str = " "; + let trunk = new Trunk(prev, prev_str); + + printTree(root.right, trunk, true); + + if (!prev) { + trunk.str = "———"; + } else if (isLeft) { + trunk.str = "/———"; + prev_str = " |"; + } else { + trunk.str = "\\———"; + prev.str = prev_str; + } + + showTrunks(trunk); + console.log(" " + root.val); + + if (prev) { + prev.str = prev_str; + } + trunk.str = " |"; + + printTree(root.left, trunk, false); +} + +/** + * Helper function to print branches of the binary tree + * @param p + */ +function showTrunks(p) { + if (!p) { + return; + } + + showTrunks(p.prev); + console.log(p.str); +} + +module.exports = { + printTree, + printLinkedList, +} From f1ba6c679c38910945c766fc4dee23b5e491b52e Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Mon, 5 Dec 2022 00:13:48 +0800 Subject: [PATCH 65/67] Update binary_tree.md --- docs/chapter_tree/binary_tree.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/docs/chapter_tree/binary_tree.md b/docs/chapter_tree/binary_tree.md index cf6cad46e..5913a1a43 100644 --- a/docs/chapter_tree/binary_tree.md +++ b/docs/chapter_tree/binary_tree.md @@ -68,8 +68,7 @@ comments: true this.val = (val === undefined ? 0 : val) // 结点值 this.left = (left === undefined ? null : left) // 左子结点指针 this.right = (right === undefined ? null : right) // 右子结点指针 - } - + } ``` === "TypeScript" From 7dbbc3de12c6f5b835f84b26459ddd50a4b13d51 Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Mon, 5 Dec 2022 00:14:21 +0800 Subject: [PATCH 66/67] Update binary_search_tree.js --- codes/javascript/chapter_tree/binary_search_tree.js | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/codes/javascript/chapter_tree/binary_search_tree.js b/codes/javascript/chapter_tree/binary_search_tree.js index 332525f2a..74b725080 100644 --- a/codes/javascript/chapter_tree/binary_search_tree.js +++ b/codes/javascript/chapter_tree/binary_search_tree.js @@ -7,7 +7,7 @@ const Tree = require("../include/TreeNode"); const { printTree } = require("../include/PrintUtil"); - /* 二叉搜索树 */ +/* 二叉搜索树 */ var root; function BinarySearchTree(nums) { @@ -143,4 +143,4 @@ console.log("\n删除结点 2 后，二叉树为\n"); printTree(getRoot()); remove(4); console.log("\n删除结点 4 后，二叉树为\n"); -printTree(getRoot()); \ No newline at end of file +printTree(getRoot()); From bc2561fb5195ff637e6ba0b74d3bdd177814c773 Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Mon, 5 Dec 2022 02:37:16 +0800 Subject: [PATCH 67/67] Add the chapter of hash map. --- .../java/chapter_hashing/array_hash_map.java | 138 ++++++++++++++++ codes/java/chapter_hashing/hash_map.java | 51 ++++++ codes/java/include/PrintUtil.java | 12 ++ docs/chapter_hashing/hash_collision.md | 17 ++ docs/chapter_hashing/hash_map.md | 153 ++++++++++++++++++ docs/chapter_hashing/summary.md | 5 + docs/chapter_searching/binary_search.md | 2 +- docs/chapter_tree/binary_search_tree.md | 8 +- mkdocs.yml | 4 + 9 files changed, 385 insertions(+), 5 deletions(-) create mode 100644 codes/java/chapter_hashing/array_hash_map.java create mode 100644 codes/java/chapter_hashing/hash_map.java create mode 100644 docs/chapter_hashing/hash_collision.md create mode 100644 docs/chapter_hashing/hash_map.md create mode 100644 docs/chapter_hashing/summary.md diff --git a/codes/java/chapter_hashing/array_hash_map.java b/codes/java/chapter_hashing/array_hash_map.java new file mode 100644 index 000000000..5fad6f3ea --- /dev/null +++ b/codes/java/chapter_hashing/array_hash_map.java @@ -0,0 +1,138 @@ +/* + * File: hash_map.java + * Created Time: 2022-12-04 + * Author: Krahets (krahets@163.com) + */ + +package chapter_hashing; +import java.util.*; + +/* 键值对 int->String */ +class Entry { + public int key; + public String val; + public Entry(int key, String val) { + this.key = key; + this.val = val; + } +} + +/* 基于数组简易实现的哈希表 */ +class ArrayHashMap { + private List bucket; + public ArrayHashMap() { + // 初始化一个长度为 10 的桶（数组） + bucket = new ArrayList<>(10); + for (int i = 0; i < 10; i++) { + bucket.add(null); + } + } + + /* 哈希函数 */ + private int hashFunc(int key) { + int index = key % 10000; + return index; + } + + /* 查询操作 */ + public String get(int key) { + int index = hashFunc(key); + Entry pair = bucket.get(index); + if (pair == null) return null; + return pair.val; + } + + /* 添加操作 */ + public void put(int key, String val) { + Entry pair = new Entry(key, val); + int index = hashFunc(key); + bucket.set(index, pair); + } + + /* 删除操作 */ + public void remove(int key) { + int index = hashFunc(key); + // 置为空字符，代表删除 + bucket.set(index, null); + } + + /* 获取所有键值对 */ + public List entrySet() { + List entrySet = new ArrayList<>(); + for (Entry pair : bucket) { + if (pair != null) + entrySet.add(pair); + } + return entrySet; + } + + /* 获取所有键 */ + public List keySet() { + List keySet = new ArrayList<>(); + for (Entry pair : bucket) { + if (pair != null) + keySet.add(pair.key); + } + return keySet; + } + + /* 获取所有值 */ + public List valueSet() { + List valueSet = new ArrayList<>(); + for (Entry pair : bucket) { + if (pair != null) + valueSet.add(pair.val); + } + return valueSet; + } + + /* 打印哈希表 */ + public void print() { + for (Entry kv: entrySet()) { + System.out.println(kv.key + " -> " + kv.val); + } + } +} + + +public class array_hash_map { + public static void main(String[] args) { + /* 初始化哈希表 */ + ArrayHashMap map = new ArrayHashMap(); + + /* 添加操作 */ + // 在哈希表中添加键值对 (key, value) + map.put(10001, "小哈"); + map.put(10002, "小啰"); + map.put(10003, "小算"); + map.put(10004, "小法"); + map.put(10005, "小哇"); + System.out.println("\n添加完成后，哈希表为\nKey -> Value"); + map.print(); + + /* 查询操作 */ + // 向哈希表输入键 key ，得到值 value + String name = map.get(10002); + System.out.println("\n输入学号 10002 ，查询到姓名 " + name); + + /* 删除操作 */ + // 在哈希表中删除键值对 (key, value) + map.remove(10005); + System.out.println("\n删除 10005 后，哈希表为\nKey -> Value"); + map.print(); + + /* 遍历哈希表 */ + System.out.println("\n遍历键值对 Key->Value"); + for (Entry kv: map.entrySet()) { + System.out.println(kv.key + " -> " + kv.val); + } + System.out.println("\n单独遍历键 Key"); + for (int key: map.keySet()) { + System.out.println(key); + } + System.out.println("\n单独遍历值 Value"); + for (String val: map.valueSet()) { + System.out.println(val); + } + } +} diff --git a/codes/java/chapter_hashing/hash_map.java b/codes/java/chapter_hashing/hash_map.java new file mode 100644 index 000000000..bd145b76e --- /dev/null +++ b/codes/java/chapter_hashing/hash_map.java @@ -0,0 +1,51 @@ +/* + * File: hash_map.java + * Created Time: 2022-12-04 + * Author: Krahets (krahets@163.com) + */ + +package chapter_hashing; +import java.util.*; +import include.*; + +public class hash_map { + public static void main(String[] args) { + /* 初始化哈希表 */ + Map map = new HashMap<>(); + + /* 添加操作 */ + // 在哈希表中添加键值对 (key, value) + map.put(10001, "小哈"); + map.put(10002, "小啰"); + map.put(10003, "小算"); + map.put(10004, "小法"); + map.put(10005, "小哇"); + System.out.println("\n添加完成后，哈希表为\nKey -> Value"); + PrintUtil.printHashMap(map); + + /* 查询操作 */ + // 向哈希表输入键 key ，得到值 value + String name = map.get(10002); + System.out.println("\n输入学号 10002 ，查询到姓名 " + name); + + /* 删除操作 */ + // 在哈希表中删除键值对 (key, value) + map.remove(10005); + System.out.println("\n删除 10005 后，哈希表为\nKey -> Value"); + PrintUtil.printHashMap(map); + + /* 遍历哈希表 */ + System.out.println("\n遍历键值对 Key->Value"); + for (Map.Entry kv: map.entrySet()) { + System.out.println(kv.getKey() + " -> " + kv.getValue()); + } + System.out.println("\n单独遍历键 Key"); + for (int key: map.keySet()) { + System.out.println(key); + } + System.out.println("\n单独遍历值 Value"); + for (String val: map.values()) { + System.out.println(val); + } + } +} diff --git a/codes/java/include/PrintUtil.java b/codes/java/include/PrintUtil.java index e6e718cea..b8c970504 100755 --- a/codes/java/include/PrintUtil.java +++ b/codes/java/include/PrintUtil.java @@ -91,4 +91,16 @@ public class PrintUtil { showTrunks(p.prev); System.out.print(p.str); } + + /** + * Print a hash map + * @param + * @param + * @param map + */ + public static void printHashMap(Map map) { + for (Map.Entry kv: map.entrySet()) { + System.out.println(kv.getKey() + " -> " + kv.getValue()); + } + } } diff --git a/docs/chapter_hashing/hash_collision.md b/docs/chapter_hashing/hash_collision.md new file mode 100644 index 000000000..40c2a78c3 --- /dev/null +++ b/docs/chapter_hashing/hash_collision.md @@ -0,0 +1,17 @@ +--- +comments: true +--- + +# 哈希冲突处理 + + + +## 链地址法 + + + +## 开放定址法 + + + +## 再哈希法 diff --git a/docs/chapter_hashing/hash_map.md b/docs/chapter_hashing/hash_map.md new file mode 100644 index 000000000..62725faae --- /dev/null +++ b/docs/chapter_hashing/hash_map.md @@ -0,0 +1,153 @@ +--- +comments: true +--- + +# 哈希表 + +哈希表通过建立「键 Key」和「值 Value」之间的映射，实现高效的元素查找。具体地，查询操作（给定一个 Key 查询得到 Value）的时间复杂度为 $O(1)$ 。 + +（图） + +## 哈希表常用操作 + +哈希表的基本操作包括 **初始化、查询操作、添加与删除键值对**。 + +```java title="hash_map.java" +/* 初始化哈希表 */ +Map map = new HashMap<>(); + +/* 添加操作 */ +// 在哈希表中添加键值对 (key, value) +map.put(10001, "小哈"); +map.put(10002, "小啰"); +map.put(10003, "小算"); +map.put(10004, "小法"); +map.put(10005, "小哇"); + +/* 查询操作 */ +// 向哈希表输入键 key ，得到值 value +String name = map.get(10002); + +/* 删除操作 */ +// 在哈希表中删除键值对 (key, value) +map.remove(10005); +``` + +遍历哈希表有三种方式，即 **遍历键值对、遍历键、遍历值**。 + +```java +/* 遍历哈希表 */ +// 遍历键值对 Key->Value +for (Map.Entry kv: map.entrySet()) { + System.out.println(kv.getKey() + " -> " + kv.getValue()); +} +// 单独遍历键 Key +for (int key: map.keySet()) { + System.out.println(key); +} +// 单独遍历值 Value +for (String val: map.values()) { + System.out.println(val); +} +``` + +## 哈希表优势 + +给定一个包含 $n$ 个学生的数据库，每个学生有 "姓名 `name` ” 和 “学号 `id` ” 两项数据，希望实现一个查询功能，即 **输入一个学号，返回对应的姓名**，那么可以使用哪些数据结构来存储呢？ + +- **无序数组：** 每个元素为 `[学号, 姓名]` ； +- **有序数组：** 将 `1.` 中的数组按照学号从小到大排序； +- **链表：** 每个结点的值为 `[学号, 姓名]` ； +- **二叉搜索树：** 每个结点的值为 `[学号, 姓名]` ，根据学号大小来构建树； +- **哈希表：** 以学号为 Key 、姓名为 Value 。 + +使用上述方法，各项操作的时间复杂度如下表所示（在此不做赘述，详解可见 [二叉搜索树章节](https://www.hello-algo.com/chapter_tree/binary_search_tree/#_6)），**哈希表全面胜出！** + +

+ +| | 无序数组 | 有序数组 | 链表 | 二叉搜索树 | 哈希表 | +| ------------ | -------- | ----------- | ------ | ----------- | ------ | +| 查找指定元素 | $O(n)$ | $O(\log n)$ | $O(n)$ | $O(\log n)$ | $O(1)$ | +| 插入元素 | $O(1)$ | $O(n)$ | $O(1)$ | $O(\log n)$ | $O(1)$ | +| 删除元素 | $O(n)$ | $O(n)$ | $O(n)$ | $O(\log n)$ | $O(1)$ | + +
+ +## 哈希函数 + +哈希表中存储元素的数据结构被称为「桶 Bucket」，底层实现可能是数组、链表、二叉树（红黑树），或是它们的组合。 + +最简单地，**我们可以仅用一个「数组」来实现哈希表**。首先，将所有 Value 放入数组中，那么每个 Value 在数组中都有唯一的「索引」。显然，访问 Value 需要给定索引，而为了 **建立 Key 和索引之间的映射关系**，我们需要使用「哈希函数 Hash Function」。 + +设数组为 `bucket` ，哈希函数为 `f(x)` ，输入键为 `key` 。那么获取 Value 的步骤为： + +1. 通过哈希函数计算出索引，即 `index = f(key)` ； +2. 通过索引在数组中获取值，即 `value = bucket[index]` ； + +以上述学生数据 `Key 学号 -> Value 姓名` 为例，我们可以将「哈希函数」设计为 + +$$ +f(x) = x \% 10000 +$$ + +（图） + +```java title="array_hash_map.java" +/* 键值对 int->String */ +class Entry { + public int key; // 键 + public String val; // 值 + public Entry(int key, String val) { + this.key = key; + this.val = val; + } +} + +/* 基于数组简易实现的哈希表 */ +class ArrayHashMap { + private List bucket; + public ArrayHashMap() { + // 初始化一个长度为 10 的桶（数组） + bucket = new ArrayList<>(); + for (int i = 0; i < 10; i++) { + bucket.add(null); + } + } + + /* 哈希函数 */ + private int hashFunc(int key) { + int index = key % 10000; + return index; + } + + /* 查询操作 */ + public String get(int key) { + int index = hashFunc(key); + Entry pair = bucket.get(index); + if (pair == null) return null; + return pair.val; + } + + /* 添加操作 */ + public void put(int key, String val) { + Entry pair = new Entry(key, val); + int index = hashFunc(key); + bucket.set(index, pair); + } + + /* 删除操作 */ + public void remove(int key) { + int index = hashFunc(key); + // 置为空字符，代表删除 + bucket.set(index, null); + } +} +``` + +## 哈希冲突 + +细心的同学可能会发现，哈希函数 $f(x) = x \% 10000$ 会在某些情况下失效。例如，当输入的 Key 为 10001, 20001, 30001, ... 时，哈希函数的计算结果都是 1 ，指向同一个 Value ，表明不同学号指向了同一个人，这明显是不对的。 + +上述现象被称为「哈希冲突 Hash Collision」，其会严重影响查询的正确性，我们将如何避免哈希冲突的问题留在下章讨论。 + +（图） diff --git a/docs/chapter_hashing/summary.md b/docs/chapter_hashing/summary.md new file mode 100644 index 000000000..5f58b7594 --- /dev/null +++ b/docs/chapter_hashing/summary.md @@ -0,0 +1,5 @@ +--- +comments: true +--- + +# 小结 diff --git a/docs/chapter_searching/binary_search.md b/docs/chapter_searching/binary_search.md index 1333faf0f..d0e4a6db9 100644 --- a/docs/chapter_searching/binary_search.md +++ b/docs/chapter_searching/binary_search.md @@ -336,6 +336,6 @@ $$ 但并不意味着所有情况下都应使用二分查找，这是因为： -- **二分查找仅适用于有序数据。** 如果输入数据是乱序的，为了使用二分查找而专门执行数据排序，那么是得不偿失的，因为排序算法的时间复杂度一般为 $O(n \log n)$ ，比线性查找和二分查找都更差。再例如，对于频繁插入元素的场景，为了保持数组的有序性，需要将元素插入到特定位置，时间复杂度为 $O(n)$ ，也是非常昂贵的。 +- **二分查找仅适用于有序数据。** 如果输入数据是无序的，为了使用二分查找而专门执行数据排序，那么是得不偿失的，因为排序算法的时间复杂度一般为 $O(n \log n)$ ，比线性查找和二分查找都更差。再例如，对于频繁插入元素的场景，为了保持数组的有序性，需要将元素插入到特定位置，时间复杂度为 $O(n)$ ，也是非常昂贵的。 - **二分查找仅适用于数组。** 由于在二分查找中，访问索引是 ”非连续“ 的，因此链表或者基于链表实现的数据结构都无法使用。 - **在小数据量下，线性查找的性能更好。** 在线性查找中，每轮只需要 1 次判断操作；而在二分查找中，需要 1 次加法、1 次除法、1 ~ 3 次判断操作、1 次加法（减法），共 4 ~ 6 个单元操作；因此，在数据量 $n$ 较小时，线性查找反而比二分查找更快。 diff --git a/docs/chapter_tree/binary_search_tree.md b/docs/chapter_tree/binary_search_tree.md index 8901b769d..6dac4f7d7 100644 --- a/docs/chapter_tree/binary_search_tree.md +++ b/docs/chapter_tree/binary_search_tree.md @@ -566,7 +566,7 @@ comments: true 假设给定 $n$ 个数字，最常用的存储方式是「数组」，那么对于这串乱序的数字，常见操作的效率为： -- **查找元素：** 由于数组是乱序的，因此需要遍历数组来确定，使用 $O(n)$ 时间； +- **查找元素：** 由于数组是无序的，因此需要遍历数组来确定，使用 $O(n)$ 时间； - **插入元素：** 只需将元素添加至数组尾部即可，使用 $O(1)$ 时间； - **删除元素：** 先查找元素，使用 $O(\log n)$ 时间，再在数组中删除该元素，使用 $O(n)$ 时间； - **获取最小 / 最大元素：** 需要遍历数组来确定，使用 $O(n)$ 时间； @@ -575,14 +575,14 @@ comments: true - **查找元素：** 由于数组已排序，可以使用二分查找，使用 $O(\log n)$ 时间； - **插入元素：** 为了保持数组是有序的，需插入到数组某位置，平均使用 $O(n)$ 时间； -- **删除元素：** 与乱序数组中的情况相同，使用 $O(n)$ 时间； +- **删除元素：** 与无序数组中的情况相同，使用 $O(n)$ 时间； - **获取最小 / 最大元素：** 数组头部和尾部元素即是最小和最大元素，使用 $O(1)$ 时间； -观察发现，乱序数组和排序数组中的各类操作的时间复杂度是 “偏科” 的，即有的快有的慢；**而二叉搜索树的各项操作的时间复杂度都是对数阶，在数据量 $n$ 很大时有巨大优势**。 +观察发现，无序数组和有序数组中的各类操作的时间复杂度是 “偏科” 的，即有的快有的慢；**而二叉搜索树的各项操作的时间复杂度都是对数阶，在数据量 $n$ 很大时有巨大优势**。
-| | 乱序数组 | 排序数组 | 二叉搜索树 | +| | 无序数组 | 有序数组 | 二叉搜索树 | | ------------------- | -------- | ----------- | ----------- | | 查找指定元素 | $O(n)$ | $O(\log n)$ | $O(\log n)$ | | 插入元素 | $O(1)$ | $O(n)$ | $O(\log n)$ | diff --git a/mkdocs.yml b/mkdocs.yml index 0c3cc015a..18675388d 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -146,6 +146,10 @@ nav: - 队列（Queue）: chapter_stack_and_queue/queue.md - 双向队列（Deque）: chapter_stack_and_queue/deque.md - 小结: chapter_stack_and_queue/summary.md + - 散列表: + - 哈希表（HashMap）: chapter_hashing/hash_map.md + - 哈希冲突处理: chapter_hashing/hash_collision.md + - 小结: chapter_hashing/summary.md - 二叉树: - 二叉树（Binary Tree）: chapter_tree/binary_tree.md - 二叉树常见类型: chapter_tree/binary_tree_types.md