JS实现平衡二叉树

  1       class TreeNode {
  2         constructor(key) {
  3           this.key = key;
  4           this.leftChild = null;
  5           this.rightChild = null;
  6           this.parent = null;
  7         }
  8         rightRotate() {
  9           const sonNode = this.leftChild;
 10           const grandsonNode = sonNode.rightChild;
 11           sonNode.rightChild = this;
 12           sonNode.parent = null;
 13           this.parent = sonNode;
 14           this.leftChild = null;
 15           if (grandsonNode) {
 16             grandsonNode.parent = this;
 17           }
 18           this.leftChild = grandsonNode;
 19           return sonNode;
 20         }
 21         leftRotate() {
 22           const sonNode = this.rightChild;
 23           const grandsonNode = sonNode.leftChild;
 24           sonNode.leftChild = this;
 25           sonNode.parent = null;
 26           if (grandsonNode) {
 27             grandsonNode.parent = this;
 28           }
 29           this.rightChild = grandsonNode;
 30           return sonNode;
 31         }
 32       }
 33 
 34       class AVLTree {
 35         constructor(keys) {
 36           this.root = new TreeNode(keys[0]);
 37           const restKeys = keys.slice(1);
 38           restKeys.forEach((value) => {
 39             this.insertNode(new TreeNode(value), this.root);
 40           });
 41         }
 42         insertNode(newNode, parent) {
 43           if (newNode.key > parent.key) {
 44             if (parent.rightChild === null) {
 45               parent.rightChild = newNode;
 46               newNode.parent = parent;
 47             } else {
 48               this.insertNode(newNode, parent.rightChild);
 49             }
 50           } else if (newNode.key < parent.key) {
 51             if (parent.leftChild === null) {
 52               parent.leftChild = newNode;
 53               newNode.parent = parent;
 54             } else {
 55               this.insertNode(newNode, parent.leftChild);
 56             }
 57           }
 58           //当添加完一个节点后，如果右子树的高度-左子树的高度>1，左旋转
 59           if (
 60             this.getHeight(parent.rightChild) -
 61               this.getHeight(parent.leftChild) >
 62             1
 63           ) {
 64             //如果它的右子树的左子树大于它的右子树的右子树的高度
 65             if (
 66               this.getHeight(parent.rightChild.leftChild) >
 67               this.getHeight(parent.rightChild.rightChild)
 68             ) {
 69               parent.rightChild = parent.rightChild.rightRotate();
 70             }
 71             //当前节点左旋转
 72             if (parent.parent) {
 73               parent.parent.rightChild = parent.leftRotate();
 74             } else {
 75               this.root = parent.leftRotate();
 76             }
 77             return;
 78           }
 79 
 80           //当添加完后，如果左子树的高度-右子树的高度>1,右旋转
 81           if (
 82             this.getHeight(parent.leftChild) -
 83               this.getHeight(parent.rightChild) >
 84             1
 85           ) {
 86             //如果它的左子树的右子树大于它的左子树的左子树的高度
 87             if (
 88               this.getHeight(parent.leftChild.rightChild) >
 89               this.getHeight(parent.leftChild.leftChild)
 90             ) {
 91               //先对其当前节点的左节点进行左旋转
 92               parent.leftChild = parent.leftChild.leftRotate();
 93             }
 94             //对当前节点进行右旋转
 95             if (parent.parent) {
 96               parent.parent.leftChild = parent.rightRotate();
 97             } else {
 98               this.root = parent.rightRotate();
 99             }
100           }
101         }
102         getHeight(node) {
103           if (!node) {
104             return 0;
105           } else {
106             return (
107               Math.max(
108                 node.leftChild === null ? 0 : this.getHeight(node.leftChild),
109                 node.rightChild === null ? 0 : this.getHeight(node.rightChild)
110               ) + 1
111             );
112           }
113         }
114       }
115 
116       //测试数据
117       // console.log(new AVLTree([1, 2, 3]));
118       // console.log(new AVLTree([1, 2, 3, 4]));
119       // console.log(new AVLTree([4, 3, 2, 1]));
120       // console.log(new AVLTree([3, 2, 4, 5, 1, 0]));
121       // console.log(new AVLTree([10, 11, 7, 6, 8, 9]));
122       // console.log(new AVLTree([2, 1, 5, 3, 6, 4]));
123       // console.log(new AVLTree([6, 2, 9, 1, 8, 12, 7, 11, 13, 10]));
124 
125       // console.log(new AVLTree([3, 2, 1]));
126       // console.log(new AVLTree([1, 2, 3]));
127       // console.log(new AVLTree([5, 2, 6, 1, 4, 3]));
128       // console.log(new AVLTree([5, 2, 6, 1, 3, 4]));
129       // console.log(new AVLTree([4, 2, 3]));
130       // console.log(new AVLTree([2, 1, 5, 3, 6, 4]));
131       // console.log(new AVLTree([2, 1, 5, 4, 6, 3]));
132       // console.log(new AVLTree([2, 3, 4]));