二叉树

树

• 搜索二叉树

  class Node {
    constructor(element, parent) {
      this.element = element;
      this.parent = parent;
      this.left = null;
      this.right = null;
    }
  }
  class Tree {
    constructor() {
      this.root = null;
    }
  
    add(element) {
      if (this.root === null) {
        return this.root = new Node(element);
      }
      // 可以用递归，用循环就可以了
      let currentNode = this.root; // 更新当前节点
      let parent;
      let compare;
      while (currentNode) {
        compare = currentNode.element < element;
        parent = currentNode; // 遍历前先记录节点
        if (compare) { //  作比较 更新节点
          // 接着以右边的为根节点
          currentNode = currentNode.right
        } else {
          currentNode = currentNode.left // 插入8的时候 右边没有人了
        }
      }
      let node = new Node(element, parent)
      if (compare) {
        parent.right = node
      } else {
        parent.left = node
      }
    }
  
    preorderTraversal() {
      function traversal(node) {
        if (node) {
          console.log(node.element);
          traversal(node.left);
          traversal(node.right);
        }
      }
      traversal(this.root)
    }
    inOrderTravarsal() {
      function traversal(node) {
        if (node.left) {
          traversal(node.left);
        }
        if (node) {
          console.log(node.element)
        }
        if (node.right) {
          traversal(node.right);
        }
      }
      traversal(this.root)
    }
    postorderTravelsal() {
      function traversal(node) {
        if (node.left) {
          traversal(node.left);
        }
        if (node.right) {
          traversal(node.right);
        }
        if (node) {
          console.log(node.element)
        }
      }
      traversal(this.root)
    }
    leveltravelsal() {
      let arr = [this.root];
      let element = [this.root.element];
      let index = 0;
      while (index < arr.length) {
        arrAdd(arr[index].left);
        arrAdd(arr[index].right);
        index++;
      }
      console.log(element);
      function arrAdd(node) {
        if (node) {
          arr.push(node);
          element.push(node.element);
        }
      }
    }
    reveser() {
      let arr = [this.root];
      let index = 0;
      while (index < arr.length) {
        arrAdd(arr[index].left);
        arrAdd(arr[index].right);
        let currentNode = arr[index].right;
        arr[index].right = arr[index].left;
        arr[index].left = currentNode;
        index++;
      }
      function arrAdd(node) {
        if (node) {
          arr.push(node);
        }
      }
    }
  }
  
  let tree = new Tree();
  [10, 8, 19, 6, 15, 22, 20].forEach(item => {
    tree.add(item);
  });
  // console.dir(tree, { depth: 1000 });
  // tree.preorderTraversal();
  // tree.inOrderTravarsal();
  // tree.postorderTravelsal();
  // tree.leveltravelsal();
  tree.reveser()
  console.dir(tree, { depth: 1000 });
  
  

• 遍历（递归，非递归 => 栈）

  • 先序 跟左右

  • 中序 左根右

  • 后序 左右根

  • 层序 (广度遍历)