yetao
/
hello-algo
mirror of https://github.com/krahets/hello-algo.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add TypeScript code and docs to AVL tree and the coding style for Typescript and JavaScript (#342)

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

* Update the coding style for Typescript and JavaScript
pull/349/head
Justin Tse 2 years ago committed by GitHub
parent 7f4243ab77
commit b14568151c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 453 additions and 49 deletions
Show Stats Download Patch File Download Diff File

2
codes/javascript/chapter_computational_complexity/worst_best_time_complexity.js
Unescape View File

@ -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;

27
codes/javascript/chapter_tree/avl_tree.js
Unescape View File

@ -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 {
@ -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;
@ -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;
@ -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) {
@ -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;
}
@ -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);
@ -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);

12
codes/typescript/chapter_computational_complexity/worst_best_time_complexity.ts
Unescape View File

@ -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;
}
@ -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(", ") + "]"
);

2
codes/typescript/chapter_searching/linear_search.ts
Unescape View File

@ -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);

228
codes/typescript/chapter_tree/avl_tree.ts
Unescape View File

@ -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
codes/typescript/module/ListNode.ts
Unescape View File

@ -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
};

19
codes/typescript/module/TreeNode.ts
Unescape View File

@ -8,14 +8,15 @@
* Definition for a binary tree node.
*/
class TreeNode {
val: number;
left: TreeNode | null;
right: TreeNode | null;
constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
this.val = val === undefined ? 0 : val; // 结点值
this.left = left === undefined ? null : left; // 左子结点指针
this.right = right === undefined ? null : right; // 右子结点指针
val: number; // 结点值
height: number; // 结点高度
left: TreeNode | null; // 左子结点指针
right: TreeNode | null; // 右子结点指针
constructor(val?: number, height?: number, left?: TreeNode | null, right?: TreeNode | null) {
this.val = val === undefined ? 0 : val;
this.height = height === undefined ? 0 : height;
this.left = left === undefined ? null : left;
this.right = right === undefined ? null : right;
}
}
@ -33,7 +34,7 @@ function arrToTree(arr: (number | null)[]): TreeNode | null {
const queue = [root];
let i = 0;
while (queue.length) {
let node = queue.shift() as TreeNode;
const node = queue.shift() as TreeNode;
if (++i >= arr.length) break;
if (arr[i] !== null) {
node.left = new TreeNode(arr[i] as number);

8
docs/chapter_computational_complexity/time_complexity.md
Unescape View File

@ -2555,7 +2555,7 @@ $$
```js title="worst_best_time_complexity.js"
/* 生成一个数组，元素为 { 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;
@ -2588,15 +2588,15 @@ $$
```typescript title="worst_best_time_complexity.ts"
/* 生成一个数组，元素为 { 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;
}

185
docs/chapter_tree/avl_tree.md
Unescape View File

@ -82,14 +82,14 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
```js title="avl_tree.js"
class TreeNode {
val; // 结点值
height; //结点高度
left; // 左子结点指针
right; // 右子结点指针
height; //结点高度
constructor(val, left, right, height) {
this.val = val === undefined ? 0 : val;
this.height = height === undefined ? 0 : height;
this.left = left === undefined ? null : left;
this.right = right === undefined ? null : right;
this.height = height === undefined ? 0 : height;
}
}
```
@ -97,7 +97,18 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
=== "TypeScript"
```typescript title="avl_tree.ts"
class TreeNode {
val: number; // 结点值
height: number; // 结点高度
left: TreeNode | null; // 左子结点指针
right: TreeNode | null; // 右子结点指针
constructor(val?: number, height?: number, left?: TreeNode | null, right?: TreeNode | null) {
this.val = val === undefined ? 0 : val;
this.height = height === undefined ? 0 : height;
this.left = left === undefined ? null : left;
this.right = right === undefined ? null : right;
}
}
```
=== "C"
@ -228,7 +239,17 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
=== "TypeScript"
```typescript title="avl_tree.ts"
/* 获取结点高度 */
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;
}
```
=== "C"
@ -340,7 +361,13 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
=== "TypeScript"
```typescript title="avl_tree.ts"
/* 获取平衡因子 */
balanceFactor(node: TreeNode): number {
// 空结点平衡因子为 0
if (node === null) return 0;
// 结点平衡因子 = 左子树高度 - 右子树高度
return this.height(node.left) - this.height(node.right);
}
```
=== "C"
@ -479,8 +506,8 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
```js title="avl_tree.js"
/* 右旋操作 */
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;
@ -495,7 +522,19 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
=== "TypeScript"
```typescript title="avl_tree.ts"
/* 右旋操作 */
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;
}
```
=== "C"
@ -624,8 +663,8 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
```js title="avl_tree.js"
/* 左旋操作 */
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;
@ -640,7 +679,19 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
=== "TypeScript"
```typescript title="avl_tree.ts"
/* 左旋操作 */
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;
}
```
=== "C"
@ -843,7 +894,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
/* 执行旋转操作，使该子树重新恢复平衡 */
rotate(node) {
// 获取结点 node 的平衡因子
let balanceFactor = this.balanceFactor(node);
const balanceFactor = this.balanceFactor(node);
// 左偏树
if (balanceFactor > 1) {
if (this.balanceFactor(node.left) >= 0) {
@ -874,7 +925,35 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
=== "TypeScript"
```typescript title="avl_tree.ts"
/* 执行旋转操作，使该子树重新恢复平衡 */
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;
}
```
=== "C"
@ -1092,7 +1171,29 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
=== "TypeScript"
```typescript title="avl_tree.ts"
/* 插入结点 */
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;
}
```
=== "C"
@ -1333,14 +1434,14 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
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;
}
@ -1351,12 +1452,68 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
// 返回子树的根节点
return node;
}
/* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
getInOrderNext(node) {
if (node === null) return node;
// 循环访问左子结点，直到叶结点时为最小结点，跳出
while (node.left !== null) {
node = node.left;
}
return node;
}
```
=== "TypeScript"
```typescript title="avl_tree.ts"
/* 删除结点 */
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;
}
```
=== "C"

Write Preview
Loading…
Cancel
Save