数据结构与算法笔记-数据结构-二叉查找树

原创
2021/03/11 16:17
阅读数 423

[TOC]

数据结构与算法笔记-数据结构-二叉查找树

二叉查找树(Binary Search Tree)

二叉查找树(也叫二叉搜索树,二叉排序树), 是二叉树中最常用的.

二叉查找树除了支持快速插入,删除,查找, 还可以支持快速查找最大节点和最小节点,以及前驱节点和后继节点.

二叉查找树的中序遍历,可以输出有序的数据序列,时间复杂度是O(n),非常高效.所以二叉查找树也叫作二叉排序树.

二叉查找树的树中任意一个节点,其左子树中的每个节点的值都要小于这个节点的值,而右子树节点的值都大于这个节点的值.

如下图:

img

二叉查找树的查找操作

二叉查找树中查找一个节点

  1. 先取根节点,如果它等于我们要查找的数据就返回.
  2. 如果要查找的数据比根节点的值小,就在左子树中递归查找
  3. 如果要查找的数据比根节点的值大,就在右子树中递归查找

如下图:

img

查找代码:

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;
    }
  }
}

二叉查找树的插入操作

插入过程和查找操作类似

  1. 新增数据一般都在叶子节点上,所以只需要从根节点开始逐个对比要插入的数据和节点的大小关系即可.
  2. 如果要插入的数据比节点的数据大
    1. 如果节点的右子树为空,则将新数据直接插到右子节点的位置
    2. 如果节点的柚子树不为空,则再递归遍历右子树,继续查找插入位置
  3. 如果要插入的数据比节点数值小
    1. 如果节点的左子树为空,则将新数据插入到左子节点的位置
    2. 如果节点的左子树不为空,则再递归遍历左子树,继续查找插入位置

img

插入代码:

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;
    }
  }
}

二叉查找树的删除操作

二叉查找树的删除操作稍微复杂一点,要根据被删除节点的子节点个数的不同而分三种情况:

  1. 第一种情况,要删除的节点没有子节点,只要将父节点中指向要删除节点的指针置为null即可. 如下图删除节点55
  2. 第二种情况,要删除的节点有一个子节点,只要更新父节点中指向要删除节点的指针,指向要删除节点的子节点即可. 如下图删除节点13
  3. 第三种情况,如果要删除的节点有两个子节点
    1. 需要找到这个节点的右子树中的最小节点, 把它替换到要删除的节点上.
    2. 再删除掉这个最小节点, 因为最小节点肯定没有左子节点(如果有左子结点,就不是最小节点).
    3. 根据上面两条规则来删除这个最小节点. 如下图删除节点18

img

删除代码:

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;
}

二叉查找树的删除操作有个简单取巧的方法,只需将要删除的节点标记为已删除,而并不真正从树中将这个节点去掉.

这样原本删除的节点还需要存储在内存中,比较浪费内存空间,不过删除操作简单很多,且并没有增加插入,查找的代码实现难度.

支持重复数据的二叉查找树

在上面的案例中,默认节点中存储的都是数字.但是一般在实际开发中可能存的是一个对象他会有很多字段.

所以一般取出对象中的一个字段作为键值(key)来构建二叉树,把其他字段叫做卫星数据.

这时候可能会遇到键值冲突的情况

  1. 一个节点存多个数据,通过链表或支持动态扩容的数组等结构将键值冲突的数据存储在同一个节点上,不再赘述.
  2. 一个节点存一个数据,将要插入的数据放到该节点的右子树,即将新插入的数据当做大于该节点的值来处理.如下三个图

插入

img

查找

查找数据时遇到相同的节点并不停止,而是继续在右子树中查找直到遇到叶子节点.

这就可以把键值相等与要查找的值的所有节点都找到了.

img

删除

删除也需要查找所有要删除的节点,然后按照深度大的先删除的方法逐个删除.

img

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

二叉查找树的插入,删除,查找的时间复杂度分析

二叉查找树形态各异,如下图,为同一组数据构造了三种二叉查找树,他们的插入,删除,查找的效率各不相同

img

上图的第一种根节点的左右子树极其不平衡,已退化为链表,查找的时间复杂度为O(n)

不论是插入,删除,查找的时间复杂度都和树的高度成正比,即O(height).也就是求一棵包含n个节点的完全二叉树的高度.

而树的高度等于最大层数减一

如上图包含n个节点的完全二叉树,

  • 第一层有 1 个节点
  • 第二层有 2 个节点
  • 第三层有 4 个节点
  • 依次类推,下面一层的节点个数是上一层的2倍
  • 第K层的节点个数就是2^(K-1)

但是,完全二叉树的最后一层的节点个数不遵守这个规律

设最大层为L,那他包含的节点个数在1到2^(L-1)之间

如果每一层的节点个数求和,总节点个数为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

极度不平衡的二叉查找树,查找性能不能满足需求

所以需要构建一个任何时候,都能保持任意节点左右子树都较为平衡的二叉查找树,也就是平衡二叉查找树.

平衡二叉查找树的高度接近logn,所以插入,删除,查找的时间复杂度也比较稳定,为O(logn)

对比散列表

散列表的插入,删除,查找,并且散列表的这些操作时间复杂度是O(1),比二叉查找树更高效,

而二叉查找树在比较平衡的情况下,插入,删除,查找的时间复杂度才是O(logn),相对散列表并没有什么优势.

之所以还用二叉查找树是因为:

  1. 散列表中的数据是无序的,想输出有序的数据要先排序.而二叉查找树的中序遍历,可在O(n)的时间复杂度内输出有序的数据序列
  2. 散列表扩容耗时,且遇到散列冲突时性能不稳定,即使二叉查找树的性能不稳定,单最常用的平衡二叉查找树的性能很稳定,且时间复杂度稳定在O(logn)
  3. 尽管散列表的查找等操作的时间复杂度是常量级的,但哈希冲突时,这个常量不一定比logn小,实际的查找速度并不一定比O(logn)快.加上哈希函数的耗时,未必比平衡二叉查找树的效率高
  4. 散列表的构造比二叉查找树复杂,散列函数的设计,冲突解决,扩容,缩容等.平衡二叉查找树只要考虑平衡性即可,且解决方案成熟,固定。
  5. 为了避免散列冲突过多,散列表装载因子不能太大,尤其是基于开放寻址法解决冲突的散列表,不然会浪费存储空间

所以平衡二叉查找树在某些方面还是优于散列表的,平时结合需求选择用就行.

小结

二叉查找树是一种特殊的二叉树, 支持快速地查找,插入,删除操作.

二叉查找树在没有重复数据的情况下, 每个节点的值都大于左子树节点的值,且小于右子树节点的值.

遇到有重复数据的二叉查找树

  1. 每个节点存储多个相同的数据
  2. 每个节点存储一个数据, 只需要稍加改造原来的插入,删除,查找操作即可.

二叉查找树的查找,插入,删除等的时间复杂度跟树的高度成正比

有两个极端情况的时间复杂度分别为O(n)和O(logn),对应二叉树退化为链表和完全二叉树.

为了避免退化,二叉查找树有更加复杂的树,即平衡二叉查找树,时间复杂度可以做到稳定的O(logn).

展开阅读全文
加载中
点击引领话题📣 发布并加入讨论🔥
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部