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 01/15] 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 80870a0..317bfe6 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 33fd86cf6006a1ee36526bbf16142dc700c6debb Mon Sep 17 00:00:00 2001 From: Yudong Jin Date: Sun, 4 Dec 2022 03:46:28 +0800 Subject: [PATCH 02/15] 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 7e1c523..b5879b4 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 03/15] 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 0000000..1b2e83b --- /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 04/15] 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 0000000..a6d2a51 --- /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 317bfe6..d738598 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 05/15] 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 1b2e83b..9afbdc2 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 d738598..eed7033 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 06/15] 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 0000000..e97c3c9 --- /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 0000000..7cf9441 --- /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 0000000..8d8bb09 --- /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 0000000..072d95f --- /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 0000000..20c709e --- /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 30d3929..8901b76 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 d7c35d9..cf6cad4 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 07/15] 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 9afbdc2..1d49449 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 51e9567..05919c3 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 08/15] 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 0000000..53a892e --- /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 09/15] 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 fcd7e45..bba71f0 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 10/15] 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 53a892e..e9b31b0 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 11/15] 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 e9b31b0..2905087 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 12/15] 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 e97c3c9..332525f 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 7cf9441..1b91ef5 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 8d8bb09..f7e6aa0 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 072d95f..9dd3083 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 0000000..daeb24a --- /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 13/15] 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 cf6cad4..5913a1a 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 14/15] 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 332525f..74b7250 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 15/15] 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 0000000..5fad6f3 --- /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 0000000..bd145b7 --- /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 e6e718c..b8c9705 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 0000000..40c2a78 --- /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 0000000..62725fa --- /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 0000000..5f58b75 --- /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 1333faf..d0e4a6d 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 8901b76..6dac4f7 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 0c3cc01..1867538 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