二叉排序树相关总结

最新推荐文章于 2024-08-07 10:53:46 发布
最新推荐文章于 2024-08-07 10:53:46 发布
阅读量1.6k 收藏 9
点赞数 4
分类专栏： 树 文章标签： BSTree
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxzxzx0119/article/details/80012374
版权

二叉排序树相关总结

  • 二叉排序树相关概念以及性质
  • 在二叉搜索树中添加元素: add()
  • 查看二叉搜索树中是否存在某个元素 : contains()
  • 找出二叉搜索树中的最小值和最小值 :minimum()、maximum()
  • 删除二叉搜索树中的最小结点和最大结点: removeMin()、removeMax()
  • 删除二叉搜索树中的任意结点: remove()
  • 完整测试源代码

二叉排序树相关概念以及性质

二叉查找树（Binary Search Tree），也称二叉搜索树，是指一棵空树或者具有下列性质的二叉树：

  • 任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
  • 任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值
  • 任意节点的左、右子树也分别为二叉查找树；
  • 没有键值相等的节点(一般)。

相关的性质：

  • 二叉查找树相比于其他数据结构的优势在于查找、插入的时间复杂度较低,为O(log n)。
  • 二叉排序树要求所有的项都能排序，要写出一个一般的类，我们需要实现Comparable接口，使得可以使用泛型来比较任意的数据类型。注意这里不是使用equals方法来实现，根据两项相等当且仅当compareTo方法返回0。
    这里给出BSTreeNode 的定义结构类
public class BSTree<E extends Comparable<E>> {

    private class Node{
        public E e;
        public Node left,right;

        public Node(E e, Node left, Node right) {
            this.e = e;
            this.left = left;
            this.right = right;
        }

        public Node(E e) {
            this.e = e;
            left = null;
            right = null;
        }
    }

    private Node root;
    private int size;

    public BSTree() {
        root = null;
        size = 0;
    }
    public int size(){
        return size;
    }
    public boolean isEmpty(){
        return size == 0;
    }
}

在二叉搜索树中添加元素: add()

  • 如果根节点为null，就新建一个根节点；
  • 如果要插入的元素比当前访问结点node小，而且node.left == null，就可以插入到node的左孩子那里；
  • 如果要插入的元素比当前访问结点node大，而且node.right == null,就可以插入到node的右孩子那里；
  • 如果要插入的元素比当前访问结点node小，而且node.left != null，就递归的去左子树插入这个值；
  • 如果要插入的元素比当前访问结点node大，而且node.right != null，就递归的去右子树插入这个值；

这里写图片描述

    public void add(E e){
        if(root == null){
            root = new Node(e);
            size++;
        }else {
            add(root,e);
        }
    }

    // 向以node为根的二分搜索树中插入元素，递归算法
    private void add(Node node, E e) {
        if(node.e.equals(e))return;

        if(e.compareTo(node.e) < 0 && node.left == null){ //比node.e小
            node.left = new Node(e);
            size++;
            return;
        }else if(e.compareTo(node.e) > 0 && node.right == null){
            node.right = new Node(e);
            size++;
            return;
        }

        if(e.compareTo(node.e) < 0)// e < node.e && node.left != null
            add(node.left,e);
        else     //e > node.e && node.right != null
            add(node.right,e);
    }
  • 更加简单的写法，也就是当我们递归插入的时候，再多递归一层，当递归到空结点的时候，就插入这个结点，注意add(Node node,E e)方法的作用:
  • 向以node为根的二分搜索树中插入元素，返回插入新结点之后二分搜索树的根，我们在递归的时候要得到返回值和上一层的结点进行连接:
    public void add(E e){
        root = add(root,e);
    }
    private Node add(Node node, E e) { /**向以node为根的二分搜索树中插入元素，返回插入新结点之后二分搜索树的根 */
        if(node == null) {//在这里插入
            size++;
            return new Node(e);
        }
        if(e.compareTo(node.e) < 0){
            node.left = add(node.left,e); //node.left是变化的
        }else if(e.compareTo(node.e) > 0){
            node.right = add(node.right,e);
        }
        return node;
    }

查看二叉搜索树中是否存在某个元素 : contains()

在二叉搜索树bsTree中查找x的过程为：

  • 若bsTree是空树，则返回false;
  • 若x等于bsTree的根节点的数据域之值，则查找成功;
  • 若x小于bsTree的根节点的数据域之值，则搜索左子树;
  • 否则搜索右子树;

这里写图片描述
代码如下：

	 //query
    public boolean contains(E e){
        return contains(root,e);
    }
    private boolean contains(Node node, E e) {
        if (node == null) return false;
        if (e.compareTo(node.e) == 0) {
            return true;
        } else if (e.compareTo(node.e) < 0) {
            return contains(node.left, e);
        } else {
            return contains(node.right, e);
        }
    }

找出二叉搜索树中的最小值和最小值 : minimum()、maximum()

实现很简单就是一直往左边，或者一直忘右边走，递归和非递归实现都很简单；

	//min
    public E minimum(){
        if(size == 0)
            throw new IllegalArgumentException("BST is empty!");
        return minimum(root).e;
    }
    private Node minimum(Node node) {
        if(node.left == null)return node;
        return minimum(node.left);
    }

	//max
    public E maximum(){
        if(size == 0)
            throw new IllegalArgumentException("BST is empty!");
        return maximum(root).e;
    }
    private Node maximum(Node node){
        if(node.right == null)return node;
        return maximum(node.right);
    }

删除二叉搜索树中的最小结点和最大结点: removeMin()、removeMax()

先看删除最小结点：

  • 如果最小结点是叶子结点，很简单直接删除即可；
  • 如果不是叶子结点，就删除这个结点，并且将它的父亲和它的右孩子连接起来即可，看下图:
    在这里插入图片描述
    删除之后就是下面的样子:
    在这里插入图片描述

注意这里的连接就是按照返回值的形式，父亲的左孩子连接上删除之后的树的根即可。

    // 删除二叉搜索树中最小值所在的结点,返回最小值
    public E removeMin(){
        E ret = minimum();
        root = removeMin(root); //remove the min node and then connect the tree
        return ret;
    }
    private Node removeMin(Node node){/**删除掉以node为根的二叉搜索树中的最小结点,返回删除节点后新的结点的二分搜索树的根  */
        if(node.left == null){ //node is min
            Node rightNode = node.right;
            node.right = null; //remove from the tree
            size--;
            return rightNode; /** 返回删除节点后新的结点的二分搜索树的根  然后上一层就可以连接上*/
        }
        node.left = removeMin(node.left); /** 去删除左子树, 然后我要连上你删除之后返回的新的根*/
        return node; /** 返回删除之后的根 ，上一层还要连接*/
    }

删除最大结点同理:

    public E removeMax(){
        E ret = maximum();
        root = removeMax(root);
        return ret;
    }
    private Node removeMax(Node node){
        if(node.right == null){
            Node leftNode = node.left;
            node.left = null;
            size--;
            return leftNode;
        }
        node.right = removeMax(node.right);
        return node;
    }

删除二叉搜索树中的任意结点: remove()

删除结点比较复杂，分为四种情况，前三种情况很简单，最后一种情况稍微复杂一点:

  • 如果是叶子结点，直接删除；
  • 如果node只有右孩子，和之前removeMin()的处理一样，删除之后，返回右子树的根节点；
  • 如果node只有左孩子，和之前removeMax()的处理一样，删除之后，返回左子树的根节点；
  • 如果node既有左孩子又有右孩子，就找到node的右子树最小的结点 (后继结点)successor结点，然后用这个结点来顶替node，具体过程和实现看图片和代码；

这里写图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

	//remove any node
    public void remove(E e){
        root = remove(root,e);
    }
    private Node remove(Node node,E e){/**删除以node为根的二分搜索树中值为e的节点，返回删除节点后新的二叉搜索树的根*/
        if(node == null) return null; // 树中没有这个结点
        if(e.compareTo(node.e) < 0){
            node.left = remove(node.left,e);
            return node;
        }else if(e.compareTo(node.e) > 0){
            node.right = remove(node.right,e);
            return node;
        }else { //e == node.e   ---> should remove

            if(node.left == null){ // only have rightchild or leaf
                Node rightNode = node.right;
                node.right = null;
                size--;
                return rightNode;
            }
            if(node.right == null){
                Node leftNode = node.left;
                node.left = null;
                size--;
                return leftNode;
            }

            /** 左右子树都不为空 : 找到比待删除结点大的最小结点(后继)， 用这个结点顶替待删除结点的位置*/
            Node successor = minimum(node.right); //找到右子树的最小结点

            successor.right = removeMin(node.right); //将successor.right设置成 原先结点node的右子树移除 successor之后的树
            successor.left = node.left; //

            //remove node
            node.left = node.right = null;
            //size--;  //这个不需要，因为在removeMin(node.right)中已经减了一次
            return successor; //返回新树的根
        }
    }

还有一个要注意的就是删除之后不需要size--，因为我们在node的右子树中删除那个最小的(successor)结点并顶替node的时候，在removeMin()中已经size- -了，所以不要再减去。

完整测试代码

package DataStructure.Tree.BST;

public class BSTree<E extends Comparable<E>> {

    private class Node{
        public E e;
        public Node left,right;

        public Node(E e, Node left, Node right) {
            this.e = e;
            this.left = left;
            this.right = right;
        }

        public Node(E e) {
            this.e = e;
            left = null;
            right = null;
        }
    }

    private Node root;
    private int size;

    public BSTree() {
        root = null;
        size = 0;
    }
    public int size(){
        return size;
    }
    public boolean isEmpty(){
        return size == 0;
    }


/**
    //easy  understand version
    public void add(E e){
        if(root == null){
            root = new Node(e);
            size++;
        }else {
            add(root,e);
        }
    }

    // 向以node为根的二分搜索树中插入元素，递归算法
    private void add(Node node, E e) {
        if(node.e.equals(e))return;

        if(e.compareTo(node.e) < 0 && node.left == null){ //比node.e小
            node.left = new Node(e);
            size++;
            return;
        }else if(e.compareTo(node.e) > 0 && node.right == null){
            node.right = new Node(e);
            size++;
            return;
        }

        if(e.compareTo(node.e) < 0)// e < node.e && node.left != null
            add(node.left,e);
        else     //e > node.e && node.right != null
            add(node.right,e);
    }
*/
    //add
    public void add(E e){
        root = add(root,e);
    }
    private Node add(Node node, E e) { /**向以node为根的二分搜索树中插入元素，返回插入新结点之后二分搜索树的根 */
        if(node == null) {//在这里插入
            size++;
            return new Node(e);
        }
        if(e.compareTo(node.e) < 0){
            node.left = add(node.left,e); //node.left是变化的
        }else if(e.compareTo(node.e) > 0){
            node.right = add(node.right,e);
        }
        return node;
    }


    //query
    public boolean contains(E e){
        return contains(root,e);
    }
    private boolean contains(Node node, E e) {
        if (node == null) return false;
        if (e.compareTo(node.e) == 0) {
            return true;
        } else if (e.compareTo(node.e) < 0) {
            return contains(node.left, e);
        } else {
            return contains(node.right, e);
        }
    }

    public E minimum(){
        if(size == 0)
            throw new IllegalArgumentException("BST is empty!");
        return minimum(root).e;
    }
    private Node minimum(Node node) {
        if(node.left == null)return node;
        return minimum(node.left);
    }

    public E maximum(){
        if(size == 0)
            throw new IllegalArgumentException("BST is empty!");
        return maximum(root).e;
    }
    private Node maximum(Node node){
        if(node.right == null)return node;
        return maximum(node.right);
    }


    // 删除二叉搜索树中最小值所在的结点,返回最小值
    public E removeMin(){
        E ret = minimum();
        root = removeMin(root); //remove the min node and then connect the tree
        return ret;
    }
    private Node removeMin(Node node){/**删除掉以node为根的二叉搜索树中的最小结点,返回删除节点后新的结点的二分搜索树的根  */
        if(node.left == null){ //node is min
            Node rightNode = node.right;
            node.right = null; //remove from the tree
            size--;
            return rightNode; /** 返回删除节点后新的结点的二分搜索树的根  然后上一层就可以连接上*/
        }
        node.left = removeMin(node.left); /** 去删除左子树, 然后我要连上你删除之后返回的新的根*/
        return node; /** 返回删除之后的根 ，上一层还要连接*/
    }

    public E removeMax(){
        E ret = maximum();
        root = removeMax(root);
        return ret;
    }
    private Node removeMax(Node node){
        if(node.right == null){
            Node leftNode = node.left;
            node.left = null;
            size--;
            return leftNode;
        }
        node.right = removeMax(node.right);
        return node;
    }


    //remove any node
    public void remove(E e){
        root = remove(root,e);
    }
    private Node remove(Node node,E e){/**删除以node为根的二分搜索树中值为e的节点，返回删除节点后新的二叉搜索树的根*/
        if(node == null) return null; // 树中没有这个结点
        if(e.compareTo(node.e) < 0){
            node.left = remove(node.left,e);
            return node;
        }else if(e.compareTo(node.e) > 0){
            node.right = remove(node.right,e);
            return node;
        }else { //e == node.e   ---> should remove

            if(node.left == null){ // only have rightchild or leaf
                Node rightNode = node.right;
                node.right = null;
                size--;
                return rightNode;
            }
            if(node.right == null){
                Node leftNode = node.left;
                node.left = null;
                size--;
                return leftNode;
            }

            /** 左右子树都不为空 : 找到比待删除结点大的最小结点(后继)， 用这个结点顶替待删除结点的位置*/
            Node successor = minimum(node.right); //找到右子树的最小结点

            successor.right = removeMin(node.right); //将successor.right设置成 原先结点node的右子树移除 successor之后的树
            successor.left = node.left; //

            //remove node
            node.left = node.right = null;
            //size--;  //这个不需要，因为在removeMin(node.right)中已经减了一次
            return successor; //返回新树的根
        }
    }


    public void printTree(){
        printTree(root,0,"H",8);
    }
    public void printTree(Node head,int height,String to,int len){
        if(head == null)return;
        printTree(head.right,height + 1,"v",len);

        String val = to + head.e + to;  //两边指示的字符
        int lenV = val.length();
        int lenL = (len - lenV)/2;  //左边的空格(分一半)
        int lenR = len - lenV - lenL; // 右边的空格
        System.out.println( getSpace(len * height) + getSpace(lenL) + val + getSpace(lenR));

        printTree(head.left,height + 1,"^",len);
    }
    public static String getSpace(int len){
        StringBuffer str = new StringBuffer();
        for(int i = 0; i < len; i++) str.append(" ");
        return str.toString();
    }



    public static void main(String[] args) {
        Integer[] arr = {21,14,28,11,18,25,32,5,12,15,19,23,27,30,37};
        //        Arrays.sort(arr); //退化成链表
        BSTree<Integer>bsTree = new BSTree<>();
        for(int i = 0; i < arr.length; i++) bsTree.add(arr[i]);
        bsTree.printTree();
        System.out.println("--------------华丽分割线-------------");

        System.out.println(bsTree.contains(27));
        System.out.println(bsTree.contains(99));
        System.out.println(bsTree.minimum());
        System.out.println(bsTree.maximum());
        System.out.println("--------------华丽分割线-------------");

//        bsTree.removeMin();
//        bsTree.removeMax();
//        bsTree.printTree();
        bsTree.remove(25);
        bsTree.printTree();
    }
}

效果:
这里写图片描述

  • 打印二叉树见这个博客。
  • 注意到我在main中测试时注释了Arrays.sort(arr);这一行，因为如果是这样插入的话就会退化成链表，这个进阶的问题就是平衡二叉树。
zxzxin
关注
  • 4
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
实验 二叉排序树
DT2131
06-20 878
掌握二叉排序树的查找、插入、删除、建立算法的思想及程序实现。 代码： #include using namespace std; typedef struct Node{ Node *ls,*rs; int val; }Node; typedef struct BSTree{ Node *root; BSTree(){root=NULL;} public:
二叉排序树总结
qq_47664976的博客
03-09 2754
二叉排序树的定义 二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： 左子树上所有结点的值均小于根结点的值； 右子树的所有结点的值均大于根结点的值； 他的左右子树也分别都是二叉排序树； 二叉排序树的查找过程 首先和根结点的值进行比较，若相等，则返回成功，返回结点位置 若小于根节点的值，则继续在其左子树上查找； 若大于根结点的值，则继续在其右子树上查找； 直至查找成功或者查找失败。 查找成功：走了一条从二叉排序树的根到对应结点的路径。 查找失败：从二叉排序树的根到路径末端。 二叉排序树的插入 查
实用数据结构之二叉排序树小结
weixin_30505485的博客
09-10 123
实用数据结构之二叉排序树小结： 定义： 满足以下条件的二叉树： 对于树上任意一个结点，其上的数值必大于等于其左子树上任意结点的数值 必小于等于其右子树上任意结点的数值 故二叉排序树的插入： 1.若当前树为空，则x为其根结点 2.若当前结点大于x，则x插入其左子树, 若当前结点小于x,则x插入其右子树 若当前结点等于x,则根据具体情况选择插入左子树或者右子树或者直接忽略 ...
[C++进阶&数据结构]二叉搜索树
最新发布
2301_80017277的博客
08-07 1333
对于二叉树的结点，我们类似于list的结点定义一样，使用一个struct类。
二叉排序树小结
ZHOUJIAN_TANK的博客
08-01 342
二叉排序树特点 二叉排序树解题思路 二叉排序树题型
二叉排序树的有关知识
qq_63037023的博客
02-13 532
什么是二叉排序树? 二叉排序树就是给一个根节点,在根节点右边的节点的值比它大,在根节点左边的值比他小。 一棵空树，或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2）若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值； （3）左、右子树也分别为二叉排序树； 代码实现: public static void main(String[] args) { int[] arr={7,3,10,12,5,1,9,2};
二叉排序树
02-07
下面将详细讲解二叉排序树的构造、遍历方法以及相关操作。 首先，我们来看如何构建一个二叉排序树。在C++中，通常我们会定义一个`Node`结构体或类来表示二叉树的节点，包括节点的值、左孩子和右孩子指针。例如： `...
数据结构综合课设二叉排序树.docx
03-26
总结，二叉排序树是一种重要的数据结构，适用于需要快速查找、插入和删除操作的场景。在实际应用中，保持树的平衡至关重要，以确保高效的性能。在编程实现时，需注意节点的插入、删除以及平衡调整策略。
写一算法,判断一棵二叉树是否是一棵二叉排序树。
07-15
根据给定的文件信息，我们将深入探讨如何通过不同的方法来判断一棵二叉树是否为二叉排序树（Binary Search Tree, BST）。二叉排序树是一种特殊的二叉树，它满足以下条件： 1. 若左子树不为空，则左子树上所有节点的...
北邮二叉树实验报告
04-12
北邮二叉树实验报告，含有源代码，比较详细，还有完整的分析过程以及实验总结等等。
二叉排序树相关知识详解
hi_siri的博客
11-21 560
二叉排序树（BST树） 二叉树。 二叉排序树或是一棵空树，或具有以下特性： 1.若左子树非空，其左子树上所有结点的值均小于根节点的值； 2.若右子树非空，其右子树上所有结点的值均大于根节点的值； 3.左右子树也满足二叉排序树的特性； 4.左子树结点值<根节点值<右子树结点值，所以如果对二叉排序树进行中序0遍历可以得到一个递增的有序序列。 ...
二叉树排序总结
mzc的博客
06-12 291
//快速排序,去基准值,左同时向中间靠拢 //左边遇到大的停止,右边遇到小的停止 //交换大小数的位置,两个指针到同一位置时,与基准值交换 //最终结果是小…基准值…大 #include <stdio.h> #include <stdlib.h> //基准值的取法随意时,容易造成时间复杂度很高的情况 //三数取中法:取三个数,左端右端,中间,选择大小处于中间的数作为基准值 ...
关于二叉排序树的总结
徐小航航 的博客
08-09 1011
 由于近几天学习了二叉排序树，对于一些题目有一些个人的见解，随手写下这篇博文，以供大家参考 二叉排序树的概念一定要弄懂：    一、二叉排序树的做法是首先建立一颗树，然后先序（中序，后序）遍历输出，如果相同则是同一棵树 二、建树的时候应该分两种情况：第一是一开始是一颗空树直接插入，第二是如果小于当前节点就把它插到左子树上       否则就放到右子树上；  关键代码： stru...
[总结] 二叉排序树
Ｄ調...
05-29 958
 1 概述二叉排序树(Binary Sorting Tree)或者是一棵空树，或者具有如下性质：（1）若它有左子树，则左子树上所有的结点的数据均小于根结点的数据；（2）若它有右子树，则右子树上所有的结点的数据均大于根结点的数据；（3）左、右子树本身又是一棵二叉排序树。如下图所示：易知：非空二叉排序树中结点数据是按照左子树、树、右子树这种顺序排列的。所以对其中序遍历得到的结点序列
二叉排序树相关
futangxiang4793的博客
03-16 152
题目描述判断两序列是否为同一二叉搜索树序列输入描述:开始一个数n，(1&lt;=n&lt;=20) 表示有n个需要判断，n= 0 的时候输入结束。 接下去一行是一个序列，序列长度小于10，包含(0~9)的数字，没有重复数字，根据这个序列可以构造出一颗二叉搜索树。 接下去的n行有n个序列，每个序列格式跟第一个序列一样，请判断这两个序列是否能组成同一颗二叉搜索树。输出描述:如果序列相同则输出YES，否...
二叉排序树详解
热门推荐
云杉木屋
04-01 2万+
摘要：本篇笔记专门介绍二叉排序树，重点讲解了二叉排序树的特性，以及二叉排序树各方面的基本实现。
二叉树总结
u013646278的博客
03-10 2637
1、定义 树 树是n（n>=0）个节点的有限集，n=0是称为空树。 在任意一个非空树中：有且只有一个根节点root；当n>1时，其余节点可分为m（m>0）个互不相交的集合，每个集合又是一棵树，称为子树。 度 节点拥有的子树的数目称为度。 节点关系 孩子节点：节点子树的根节点，B是A的孩子节点 双亲结点：孩子节点的上级节点，A是B的双亲结点 兄弟节点：同一个双亲结点直接称为兄弟节点，B和C互为兄弟节点（他们共一个A作为双亲节点） 节点层次 从根节点开始定义，根节点为第一层，孩子节点为第二层
二叉排序树实现与插入操作解析
总结来说，这个资源提供了基本的二叉排序树实现，包括插入和搜索功能，但没有涵盖删除操作。对于学习数据结构和算法的学生来说，这是一个很好的起点，可以帮助他们理解二叉排序树的工作原理，并能够编写实际的C语言...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值