二叉树

1. 树：由一组以边连接的节点组成

二叉树：特殊的树，子节点数不超过两个。一个父节点的两个子节点分别称为做节点和右节点。相对较小的值保存在左节点中，相对较小的值保存在右节点中。

2. 实现二叉树

1）node类：保存数据、和其他节点的链接

2）BST类：

 function Node(data, left, right) {
       this.data = data;
       this.left = left;
       this.right = right;
       this.show = show;
}
function show() {
       return this.data;
}

 function BST() {
     this.root = null;
     this.insert = insert;
     this.inOrder = inOrder;
}
 function insert(data) {
     var n = new Node(data, null, null);
     if (this.root == null) {
           this.root = n;
     }
      else {
              var current = this.root;
              var parent;
              while (true) {
                  parent = current;
                   if (data < current.data) {
                         current = current.left;
                         if (current == null) {
                               parent.left = n;
                               break; 
                              }
                           }
                         else {
                             current = current.right;
                                 if (current == null) {
                                    parent.right = n;
                                    break; 
                                   }
                             }
                       }
                 }
           }

3. 遍历二叉查找树

1）中序：升序访问BST上所有节点

 function inOrder(node) {
     if (!(node == null)) {
         inOrder(node.left);
         putstr(node.show() + " ");
         inOrder(node.right);
     }
}

2）先序：先访问根节点，然后以相同方式访问左子树、右子树

function preOrder(node) {
    if (!(node == null)) {
         putstr(node.show() + " ");
         preOrder(node.left);
         preOrder(node.right);
} }

3）后序：先遍历叶子节点，左子树到右子树到根

function postOrder(node) {
      if (!(node == null)) {
          postOrder(node.left);
          postOrder(node.right);
          putstr(node.show() + " ");
       }
}

4. 在二叉树查值

1）最大最小值

较小值总在左子节点上

function getMin() {
    var current = this.root;
    while (!(current.left == null)) {
        current = current.left;
    }
    return current.data;
}

function getMax() {
    var current = this.root;
    while (!(current.right == null)) {
        current = current.right;
    }
    return current.data;
}

2）查找给定值

function find(data) {
    var current = this.root;
    while (current != null) {
        if (current.data == data) {
            return current;
        }
                          else if (data < current.data) {
                              current = current.left;
}
else {
                              current = current.right;
                          }
}
                      return null;
                  }

3）从二叉树删除节点

function remove(data) {
    root = removeNode(this.root, data);
}
function removeNode(node, data) {
    if (node == null) {
        return null;
}
    if (data == node.data) {
        // 没有子节点的节点
    if (node.left == null && node.right == null) {
        return null;
}
    // 没有左子节点的节点
    if (node.left == null) {
        return node.right;
    }
    // 没有右子节点的节点
    if (node.right == null) {
        return node.left;
     }
    // 有两个子节点的节点
    var tempNode = getSmallest(node.right);
    node.data = tempNode.data;
    node.right = removeNode(node.right, tempNode.data); return node;
    }
    else if (data < node.data) {
        node.left = removeNode(node.left, data);
        return node;
     }
    else {
        node.right = removeNode(node.right, data);
        return node;
} }