JS实现平衡二叉树

      class TreeNode {
        constructor(key) {
          this.key = key;
          this.leftChild = null;
          this.rightChild = null;
          this.parent = null;
        }
        rightRotate() {
          const sonNode = this.leftChild;
          const grandsonNode = sonNode.rightChild;
          sonNode.rightChild = this;
          sonNode.parent = null;
          this.parent = sonNode;
          this.leftChild = null;
          if (grandsonNode) {
            grandsonNode.parent = this;
          }
          this.leftChild = grandsonNode;
          return sonNode;
        }
        leftRotate() {
          const sonNode = this.rightChild;
          const grandsonNode = sonNode.leftChild;
          sonNode.leftChild = this;
          sonNode.parent = null;
          if (grandsonNode) {
            grandsonNode.parent = this;
          }
          this.rightChild = grandsonNode;
          return sonNode;
        }
      }

      class AVLTree {
        constructor(keys) {
          this.root = new TreeNode(keys[0]);
          const restKeys = keys.slice(1);
          restKeys.forEach((value) => {
            this.insertNode(new TreeNode(value), this.root);
          });
        }
        insertNode(newNode, parent) {
          if (newNode.key > parent.key) {
            if (parent.rightChild === null) {
              parent.rightChild = newNode;
              newNode.parent = parent;
            } else {
              this.insertNode(newNode, parent.rightChild);
            }
          } else if (newNode.key < parent.key) {
            if (parent.leftChild === null) {
              parent.leftChild = newNode;
              newNode.parent = parent;
            } else {
              this.insertNode(newNode, parent.leftChild);
            }
          }
          //当添加完一个节点后，如果右子树的高度-左子树的高度>1，左旋转
          if (
            this.getHeight(parent.rightChild) -
              this.getHeight(parent.leftChild) >
            1
          ) {
            //如果它的右子树的左子树大于它的右子树的右子树的高度
            if (
              this.getHeight(parent.rightChild.leftChild) >
              this.getHeight(parent.rightChild.rightChild)
            ) {
              parent.rightChild = parent.rightChild.rightRotate();
            }
            //当前节点左旋转
            if (parent.parent) {
              parent.parent.rightChild = parent.leftRotate();
            } else {
              this.root = parent.leftRotate();
            }
            return;
          }

          //当添加完后，如果左子树的高度-右子树的高度>1,右旋转
          if (
            this.getHeight(parent.leftChild) -
              this.getHeight(parent.rightChild) >
            1
          ) {
            //如果它的左子树的右子树大于它的左子树的左子树的高度
            if (
              this.getHeight(parent.leftChild.rightChild) >
              this.getHeight(parent.leftChild.leftChild)
            ) {
              //先对其当前节点的左节点进行左旋转
              parent.leftChild = parent.leftChild.leftRotate();
            }
            //对当前节点进行右旋转
            if (parent.parent) {
              parent.parent.leftChild = parent.rightRotate();
            } else {
              this.root = parent.rightRotate();
            }
          }
        }
        getHeight(node) {
          if (!node) {
            return 0;
          } else {
            return (
              Math.max(
                node.leftChild === null ? 0 : this.getHeight(node.leftChild),
                node.rightChild === null ? 0 : this.getHeight(node.rightChild)
              ) + 1
            );
          }
        }
      }

      //测试数据
      // console.log(new AVLTree([1, 2, 3]));
      // console.log(new AVLTree([1, 2, 3, 4]));
      // console.log(new AVLTree([4, 3, 2, 1]));
      // console.log(new AVLTree([3, 2, 4, 5, 1, 0]));
      // console.log(new AVLTree([10, 11, 7, 6, 8, 9]));
      // console.log(new AVLTree([2, 1, 5, 3, 6, 4]));
      // console.log(new AVLTree([6, 2, 9, 1, 8, 12, 7, 11, 13, 10]));

      // console.log(new AVLTree([3, 2, 1]));
      // console.log(new AVLTree([1, 2, 3]));
      // console.log(new AVLTree([5, 2, 6, 1, 4, 3]));
      // console.log(new AVLTree([5, 2, 6, 1, 3, 4]));
      // console.log(new AVLTree([4, 2, 3]));
      // console.log(new AVLTree([2, 1, 5, 3, 6, 4]));
      // console.log(new AVLTree([2, 1, 5, 4, 6, 3]));
      // console.log(new AVLTree([2, 3, 4]));

今天试着实现了一个平衡二叉树，平衡二叉树和二叉树其实只差平衡二字，但其实最难的便是这两步。导致不平衡的情况有很多，大家可以参考一下这篇博客。https://www.cnblogs.com/li-ningning/p/12358460.html

博客中博主把导致不平衡的结点分成了八类，但我们是否需要为8种情况设置8种调整方法呢？事实上是不需要的。通过观察我们可以发现所有调整方法都可以总结为两种情况：

1. 当前节点的左子树高度大于右子树，此时需要再判断当前结点左子结点，如果左子结点的右子树高度大于左子树高度，需要对左子结点先进行左旋转，然后再对当前的节点进行右旋转。
2. 当前节点的右子树高度大于左子树，此时需要再判断当前结点右子结点，如果右子结点的左子树高度大于右子树高度，需要对右子结点先进行右旋转，然后再对当前的节点进行左旋转。

写代码的时候有几个点必须要时刻注意，旋转是对于哪个结点来说的，同时如果旋转的结点是根节点还需要特别处理。在代码中使用了双指针，这样子节点和父节点就能实现互访。

同时左右旋转的时候还需要判断某些特殊结点是否存在，即代码中的grandsonNode，这些结点在左右旋转后的变化都是比较大的。

博主在写代码时候还发现一个问题，就是总觉得会有很多特殊的情况没有处理到，然后平衡处理逻辑越写越复杂。最后其实发现也不过就是上面两种方法的子集。这些情况也是上面博主引用那篇博客所述情况的子集。所以总结规律很重要，emmm，如果不擅长，那不如就记住吧，hhh。

有问题的话欢迎在评论区与博主讨论哦。