第七章 二叉搜索树（BinarySearchTree）

于 2022-03-17 16:37:48 发布
阅读量205 收藏 3
点赞数 5
分类专栏： 恋上数据结构与算法 第一季 文章标签： 数据结构 二叉搜索树 二叉树 BST 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sj15814963053/article/details/123554178
版权

第七章 二叉搜索树（BinarySearchTree）

推荐一些神奇的网站：

  • https://520it.com/binarytrees/
  • http://btv.melezinek.cz/binary-search-tree.html
  • https://www.cs.usfca.edu/~galles/visualization/BST.html

思考：在 n 个动态的整数中搜索某个整数？（查看其是否存在）

  • 假设使用动态数组存放元素，从第 0 个位置开始遍历搜索，平均时间复杂度: O ( n )

Untitled

  • 如果维护一个有序的动态数组，使用二分搜索，最坏时间复杂度: O ( logn )
    • 但是添加、删除的平均时间复杂度是: O ( n )

Untitled

  • 针对这个需求，有没有更好的解决方案？
    • 使用二叉搜索树，添加、删除、搜索的最坏时间复杂度均可优化至: O ( logn )

Untitled

  • 二叉搜索树是二叉树的一种，是应用非常广泛的一种二叉树，英文简称为 BST
    • 又被称为：二叉查找树、二叉排序树
  • 任意一个节点的值都大于其左子树所有节点的值
  • 任意一个节点的值都小于其右子树所有节点的值
  • 它的左右子树也是一棵二又搜索树
  • 二叉搜索树可以大大提高搜索数据的效率
  • 二叉搜索树存储的元素必须具备可比较性
    • 比如 int、double 等
  • 如果是自定义类型，需要指定比较方式
  • 不允许为 null

注意：对于我们现在使用的二叉树来说，它的元素没有索引的概念

二叉搜索树的接口设计

int size() // 元素的数量
boolean isEmpty() // 是否为空
void clear() // 清空所有元素
void add (E element) // 添加元素
void remove (E element) // 删除元素
boolean contains (E element) // 是否包含某元素

添加元素: add( )

Untitled

/**
 * 添加元素
 *
 * @param element
 */
public void add(E element) {
    elementNotNullCheck(element);

    //根节点为空，相当于添加第一个节点
    if (root == null) {
        root = new Node<>(element, null);
        size++;
        return;
    }
    //添加的不是第一个节点
    //找到父节点
    Node<E> parent = root;
    Node<E> node = root;
    int cmp = 0;
    while (node != null) {
        cmp = commpare(element, node.element);
        parent = node;
        if (cmp > 0) {
            node = node.right;
        } else if (cmp < 0) {
            node = node.left;
        } else { //相等直接返回
            node.element = element;
            return;
        }
    }
    //找到父节点，看看插入到父节点的哪个位置
    Node<E> newNode = new Node<>(element, parent); //创建新节点
    if (cmp > 0) {
        parent.right = newNode;
    } else {
        parent.left = newNode;
    }
    size++;
}

删除元素: remove( )

删除节点 – 叶子节点

叶子节点直接删除即可

Untitled

删除节点 – 度为1的节点

删除度为1的节点：用子节点替代原节点的位置

  • 如果要删除的节点不是根节点：如果要删除的节点不是根节点

Untitled

  • 如果要删除的节点是根节点

Untitled

删除节点 – 度为2的节点

Untitled

public void remove(E element) {
    remove(node(element));
}

private void remove(Node<E> node) {
    if (node == null) {
        return;
    }
    size--;
    if (node.hasTwoChildren()) { //度为2的节点
        //找到后继节点
        Node<E> s = successor(node);
        //用后继节点的值，覆盖度为2的节点的值
        node.element = s.element;
        //删除后继节点
        node = s;
    }
    //删除node节点（node的度必然是1或者0）
    Node<E> replacement = node.left != null ? node.left : node.right;

    if (replacement != null) { //node是度为1的节点
        //更改parent
        replacement.parent = node.parent;
        //更改parent的left，right的指向
        if (node.parent == null) { //node是度为1的节点并且是根节点
            root = replacement;
        } else {
            if (node == node.parent.left) {
                node.parent.left = replacement;
            } else { //node == node.parent.right
                node.parent.right = replacement;
            }
        }
    } else if (node.parent == null) { //node是叶子节点并且是根节点
        root = null;
    } else { //node是叶子节点，但不是根节点
        if (node == node.parent.left) {
            node.parent.left = null;
        } else { //node == node.parent.right
            node.parent.right = null;
        }
    }
}

private Node<E> node(E element) {
    Node<E> node = root;
    while (node != null) {
        int cmp = commpare(element, node.element);
        if (cmp == 0) {
            return node;
        } else if (cmp > 0) {
            node = node.right;
        } else { //cmp < 0
            node = node.left;
        }
    }
    return null;
}

BST完整代码

package cn.xx.java.tree;

import java.util.Comparator;
import java.util.LinkedList;
import java.util.Queue;

/**
 * 二叉搜索树
 *
 * @author xiexu
 * @create 2021-07-26 12:13 下午
 */
public class BST<E> extends BinaryTree<E> {
    private Comparator<E> comparator;

    public BST() {
        this(null);
    }

    public BST(Comparator<E> comparator) {
        this.comparator = comparator;
    }

    private void elementNotNullCheck(E element) {
        if (element == null) {
            throw new IllegalArgumentException("element must not be null");
        }
    }

    /**
     * 添加元素
     *
     * @param element
     */
    public void add(E element) {
        elementNotNullCheck(element);

        //根节点为空，相当于添加第一个节点
        if (root == null) {
            root = new Node<>(element, null);
            size++;
            return;
        }
        //添加的不是第一个节点
        //找到父节点
        Node<E> parent = root;
        Node<E> node = root;
        int cmp = 0;
        while (node != null) {
            cmp = commpare(element, node.element);
            parent = node;
            if (cmp > 0) {
                node = node.right;
            } else if (cmp < 0) {
                node = node.left;
            } else { //相等直接返回
                node.element = element;
                return;
            }
        }
        //找到父节点，看看插入到父节点的哪个位置
        Node<E> newNode = new Node<>(element, parent); //创建新节点
        if (cmp > 0) {
            parent.right = newNode;
        } else {
            parent.left = newNode;
        }
        size++;
    }

    public void remove(E element) {
        remove(node(element));
    }

    private void remove(Node<E> node) {
        if (node == null) {
            return;
        }
        size--;
        if (node.hasTwoChildren()) { //度为2的节点
            //找到后继节点
            Node<E> s = successor(node);
            //用后继节点的值，覆盖度为2的节点的值
            node.element = s.element;
            //删除后继节点
            node = s;
        }
        //删除node节点（node的度必然是1或者0）
        Node<E> replacement = node.left != null ? node.left : node.right;

        if (replacement != null) { //node是度为1的节点
            //更改parent
            replacement.parent = node.parent;
            //更改parent的left，right的指向
            if (node.parent == null) { //node是度为1的节点并且是根节点
                root = replacement;
            } else {
                if (node == node.parent.left) {
                    node.parent.left = replacement;
                } else { //node == node.parent.right
                    node.parent.right = replacement;
                }
            }
        } else if (node.parent == null) { //node是叶子节点并且是根节点
            root = null;
        } else { //node是叶子节点，但不是根节点
            if (node == node.parent.left) {
                node.parent.left = null;
            } else { //node == node.parent.right
                node.parent.right = null;
            }
        }
    }

    private Node<E> node(E element) {
        Node<E> node = root;
        while (node != null) {
            int cmp = commpare(element, node.element);
            if (cmp == 0) {
                return node;
            } else if (cmp > 0) {
                node = node.right;
            } else { //cmp < 0
                node = node.left;
            }
        }
        return null;
    }

    /**
     * 判断元素是否存在
     *
     * @param element
     * @return
     */
    public boolean contains(E element) {
        return node(element) != null;
    }

    /**
     * @param e1
     * @param e2
     * @return 返回值等于0，代表e1和e2相等；返回值大于0，代表e1大于e2；返回值小于0，代表e1小于e2
     */
    private int commpare(E e1, E e2) {
        if (comparator != null) {
            return comparator.compare(e1, e2);
        } else {
            return ((Comparable<E>) e1).compareTo(e2);
        }
    }

    /**
     * 前序遍历
     */
    public void preorderTraversal() {
        preorderTraversal(root);
    }

    private void preorderTraversal(Node<E> node) {
        if (node == null) {
            return;
        }
        //先访问根节点
        System.out.println(node.element);
        //访问左子节点
        preorderTraversal(node.left);
        //访问右子节点
        preorderTraversal(node.right);
    }

    /**
     * 中序遍历
     */
    public void inorderTraversal() {
        inorderTraversal(root);
    }

    private void inorderTraversal(Node<E> node) {
        if (node == null) {
            return;
        }
        //先中序遍历左子树
        inorderTraversal(node.left);
        //输出根节点
        System.out.println(node.element);
        //再中序遍历右子树
        inorderTraversal(node.right);
    }

    /**
     * 后序遍历
     */
    public void postorderTraversal() {
        postorderTraversal(root);
    }

    private void postorderTraversal(Node<E> node) {
        if (node == null) {
            return;
        }
        //先遍历左子树
        postorderTraversal(node.left);
        //再遍历右子树
        postorderTraversal(node.right);
        //最后访问根节点
        System.out.println(node.element);
    }

    /**
     * 层序遍历
     */
    public void levelOrderTranversal() {
        if (root == null) {
            return;
        }
        Queue<Node<E>> queue = new LinkedList<>();
        //将头节点入队
        queue.offer(root);
        while (!queue.isEmpty()) {
            //将头结点出队
            Node<E> node = queue.poll();
            System.out.println(node.element);
            //如果左子节点不为空，就将左子节点入队
            if (node.left != null) {
                queue.offer(node.left);
            }
            //如果右子节点不为空，就将右子节点入队
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
    }

}
猿小羽
关注
  • 5
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
求二叉树某一节点出现次数
sinat_18558057的博客
04-26 410
求某一节点的值在所有路径当中的最大值。先求出路径，路径即是二叉树中跟节点到叶子节点所有路径。 # Definition for a binary tree node. class TreeNode: def __init__(self, x): self.val = x self.left = None self.right = None class Solution: def getMaxNumInAllPath(self, root,
38. 树 - 寻找二叉查找树中出现次数最多的值
一杯红酒7的博客
03-15 811
1.题目 LeetCode: 501. 二叉搜索树中的众数 【easy】 给定一个有相同值的二叉搜索树（BST），找出 BST 中的所有众数（出现频率最高的元素）。 假定 BST 有如下定义： 结点左子树中所含结点的值小于等于当前结点的值 结点右子树中所含结点的值大于等于当前结点的值 左子树和右子树都是二叉搜索树 例如： 给定 BST [1,null,2,2], 1 2 / 2 返回[2]. 提示： 如果众数超过1个，不需考虑输出顺序 进阶： 你可以不使用额外的空间吗？（假设由递归产生的隐式调用栈的开销不
二叉查找树
ahjxhy2010的博客
05-31 719
先了解一下二叉查找树，它是一种经典的数据结构，其左子树的值总是小于根的值，右子树的值总是大于根的值，如下图①。如果要在这课树中查找值为5的记录，其大致流程：先找到根，其值为6，大于5，所以查找左子树，找到3，而5大于3，接着找3的右子树，总共找了3次。同样的方法，如果查找值为8的记录，也需要查找3次。所以二叉查找树的平均查找次数为(3 + 3 + 3 + 2 + 2 + 1) / 6 = 2.3次
【二叉树】统计成绩出现的次数
Wonder233的学习博客
11-06 1040
编程实现二叉搜索树来记录考试成绩的分布。 解题： 修改 Node 对象， 为其增加一个记录成绩出现频次的成员。function Node(data,left,right){ this.data = data; this.count = 1; this.left = left; this.right = right; }同时还需要一个方法， 当在 BST 中发现某成绩
第4章第1节练习题3 二叉树特殊节点个数统计
法海你懂不?
06-18 3184
分别采用递归与非递归的方式实现对二叉树中度为0的节点，度为1的结点，度为2的结点的个数统计，并且简单分析了递归传值的过程。
二叉搜索树实例练习
09-05
`BinarySearchTree` 类是二叉搜索树本身，包含根节点的引用。`insert` 方法用于向树中插入节点，`printTree` 方法用于先序遍历并返回字符串表示。`main` 函数读取输入的序列，构建二叉搜索树，并通过比较它们的先序...
二叉搜索树的插入删除_二叉搜索树_python_
09-29
在实际使用中，你可以创建一个`BinarySearchTree`实例，然后通过调用`insert`和`delete`方法来操作二叉搜索树。例如： ```python bst = BinarySearchTree() bst.insert(5) bst.insert(3) bst.insert(7) bst.insert...
BinarySearchTree:二叉搜索树代码
06-28
2. `BinarySearchTree`类：作为二叉搜索树的主体，可能包含`insert`、`search`和`delete`等方法，用于进行插入、查找和删除操作。 3. 可能还有辅助方法如`preOrder`、`inOrder`和`postOrder`，分别用于前序、中序和...
二叉搜索树源码分享
09-04
`BinarySearchTree`是二叉搜索树的模板类，包含以下成员： 1. `m_root`：指向根节点的指针，初始为`NULL`。 2. 构造函数：默认构造函数初始化`m_root`为`NULL`；拷贝构造函数用于创建与给定二叉搜索树相同的副本。 ...
tree-java.rar_tree_二叉搜索树
09-20
- `BinarySearchTree.java`: 实现二叉搜索树的主要逻辑，包括插入、查找和删除方法。 ```java public class BinarySearchTree { private Node root; public void insert(int key, int value) { // 插入逻辑，...
7-2 Insertion Sequences of a Binary Search Tree (30分)
weixin_43301333的博客
01-14 496
A binary search tree (BST) can be defined as a binary tree with the following properties: The left subtree of a node contains only nodes with keys less than the node’s key; The right subtree of a node...
【数据结构】——二叉搜索树
sjp11的博客
10-31 6422
目录 前言 二叉搜索树的概念 二叉搜索树的操作 树的节点实现 搜索树的基本结构 插入数据 查找 删除 拷贝构造函数 二叉搜索树的应用 前言 在c++中的容器里map和set的学习需要二叉搜索树的铺垫，也为后边的的红黑树和AVL树做铺垫，也就是说，今天主要讲搜索树的基本结构和应用。 二叉搜索树的概念 所有的根节点大于左子树的节点，小于右子树的节点的二叉树就叫做二叉搜索树。 二叉搜索的性质： 如果左子树不为空，则左子树上的所有节点都小于根节点。 如果右子树不为...
二叉树查找的时间复杂度
热门推荐
风从北边来的博客
10-30 5万+
原文链接：https://blog.csdn.net/li_huai_dong/article/details/79911069 给定值的比较次数等于给定值节点在二叉排序树中的层数。如果二叉排序树是平衡的，则n个节点的二叉排序树的高度为Log2(n+1),其查找效率为O(Log2n)，近似于折半查找。如果二叉排序树完全不平衡，则其深度可达到n，查找效率为O(n)，退化为顺序查找。一般的，二叉排序...
数据结构之二叉搜索树（BinarySearchTree）
如风
06-03 642
一。定义：二叉搜索树（Binary Search Tree），也称有序二叉树（ordered binary tree）,排序二叉树（sorted binary tree），是指一棵空树或者具有下列性质的二叉树： 1. 若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 2. 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 3. 任意节点的左
Binary Search Tree（二叉查找树）
kuma的博客
03-12 1万+
Binary Search Tree 也被成为 ordered binary tree（有序二叉树）或 sorted binary tree（排序二叉树）,有如下性质： 若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点的值； 若任意节点的右子树不空，则右子树上所有节点的值均大于它的根节点的值； 任意节点的左、右子树也分别为二叉查找树； 没有键值相等的节点。 和数组，链表的比较 数...
7-20 Binary Search Tree
qq_1300258993的博客
02-11 274
题目 题意：给定含有n个元素的序列可建出相应的二叉搜索树， 以及给出m个查询序列，问这些待查询序列的二叉搜索树是否和最初的二叉搜索树相同。测试样例以0结束 tip：建树+遍历对比 #include<iostream> using namespace std; struct node { int val; struct node *l,*r; }; struct node* ...
Binary Search Tree
风之云的博客
09-06 509
二叉搜索树严格满足条件：结点的关键字Key比左边subtree的所有node中的Key大，比右边subtree中的所有node里的key小。 BST数据结构包含：right Node 、left Node，Key，Value，size ...
算法：构造全部数量的二叉搜索树
一把健
10-23 340
算法设计第五次作业part1 1.给出一个数组，算出其能构成的不同二叉搜索树结构的数量 package main import ( "fmt" "sort" ) /** 1.给出一个数组，算出其能构成的不同二叉搜索树结构的数量 */ type array []int func (a array) Len() int { return len(a) } func (a array) Less(i, j int) bool { return a[i] < a[j] } func (a
数据结构实验之查找一：二叉排序树
qq_43345339的博客
12-05 205
Problem Description 对应给定的一个序列可以唯一确定一棵二叉排序树。然而，一棵给定的二叉排序树却可以由多种不同的序列得到。例如分别按照序列{3,1,4}和{3,4,1}插入初始为空的二叉排序树，都得到一样的结果。你的任务书对于输入的各种序列，判断它们是否能生成一样的二叉排序树。 Input 输入包含若干组测试数据。每组数据的第1行给出两个正整数N (n < =...
python打印二叉搜索树
最新发布
08-29
该代码示例中，我们创建了一个 `Node` 类表示二叉搜索树的节点，以及一个 `BinarySearchTree` 类表示二叉搜索树。`BinarySearchTree` 类包含了插入节点和打印节点值的方法。我们使用 `insert` 方法将新节点插入二叉...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

猿小羽

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值