add js codes to avl_tree.js

codes/javascript/chapter_tree/avl_tree.js

@@ -0,0 +1,213 @@
+/**
+ * File: avl_tree.cpp
+ * Created Time: 2023-02-05
+ * Author: what-is-me (whatisme@outlook.jp)
+ */
+
+let { TreeNode } = require("../include/TreeNode");
+let { printTree } = require("../include/PrintUtil");
+
+/* AVL 树*/
+class AVLTree {
+ /*构造函数*/
+ constructor() {
+ this.root = null; //根节点
+ }
+
+ /* 获取结点高度 */
+ height(node) {
+ // 空结点高度为 -1 ，叶结点高度为 0
+ return node === null ? -1 : node.height;
+ }
+
+ /* 更新结点高度 */
+ updateHeight(node) {
+ // 结点高度等于最高子树高度 + 1
+ node.height = Math.max(this.height(node.left), this.height(node.right)) + 1;
+ }
+
+ /* 获取平衡因子 */
+ balanceFactor(node) {
+ // 空结点平衡因子为 0
+ if (node === null) return 0;
+ // 结点平衡因子 = 左子树高度 - 右子树高度
+ return this.height(node.left) - this.height(node.right);
+ }
+
+ /* 右旋操作 */
+ rightRotate(node) {
+ let child = node.left;
+ let grandChild = child.right;
+ // 以 child 为原点，将 node 向右旋转
+ child.right = node;
+ node.left = grandChild;
+ // 更新结点高度
+ this.updateHeight(node);
+ this.updateHeight(child);
+ // 返回旋转后子树的根节点
+ return child;
+ }
+
+ /* 左旋操作 */
+ leftRotate(node) {
+ let child = node.right;
+ let grandChild = child.left;
+ // 以 child 为原点，将 node 向左旋转
+ child.left = node;
+ node.right = grandChild;
+ // 更新结点高度
+ this.updateHeight(node);
+ this.updateHeight(child);
+ // 返回旋转后子树的根节点
+ return child;
+ }
+
+ /* 执行旋转操作，使该子树重新恢复平衡 */
+ rotate(node) {
+ // 获取结点 node 的平衡因子
+ let 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) {
+ this.root = this.insertHelper(this.root, val);
+ return this.root;
+ }
+
+ /* 递归插入结点（辅助函数） */
+ 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);
+ else return node; // 重复结点不插入，直接返回
+ this.updateHeight(node); // 更新结点高度
+ /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+ node = this.rotate(node);
+ // 返回子树的根节点
+ return node;
+ }
+
+ /* 删除结点 */
+ remove(val) {
+ this.root = this.removeHelper(this.root, val);
+ return this.root;
+ }
+
+ /* 递归删除结点（辅助函数） */
+ 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);
+ else {
+ if (node.left === null || node.right === null) {
+ let 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);
+ 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) {
+ if (node === null) return node;
+ // 循环访问左子结点，直到叶结点时为最小结点，跳出
+ while (node.left !== null) {
+ node = node.left;
+ }
+ return node;
+ }
+
+ /* 查找结点 */
+ search(val) {
+ let cur = this.root;
+ // 循环查找，越过叶结点后跳出
+ while (cur !== null) {
+ // 目标结点在 cur 的右子树中
+ if (cur.val < val) cur = cur.right;
+ // 目标结点在 cur 的左子树中
+ else if (cur.val > val) cur = cur.left;
+ // 找到目标结点，跳出循环
+ else break;
+ }
+ // 返回目标结点
+ return cur;
+ }
+}
+
+function testInsert(tree, val) {
+ tree.insert(val);
+ console.log("\n插入结点 " + val + " 后，AVL 树为");
+ printTree(tree.root);
+}
+
+function testRemove(tree, val) {
+ tree.remove(val);
+ console.log("\n删除结点 " + val + " 后，AVL 树为");
+ printTree(tree.root);
+}
+
+/* 初始化空 AVL 树 */
+let 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 的结点
+
+/* 查询结点 */
+let node = avlTree.search(7);
+console.log("\n查找到的结点对象为 " + node + "，结点值 = " + node.val);

codes/javascript/include/TreeNode.js

@@ -7,23 +7,29 @@
 /**
  * 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); // 右子结点指针
+class TreeNode {
+ val; // 结点值
+ left; // 左子结点指针
+ right; // 右子结点指针
+ height; //结点高度
+ constructor(val, left, right, height) {
+ this.val = val === undefined ? 0 : val;
+ this.left = left === undefined ? null : left;
+ this.right = right === undefined ? null : right;
+ this.height = height === undefined ? 0 : height;
+ }
 }
 
 /**
-* Generate a binary tree given an array
-* @param arr
-* @return
-*/
+ * Generate a binary tree given an array
+ * @param arr
+ * @return
+ */
 function arrToTree(arr) {
- if (arr.length === 0)
- return null;
-
+ if (arr.length === 0) return null;
+
  let root = new TreeNode(arr[0]);
- let queue = [root] 
+ let queue = [root];
  let i = 0;
  while (queue.length) {
  let node = queue.shift();
@@ -42,7 +48,7 @@ function arrToTree(arr) {
  return root;
 }
 
-module.exports = { 
+module.exports = {
  TreeNode,
  arrToTree,
-}
+};