Skip to content

Commit

Permalink
Add TypeScript code and docs to AVL tree and the coding style for Typ…
Browse files Browse the repository at this point in the history
…escript and JavaScript (#342)

* Add TypeScript code and docs to AVL tree and update JavaScript style

* Update the coding style for Typescript and JavaScript
  • Loading branch information
justin-tse authored Feb 6, 2023
1 parent 7f4243a commit b145681
Show file tree
Hide file tree
Showing 9 changed files with 453 additions and 49 deletions.
Original file line number Diff line number Diff line change
Expand Up @@ -6,7 +6,7 @@

/* 生成一个数组,元素为 { 1, 2, ..., n },顺序被打乱 */
function randomNumbers(n) {
let nums = Array(n);
const nums = Array(n);
// 生成数组 nums = { 1, 2, 3, ..., n }
for (let i = 0; i < n; i++) {
nums[i] = i + 1;
Expand Down
27 changes: 14 additions & 13 deletions codes/javascript/chapter_tree/avl_tree.js
Original file line number Diff line number Diff line change
@@ -1,11 +1,11 @@
/**
* File: avl_tree.cpp
* File: avl_tree.js
* Created Time: 2023-02-05
* Author: what-is-me (whatisme@outlook.jp)
*/

let { TreeNode } = require("../include/TreeNode");
let { printTree } = require("../include/PrintUtil");
const { TreeNode } = require("../include/TreeNode");
const { printTree } = require("../include/PrintUtil");

/* AVL 树*/
class AVLTree {
Expand Down Expand Up @@ -36,8 +36,8 @@ class AVLTree {

/* 右旋操作 */
rightRotate(node) {
let child = node.left;
let grandChild = child.right;
const child = node.left;
const grandChild = child.right;
// 以 child 为原点,将 node 向右旋转
child.right = node;
node.left = grandChild;
Expand All @@ -50,8 +50,8 @@ class AVLTree {

/* 左旋操作 */
leftRotate(node) {
let child = node.right;
let grandChild = child.left;
const child = node.right;
const grandChild = child.left;
// 以 child 为原点,将 node 向左旋转
child.left = node;
node.right = grandChild;
Expand All @@ -65,7 +65,7 @@ class AVLTree {
/* 执行旋转操作,使该子树重新恢复平衡 */
rotate(node) {
// 获取结点 node 的平衡因子
let balanceFactor = this.balanceFactor(node);
const balanceFactor = this.balanceFactor(node);
// 左偏树
if (balanceFactor > 1) {
if (this.balanceFactor(node.left) >= 0) {
Expand Down Expand Up @@ -126,14 +126,14 @@ class AVLTree {
else if (val > node.val) node.right = this.removeHelper(node.right, val);
else {
if (node.left === null || node.right === null) {
let child = node.left !== null ? node.left : node.right;
const child = node.left !== null ? node.left : node.right;
// 子结点数量 = 0 ,直接删除 node 并返回
if (child === null) return null;
// 子结点数量 = 1 ,直接删除 node
else node = child;
} else {
// 子结点数量 = 2 ,则将中序遍历的下个结点删除,并用该结点替换当前结点
let temp = this.getInOrderNext(node.right);
const temp = this.getInOrderNext(node.right);
node.right = this.removeHelper(node.right, temp.val);
node.val = temp.val;
}
Expand Down Expand Up @@ -184,8 +184,9 @@ function testRemove(tree, val) {
printTree(tree.root);
}

/* Driver Code */
/* 初始化空 AVL 树 */
let avlTree = new AVLTree();
const avlTree = new AVLTree();
/* 插入结点 */
// 请关注插入结点后,AVL 树是如何保持平衡的
testInsert(avlTree, 1);
Expand All @@ -209,5 +210,5 @@ testRemove(avlTree, 5); // 删除度为 1 的结点
testRemove(avlTree, 4); // 删除度为 2 的结点

/* 查询结点 */
let node = avlTree.search(7);
console.log("\n查找到的结点对象为 " + node + ",结点值 = " + node.val);
const node = avlTree.search(7);
console.log("\n查找到的结点对象为", node, ",结点值 = " + node.val);
Original file line number Diff line number Diff line change
Expand Up @@ -6,15 +6,15 @@

/* 生成一个数组,元素为 { 1, 2, ..., n },顺序被打乱 */
function randomNumbers(n: number): number[] {
let nums = Array(n);
const nums = Array(n);
// 生成数组 nums = { 1, 2, 3, ..., n }
for (let i = 0; i < n; i++) {
nums[i] = i + 1;
}
// 随机打乱数组元素
for (let i = 0; i < n; i++) {
let r = Math.floor(Math.random() * (i + 1));
let temp = nums[i];
const r = Math.floor(Math.random() * (i + 1));
const temp = nums[i];
nums[i] = nums[r];
nums[r] = temp;
}
Expand All @@ -35,9 +35,9 @@ function findOne(nums: number[]): number {

/* Driver Code */
for (let i = 0; i < 10; i++) {
let n = 100;
let nums = randomNumbers(n);
let index = findOne(nums);
const n = 100;
const nums = randomNumbers(n);
const index = findOne(nums);
console.log(
"\n数组 [ 1, 2, ..., n ] 被打乱后 = [" + nums.join(", ") + "]"
);
Expand Down
2 changes: 1 addition & 1 deletion codes/typescript/chapter_searching/linear_search.ts
Original file line number Diff line number Diff line change
Expand Up @@ -37,7 +37,7 @@ function linearSearchLinkedList(head: ListNode | null, target: number): ListNode
const target = 3;

/* 在数组中执行线性查找 */
const nums = [ 1, 5, 3, 2, 4, 7, 5, 9, 10, 8 ];
const nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8];
const index = linearSearchArray(nums, target);
console.log('目标元素 3 的索引 =', index);

Expand Down
228 changes: 228 additions & 0 deletions codes/typescript/chapter_tree/avl_tree.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,228 @@
/**
* File: avl_tree.ts
* Created Time: 2023-02-06
* Author: Justin (xiefahit@gmail.com)
*/

import { TreeNode } from "../module/TreeNode";
import { printTree } from "../module/PrintUtil";

/* AVL 树*/
class AVLTree {
root: TreeNode;
/*构造函数*/
constructor() {
this.root = null; //根节点
}

/* 获取结点高度 */
height(node: TreeNode): number {
// 空结点高度为 -1 ,叶结点高度为 0
return node === null ? -1 : node.height;
}

/* 更新结点高度 */
updateHeight(node: TreeNode): void {
// 结点高度等于最高子树高度 + 1
node.height = Math.max(this.height(node.left), this.height(node.right)) + 1;
}

/* 获取平衡因子 */
balanceFactor(node: TreeNode): number {
// 空结点平衡因子为 0
if (node === null) return 0;
// 结点平衡因子 = 左子树高度 - 右子树高度
return this.height(node.left) - this.height(node.right);
}

/* 右旋操作 */
rightRotate(node: TreeNode): TreeNode {
const child = node.left;
const grandChild = child.right;
// 以 child 为原点,将 node 向右旋转
child.right = node;
node.left = grandChild;
// 更新结点高度
this.updateHeight(node);
this.updateHeight(child);
// 返回旋转后子树的根节点
return child;
}

/* 左旋操作 */
leftRotate(node: TreeNode): TreeNode {
const child = node.right;
const grandChild = child.left;
// 以 child 为原点,将 node 向左旋转
child.left = node;
node.right = grandChild;
// 更新结点高度
this.updateHeight(node);
this.updateHeight(child);
// 返回旋转后子树的根节点
return child;
}

/* 执行旋转操作,使该子树重新恢复平衡 */
rotate(node: TreeNode): TreeNode {
// 获取结点 node 的平衡因子
const balanceFactor = this.balanceFactor(node);
// 左偏树
if (balanceFactor > 1) {
if (this.balanceFactor(node.left) >= 0) {
// 右旋
return this.rightRotate(node);
} else {
// 先左旋后右旋
node.left = this.leftRotate(node.left);
return this.rightRotate(node);
}
}
// 右偏树
if (balanceFactor < -1) {
if (this.balanceFactor(node.right) <= 0) {
// 左旋
return this.leftRotate(node);
} else {
// 先右旋后左旋
node.right = this.rightRotate(node.right);
return this.leftRotate(node);
}
}
// 平衡树,无需旋转,直接返回
return node;
}

/* 插入结点 */
insert(val: number): TreeNode {
this.root = this.insertHelper(this.root, val);
return this.root;
}

/* 递归插入结点(辅助函数) */
insertHelper(node: TreeNode, val: number): TreeNode {
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);
} else {
return node; // 重复结点不插入,直接返回
}
this.updateHeight(node); // 更新结点高度
/* 2. 执行旋转操作,使该子树重新恢复平衡 */
node = this.rotate(node);
// 返回子树的根节点
return node;
}

/* 删除结点 */
remove(val: number): TreeNode {
this.root = this.removeHelper(this.root, val);
return this.root;
}

/* 递归删除结点(辅助函数) */
removeHelper(node: TreeNode, val: number): TreeNode {
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);
} else {
if (node.left === null || node.right === null) {
const child = node.left !== null ? node.left : node.right;
// 子结点数量 = 0 ,直接删除 node 并返回
if (child === null) {
return null;
} else {
// 子结点数量 = 1 ,直接删除 node
node = child;
}
} else {
// 子结点数量 = 2 ,则将中序遍历的下个结点删除,并用该结点替换当前结点
const temp = this.getInOrderNext(node.right);
node.right = this.removeHelper(node.right, temp.val);
node.val = temp.val;
}
}
this.updateHeight(node); // 更新结点高度
/* 2. 执行旋转操作,使该子树重新恢复平衡 */
node = this.rotate(node);
// 返回子树的根节点
return node;
}

/* 获取中序遍历中的下一个结点(仅适用于 root 有左子结点的情况) */
getInOrderNext(node: TreeNode): TreeNode {
if (node === null) return node;
// 循环访问左子结点,直到叶结点时为最小结点,跳出
while (node.left !== null) {
node = node.left;
}
return node;
}

/* 查找结点 */
search(val: number): TreeNode {
let cur = this.root;
// 循环查找,越过叶结点后跳出
while (cur !== null) {
if (cur.val < val) {
// 目标结点在 cur 的右子树中
cur = cur.right;
} else if (cur.val > val) {
// 目标结点在 cur 的左子树中
cur = cur.left;
} else {
// 找到目标结点,跳出循环
break;
}
}
// 返回目标结点
return cur;
}
}

function testInsert(tree: AVLTree, val: number): void {
tree.insert(val);
console.log("\n插入结点 " + val + " 后,AVL 树为");
printTree(tree.root);
}

function testRemove(tree: AVLTree, val: number): void {
tree.remove(val);
console.log("\n删除结点 " + val + " 后,AVL 树为");
printTree(tree.root);
}

/* Driver Code */
/* 初始化空 AVL 树 */
const avlTree = new AVLTree();
/* 插入结点 */
// 请关注插入结点后,AVL 树是如何保持平衡的
testInsert(avlTree, 1);
testInsert(avlTree, 2);
testInsert(avlTree, 3);
testInsert(avlTree, 4);
testInsert(avlTree, 5);
testInsert(avlTree, 8);
testInsert(avlTree, 7);
testInsert(avlTree, 9);
testInsert(avlTree, 10);
testInsert(avlTree, 6);

/* 插入重复结点 */
testInsert(avlTree, 7);

/* 删除结点 */
// 请关注删除结点后,AVL 树是如何保持平衡的
testRemove(avlTree, 8); // 删除度为 0 的结点
testRemove(avlTree, 5); // 删除度为 1 的结点
testRemove(avlTree, 4); // 删除度为 2 的结点

/* 查询结点 */
const node = avlTree.search(7);
console.log("\n查找到的结点对象为", node, ",结点值 = " + node.val);
19 changes: 18 additions & 1 deletion codes/typescript/module/ListNode.ts
Original file line number Diff line number Diff line change
Expand Up @@ -31,4 +31,21 @@ function arrToLinkedList(arr: number[]): ListNode | null {
return dum.next;
}

export { ListNode, arrToLinkedList };
/**
* Get a list node with specific value from a linked list
* @param head
* @param val
* @return
*/
function getListNode(head: ListNode | null, val: number): ListNode | null {
while (head !== null && head.val !== val) {
head = head.next;
}
return head;
}

export {
ListNode,
arrToLinkedList,
getListNode
};
Loading

0 comments on commit b145681

Please sign in to comment.