数据结构学习-二叉搜索树

树的相关术语

树是一种分层数据的抽象模型，一个树结构包含一系列存在父子关系的节点，每个节点都有一个父节点（除了顶部的第一个节点）以及零个或多个子节点：

根节点：位于树顶部的节点叫作根节点（11）

内部节点：至少有一个子节点的节点称为内部节点（7、5、9、15、13、20）

外部节点：没有子元素的节点称为外部节点或叶节点（3、6、8、10、12、14、18、25）

祖先：一个节点（除了根节点）的祖先包括父节点、祖父节点、曾祖父节点等，例如，节点5的祖先有节点7和节点11

后代：一个节点的后代包括子节点、孙子节点、曾孙节点等。例如，节点5的后代有节点3和节点6。

节点深度：节点的深度取决于它的祖先节点的数量。比如，节点3有3个祖先节
点（5、7和11），它的深度为3。

树的高度：树的高度取决于所有节点深度的最大值，一棵树也可以被分解成层级，根节点在第0层，它的子节点在第1层，以此类推。上图中的树的高度为3（最大高度已在图中表示——第3层）。

二叉树和二叉搜索树

二叉树是树中出现频率很高的一个词，之所以叫二叉树，是因为这种树中的节点最多只有两个子节点，左侧的叫左侧子节点，右侧的叫右侧子节点。上面图中展示的就是二叉树

二叉搜索树（BST）是二叉树的一种，这种树要求左侧子节点的值必须比父节点小，右侧子节点大于或等于父节点。上面图中展示的不仅是二叉树，也是二叉搜索树

实现二叉搜索树

二叉搜索树的结构和双向链表很像，在双向链表中，每个节点包含两个指针，一个指向下一个节点，另一个指向上一个节点。对于树，使用同样的方式（也使用两个指针）。但是，一个指向左侧子节点，另一个指向右侧子节点。在树中，称指针为边。下图展现了二叉搜索树数据结构的组织方式

任何数据结构都有基本的方法，下面是将要在树类中实现的方法

insert(key) ：向树中插入一个新的键。
search(key) ：在树中查找一个键，如果节点存在，则返回 true ；如果不存在，则返回false 。
inOrderTraverse ：通过中序遍历方式遍历所有节点。
preOrderTraverse ：通过先序遍历方式遍历所有节点。
postOrderTraverse ：通过后序遍历方式遍历所有节点。
min ：返回树中最小的值/键。
max ：返回树中最大的值/键。
remove(key) ：从树中移除某个键

function BinarySearchTree() {
  var Node = function(key) {
    this.key = key; // 节点值
    this.left = null; // 左侧子节点
    this.right = null; // 右侧子节点
  };

  var root = null; // 根节点

  this.insert = function(key) {
    var newNode = new Node(key);
    if (root === null) { // 创造根节点
      root = newNode;
    } else {
      insertNode(root, newNode); // 插入新节点
    }
  };

  var insertNode = function(node, newNode) {
    if (newNode.key < node.key) { // 新节点的值比父节点小，排在左侧
      if (node.left === null) { // 父节点没有左侧子节点，就插入新节点
        node.left = newNode;
      } else {
        insertNode(node.left, newNode); // 已经有了，就把新节点作为父节点，递归插入
      }
    } else { // 新节点的值比父节点大或相等，排在右侧
      if (node.right === null) {
        node.right = newNode;
      } else {
        insertNode(node.right, newNode);
      }
    }
  };

  this.getRoot = function() {
    return root;
  };

  this.search = function(key) {
    return searchNode(root, key); // 从根节点开始搜索
  };

  var searchNode = function(node, key) {
    if (node === null) { // 根节点不存在，直接返回
      return false;
    }

    if (key < node.key) { // 左侧子节点递归查找
      return searchNode(node.left, key);
    } else if (key > node.key) { // 右侧子节点递归查找
      return searchNode(node.right, key);
    } else { // 找到了
      return true;
    }
  };
  
  // 中序遍历
  this.inOrderTraverse = function(callback) {
    inOrderTraverseNode(root, callback);
  };

  var inOrderTraverseNode = function(node, callback) {
    if (node !== null) {
      inOrderTraverseNode(node.left, callback);
      callback(node.key);
      inOrderTraverseNode(node.right, callback);
    }
  };
  
  // 先序遍历
  this.preOrderTraverse = function(callback) {
    preOrderTraverseNode(root, callback);
  };
  
  var preOrderTraverseNode = function(node, callback) {
    if (node !== null) {
      callback(node.key);
      preOrderTraverseNode(node.left, callback);
      preOrderTraverseNode(node.right, callback);
    }
  };

  // 后序遍历
  this.postOrderTraverse = function(callback) {
    postOrderTraverseNode(root, callback);
  };

  var postOrderTraverseNode = function(node, callback) {
    if (node !== null) {
      postOrderTraverseNode(node.left, callback);
      postOrderTraverseNode(node.right, callback);
      callback(node.key);
    }
  };

  this.min = function() {
    return minNode(root);
  };

  var minNode = function(node) {
    if (node) {
      while (node && node.left !== null) {
        node = node.left;
      }
      return node.key;
    }
    return null;
  };

  this.max = function() {
    return maxNode(root);
  };

  var maxNode = function(node) {
    if (node) {
      while (node && node.right !== null) {
        node = node.right;
      }
      return node.key;
    }
    return null;
  };

  this.remove = function(element) {
    root = removeNode(root, element);
  };

  var findMinNode = function(node) {
    while (node && node.left !== null) {
      node = node.left;
    }

    return node;
  };

  var removeNode = function(node, element) {

    if (node === null) {
      return null;
    }

    if (element < node.key) {
      node.left = removeNode(node.left, element);
      return node;

    } else if (element > node.key) {
      node.right = removeNode(node.right, element);
      return node;

    } else { // 找到了

      // 第一种情况： 一个叶节点
      if (node.left === null && node.right === null) {
        node = null;
        return node;
      }

      //第二种情况：一个只有一个子节点的节点
      if (node.left === null) {
        node = node.right;
        return node;

      } else if (node.right === null) {
        node = node.left;
        return node;
      }

      //第三种情况：一个有两个子节点的节点
      var aux = findMinNode(node.right);
      node.key = aux.key;
      node.right = removeNode(node.right, aux.key);
      return node;
    }
  };
}

插入操作

创建上图所示的树

var tree = new BinarySearchTree();

tree.insert(11);

tree.insert(7);
tree.insert(15);

tree.insert(5);

tree.insert(3);

tree.insert(9);
tree.insert(8);
tree.insert(10);

tree.insert(13);
tree.insert(12);
tree.insert(14);

tree.insert(20);
tree.insert(18);
tree.insert(25);

此时如果执行tree.insert(6);，插入一个值为 6 的键，执行过程如下

键6会先和键11比较，由于比键11小所以要插入到左侧，但左侧已经有7了，于是和7比较，发现比7小所以要插入到左侧，但左侧有键5，于是和5比较，比5大所以插入到5的右侧

遍历操作

中序遍历：中序遍历是一种以从最小到最大的顺序访问所有节点的遍历方式

tree.inOrderTraverse(function(v){
  console.log(v)
});
// 3 5 6 7 8 9 10 11 12 13 14 15 18 20 25

先序遍历：先序遍历是以优先于后代节点的顺序访问每个节点的。先序遍历的一种应用是打印一个结构化的文档

tree.preOrderTraverse(function(v){
  console.log(v)
});
// 11 7 5 3 6 9 8 10 15 13 12 14 20 18 25

后序遍历：后序遍历则是先访问节点的后代节点，再访问节点本身。后序遍历的一种应用是计算一个目录和它的子目录中所有文件所占空间的大小

tree.postOrderTraverse(function(v){
  console.log(v)
});
// 3 6 5 8 10 9 7 12 14 13 18 25 20 15 11

最小值和最大值

查找最小值和最大值是比较简单的，很显然最后一层的最左侧一定是最小值，最右侧一定是最大值

搜索特定值

查找某个值是否存在于树中，思路比较简单，把这个特定值先和根节点比较，如果比其小就和左侧子节点找，如果比其大就和右侧子节点查找，重复这两步操作，直到直到相等的那个值