algorithm/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2025-11-02 21:24:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

Update JavaScript and TypeScript codes for all chapters, rename JavaScript and TypeScript import folder to modules (#402)

Browse Source 
* Update JavaScript and TypeScript codes

* Rename JavaScript and TypeScript import folder to modules
This commit is contained in:
Justin Tse
2023-03-03 01:34:53 +08:00
committed by GitHub
parent 7b41e6c2f0
commit e4a98bc9c5
61 changed files with 324 additions and 290 deletions
Download Patch File Download Diff File Expand all files Collapse all files

62
codes/javascript/chapter_tree/avl_tree.js
View File

@ -4,8 +4,8 @@
* Author: what-is-me (whatisme@outlook.jp)
*/
const { TreeNode } = require("../include/TreeNode");
const { printTree } = require("../include/PrintUtil");
const { TreeNode } = require("../modules/TreeNode");
const { printTree } = require("../modules/PrintUtil");
/* AVL 树*/
class AVLTree {
@ -21,7 +21,7 @@ class AVLTree {
}
/* 更新结点高度 */
updateHeight(node) {
#updateHeight(node) {
// 结点高度等于最高子树高度 + 1
node.height = Math.max(this.height(node.left), this.height(node.right)) + 1;
}
@ -35,57 +35,57 @@ class AVLTree {
}
/* 右旋操作 */
rightRotate(node) {
#rightRotate(node) {
const child = node.left;
const grandChild = child.right;
// 以 child 为原点，将 node 向右旋转
child.right = node;
node.left = grandChild;
// 更新结点高度
this.updateHeight(node);
this.updateHeight(child);
this.#updateHeight(node);
this.#updateHeight(child);
// 返回旋转后子树的根结点
return child;
}
/* 左旋操作 */
leftRotate(node) {
#leftRotate(node) {
const child = node.right;
const grandChild = child.left;
// 以 child 为原点，将 node 向左旋转
child.left = node;
node.right = grandChild;
// 更新结点高度
this.updateHeight(node);
this.updateHeight(child);
this.#updateHeight(node);
this.#updateHeight(child);
// 返回旋转后子树的根结点
return child;
}
/* 执行旋转操作，使该子树重新恢复平衡 */
rotate(node) {
#rotate(node) {
// 获取结点 node 的平衡因子
const balanceFactor = this.balanceFactor(node);
// 左偏树
if (balanceFactor > 1) {
if (this.balanceFactor(node.left) >= 0) {
// 右旋
return this.rightRotate(node);
return this.#rightRotate(node);
} else {
// 先左旋后右旋
node.left = this.leftRotate(node.left);
return this.rightRotate(node);
node.left = this.#leftRotate(node.left);
return this.#rightRotate(node);
}
}
// 右偏树
if (balanceFactor < -1) {
if (this.balanceFactor(node.right) <= 0) {
// 左旋
return this.leftRotate(node);
return this.#leftRotate(node);
} else {
// 先右旋后左旋
node.right = this.rightRotate(node.right);
return this.leftRotate(node);
node.right = this.#rightRotate(node.right);
return this.#leftRotate(node);
}
}
// 平衡树，无需旋转，直接返回
@ -94,36 +94,36 @@ class AVLTree {
/* 插入结点 */
insert(val) {
this.root = this.insertHelper(this.root, val);
this.root = this.#insertHelper(this.root, val);
return this.root;
}
/* 递归插入结点（辅助方法） */
insertHelper(node, val) {
#insertHelper(node, val) {
if (node === null) return new TreeNode(val);
/* 1. 查找插入位置，并插入结点 */
if (val < node.val) node.left = this.insertHelper(node.left, val);
else if (val > node.val) node.right = this.insertHelper(node.right, val);
if (val < node.val) node.left = this.#insertHelper(node.left, val);
else if (val > node.val) node.right = this.#insertHelper(node.right, val);
else return node; // 重复结点不插入，直接返回
this.updateHeight(node); // 更新结点高度
this.#updateHeight(node); // 更新结点高度
/* 2. 执行旋转操作，使该子树重新恢复平衡 */
node = this.rotate(node);
node = this.#rotate(node);
// 返回子树的根结点
return node;
}
/* 删除结点 */
remove(val) {
this.root = this.removeHelper(this.root, val);
this.root = this.#removeHelper(this.root, val);
return this.root;
}
/* 递归删除结点（辅助方法） */
removeHelper(node, val) {
#removeHelper(node, val) {
if (node === null) return null;
/* 1. 查找结点，并删除之 */
if (val < node.val) node.left = this.removeHelper(node.left, val);
else if (val > node.val) node.right = this.removeHelper(node.right, val);
if (val < node.val) node.left = this.#removeHelper(node.left, val);
else if (val > node.val) node.right = this.#removeHelper(node.right, val);
else {
if (node.left === null || node.right === null) {
const child = node.left !== null ? node.left : node.right;
@ -133,20 +133,20 @@ class AVLTree {
else node = child;
} else {
// 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
const temp = this.getInOrderNext(node.right);
node.right = this.removeHelper(node.right, temp.val);
const temp = this.#getInOrderNext(node.right);
node.right = this.#removeHelper(node.right, temp.val);
node.val = temp.val;
}
}
this.updateHeight(node); // 更新结点高度
this.#updateHeight(node); // 更新结点高度
/* 2. 执行旋转操作，使该子树重新恢复平衡 */
node = this.rotate(node);
node = this.#rotate(node);
// 返回子树的根结点
return node;
}
/* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
getInOrderNext(node) {
#getInOrderNext(node) {
if (node === null) return node;
// 循环访问左子结点，直到叶结点时为最小结点，跳出
while (node.left !== null) {

14
codes/javascript/chapter_tree/binary_search_tree.js
View File

@ -1,14 +1,14 @@
/**
* File: binary_tree.js
* File: binary_search_tree.js
* Created Time: 2022-12-04
* Author: IsChristina (christinaxia77@foxmail.com)
*/
const Tree = require("../include/TreeNode");
const { printTree } = require("../include/PrintUtil");
const { TreeNode } = require("../modules/TreeNode");
const { printTree } = require("../modules/PrintUtil");
/* 二叉搜索树 */
var root;
let root;
function BinarySearchTree(nums) {
nums.sort((a, b) => { return a - b }); // 排序数组
@ -25,7 +25,7 @@ function buildTree(nums, i, j) {
if (i > j) return null;
// 将数组中间结点作为根结点
let mid = Math.floor((i + j) / 2);
let root = new Tree.TreeNode(nums[mid]);
let root = new TreeNode(nums[mid]);
// 递归建立左子树和右子树
root.left = buildTree(nums, i, mid - 1);
root.right = buildTree(nums, mid + 1, j);
@ -64,7 +64,7 @@ function insert(num) {
else cur = cur.left;
}
// 插入结点 val
let node = new Tree.TreeNode(num);
let node = new TreeNode(num);
if (pre.val < num) pre.right = node;
else pre.left = node;
return node;
@ -120,7 +120,7 @@ function getInOrderNext(root) {
/* Driver Code */
/* 初始化二叉搜索树 */
var nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
const nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
BinarySearchTree(nums);
console.log("\n初始化的二叉树为\n");
printTree(getRoot());

16
codes/javascript/chapter_tree/binary_tree.js
View File

@ -4,16 +4,16 @@
* Author: IsChristina (christinaxia77@foxmail.com)
*/
const Tree = require("../include/TreeNode");
const { printTree } = require("../include/PrintUtil");
const { TreeNode } = require("../modules/TreeNode");
const { printTree } = require("../modules/PrintUtil");
/* 初始化二叉树 */
// 初始化结点
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);
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;
@ -23,7 +23,7 @@ console.log("\n初始化二叉树\n");
printTree(n1);
/* 插入与删除结点 */
let P = new Tree.TreeNode(0);
const P = new TreeNode(0);
// 在 n1 -> n2 中间插入结点 P
n1.left = P;
P.left = n2;

14
codes/javascript/chapter_tree/binary_tree_bfs.js
View File

@ -1,18 +1,18 @@
/**
* File: binary_tree.js
* File: binary_tree_bfs.js
* Created Time: 2022-12-04
* Author: IsChristina (christinaxia77@foxmail.com)
*/
const { arrToTree } = require("../include/TreeNode");
const { printTree } = require("../include/PrintUtil");
const { arrToTree } = require("../modules/TreeNode");
const { printTree } = require("../modules/PrintUtil");
/* 层序遍历 */
function levelOrder(root) {
// 初始化队列，加入根结点
let queue = [root];
const queue = [root];
// 初始化一个列表，用于保存遍历序列
let list = [];
const list = [];
while (queue.length) {
let node = queue.shift(); // 队列出队
list.push(node.val); // 保存结点值
@ -28,10 +28,10 @@ function levelOrder(root) {
/* Driver Code */
/* 初始化二叉树 */
// 这里借助了一个从数组直接生成二叉树的函数
var root = arrToTree([1, 2, 3, 4, 5, 6, 7]);
const root = arrToTree([1, 2, 3, 4, 5, 6, 7]);
console.log("\n初始化二叉树\n");
printTree(root);
/* 层序遍历 */
let list = levelOrder(root);
const list = levelOrder(root);
console.log("\n层序遍历的结点打印序列 = " + list);

10
codes/javascript/chapter_tree/binary_tree_dfs.js
View File

@ -1,14 +1,14 @@
/**
* File: binary_tree.js
* File: binary_tree_dfs.js
* Created Time: 2022-12-04
* Author: IsChristina (christinaxia77@foxmail.com)
*/
const { arrToTree } = require("../include/TreeNode");
const { printTree } = require("../include/PrintUtil");
const { arrToTree } = require("../modules/TreeNode");
const { printTree } = require("../modules/PrintUtil");
// 初始化列表，用于存储遍历序列
var list = [];
const list = [];
/* 前序遍历 */
function preOrder(root) {
@ -40,7 +40,7 @@ function postOrder(root) {
/* Driver Code */
/* 初始化二叉树 */
// 这里借助了一个从数组直接生成二叉树的函数
var root = arrToTree([1, 2, 3, 4, 5, 6, 7]);
const root = arrToTree([1, 2, 3, 4, 5, 6, 7]);
console.log("\n初始化二叉树\n");
printTree(root);