二叉树

非线性排序，完全二叉树

二叉树2种存储方法：基于链式，数组

链式存储法：三个节点，一个存储数据，另外2个存储左右节点指针

基于数组的顺序存储法，根节点存储在下标 i = 1 的位置，那左子节点 2 * i = 2 的，右子节点存储在 2 * i + 1 = 3 。以此类推

完全二叉树，仅仅“浪费”了一个下标为 0 的存储位置。如果是非完全二叉树，其实会浪费比较多的数组存储空间。例子。
所以完全二叉树，用数组存储是最节省内存的一种方式

二叉树的遍历

前序遍历、中序遍历和后序遍历

每个节点最多会被访问两次，所以遍历操作的时间复杂度，跟节点的个数 n 成正比，也就是说二叉树遍历的时间复杂度是 O(n)。
思考：
1、给定一组数据，比如 1，3，5，6，9，10。你来算算，可以构建出多少种不同的二叉树？

• 既然是数组了，说明是完全二叉树，应该有n的阶乘个组合。

2、三种二叉树的遍历方式，前、中、后序。实际上，还有另外一种遍历方式，也就是按层遍历，你知道如何实现吗？

• 二叉树按层遍历，可以看作以根结点为起点，图的广度优先遍历的问题。

二叉查找树

特点：支持动态数据集合的快速插入、删除、查找操作。
二叉查找树要求，左子树中的每个节点的值，都要小于这个节点的值，右子树节点的值都大于这个节点的值
二叉查找树的查找操作

public class BinarySearchTree {
  private Node tree;

  public Node find(int data) {
    Node p = tree;
    while (p != null) {
      if (data < p.data) p = p.left;
      else if (data > p.data) p = p.right;
      else return p;
    }
    return null;
  }

  public static class Node {
    private int data;
    private Node left;
    private Node right;

    public Node(int data) {
      this.data = data;
    }
  }
}

2. 二叉查找树的插入操作

public void insert(int data) {
  if (tree == null) {
    tree = new Node(data);
    return;
  }

  Node p = tree;
  while (p != null) {
    if (data > p.data) {
      if (p.right == null) {
        p.right = new Node(data);
        return;
      }
      p = p.right;
    } else { // data < p.data
      if (p.left == null) {
        p.left = new Node(data);
        return;
      }
      p = p.left;
    }
  }
}

3. 二叉查找树的删除操作

• 第一种，如果要删除的节点没有子节点，只需直接将父节点中，指向要删除节点的指针置为 null。比如图中的删除节点 55。
• 第二种，如果要删除的节点只有一个子节点（只有左子节点或者右子节点），只需更新父节点中，指向要删除节点的指针，让它指向要删除节点的子节点就可以了。比如图中的删除节点 13。
• 第三种，如果要删除的节点有两个子节点。需要找到这个节点的右子树中的最小节点，把它替换到要删除的节点上。然后再删除掉这个最小节点，因为最小节点肯定没有左子节点（如果有左子结点，那就不是最小节点了），所以，我们可以应用上面两条规则来删除这个最小节点。比如图中的删除节点 18。
  

public void delete(int data) {
  Node p = tree; // p指向要删除的节点，初始化指向根节点
  Node pp = null; // pp记录的是p的父节点
  while (p != null && p.data != data) {
    pp = p;
    if (data > p.data) p = p.right;
    else p = p.left;
  }
  if (p == null) return; // 没有找到

  // 要删除的节点有两个子节点
  if (p.left != null && p.right != null) { // 查找右子树中最小节点
    Node minP = p.right;
    Node minPP = p; // minPP表示minP的父节点
    while (minP.left != null) {
      minPP = minP;
      minP = minP.left;
    }
    p.data = minP.data; // 将minP的数据替换到p中
    p = minP; // 下面就变成了删除minP了
    pp = minPP;
  }
  // 删除节点是叶子节点或者仅有一个子节点
  Node child; // p的子节点
  if (p.left != null) child = p.left;
  else if (p.right != null) child = p.right;
  else child = null;

  if (pp == null) tree = child; // 删除的是根节点
  else if (pp.left == p) pp.left = child;
  else pp.right = child;
}

• 关于二叉查找树的删除操作，还有个非常简单、取巧的方法，就是单纯将要删除的节点标记为“已删除”，但不真正从树中将这个节点去掉。这样原本删除的节点还需要存储在内存中，比较浪费内存空间，但是删除操作就变得简单了很多。而且，这种处理方法也并没有增加插入、查找操作代码实现的难度。

4. 二叉查找树的其他操作

二叉查找树中还可以支持快速地查找最大节点和最小节点、前驱节点和后继节点。
中序遍历二叉查找树，可以输出有序的数据序列，时间复杂度 O(n)，非常高效。因此，二叉查找树也叫作二叉排序树。支持重复数据的二叉查找树。
支持重复数据的二叉查找树
二叉查找树在实际的软件开发中，存储的是一个包含很多字段的对象。利用对象的某个字段作为键值（key）来构建二叉查找树。把对象中的其他字段叫作卫星数据。
存储的两个相同对象的键值，2种解决方法：

• 第一种，二叉查找树中每一个节点不仅会存储一个数据，因此我们通过链表和支持动态扩容的数组等数据结构，把值相同的数据都存储在同一个节点上。
• 第二种，每个节点仍然只存储一个数据。查找中，如果节点的值，与要插入数据的值相同，将插入的数据放到这个节点的右子树，也就是说，把新插入的数据当作大于这个节点的值来处理。
  
• 当查找遇到值相同节点，不停止查找操作，继续在右子树中查找，直到遇到叶子节点才停止。这样就可以把键值等于要查找值的所有节点都找出来。
• 对于删除操作，也需要先查找到每个要删除的节点，然后再按前面讲的删除操作的方法，依次删除。
  

二叉查找树的时间复杂度分析

时间复杂度其实都跟树的高度成正比，也就是 O(height)

• 树的高度，第 K 层包含的节点个数 2^(K-1)。
• 对于完全二叉树。它包含的节点个数在 1 个到 2^(L-1) 个之间（假设最大层数是 L）。如果我们把每一层的节点个数加起来就是总的节点个数 n。也就是说，如果节点的个数是 n，那么 n 满足这样一个关系：

n >= 1+2+4+8+…+2^(L-2)+1
n <= 1+2+4+8+…+2^(L-2)+2(L-1)

借助等比数列的求和公式，可以计算出，L 的范围是 [log2(n+1), log2n +1]。完全二叉树的层数小于等于 log2n +1，完全二叉树的高度小于等于 log2n。

相比散列表的优点

• 散列表存储是无序的，如果输出有序的数据，需要先进行排序，而二叉树直接中序遍历，O（n)。
• 散列表扩容耗时太多，当遇到散列冲突时，性能不稳定，而平衡二叉树性能非常稳定O(logn)。
• 笼统地来说，散列表时间复杂度是常量级的，但因为哈希冲突的存在，这个常量不一定比 logn 小，所以实际的查找速度可能不一定比 O(logn) 快
• 散列表复杂，散列函数的设计、冲突解决办法、扩容、缩容等。平衡二叉查找树只需要考虑平衡性这一个问题，而且这个问题的解决方案比较成熟、固定。
• 为了避免过多的散列冲突，散列表装载因子不能太大，特别是基于开放寻址法解决冲突的散列表，不然会浪费一定的存储空间。