二叉排序树（Binary Sort(Search) Tree）

最新推荐文章于 2023-08-28 21:29:26 发布
最新推荐文章于 2023-08-28 21:29:26 发布
阅读量637 收藏 1
点赞数 1
分类专栏： 数据结构与算法 文章标签： 数据结构 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46357847/article/details/121234830
版权

二叉排序树（Binary Sort(Search) Tree）

二叉排序树（Binary Sort Tree）又称二叉查找 / 搜索树（Binary Search Tree），也是树的一种特殊数据结构，这种树结构最大的特点就是查询效率高，很多情况下甚至比链表结构还要高。这种结构不仅查找高效，在动态插入、删除、修改等地方同样高效，因此这种结构在查找、插入算法、删除节点等地方被大量应用。

1、引子

现有一组数列[7, 3, 10, 12, 5, 1, 9]，要求能够高效的完成对数据的查询和添加。

解决方案分析：

1、使用数组实现

  1. 数组未排序时，直接在数组尾部添加，速度非常快，因为无需考虑顺序，缺点就是查找慢。
  2. 数组已排好序，对于排好序的数组我们可以使用二分法查找，查找速度可以非法快。但是也有缺点，为了保证数组有序在添加新数据时，找到插入位置后，后面的数据需要整体移动，导致效率很差。

2、使用链式存储即链表结构

  1. 不管链表是否有序，查找速度都慢，添加数据速度比数组快，因为不需要整体移动！

3、使用树存储方式

  1. 针对经常要查询和修改的数据，使用树结构存储最合适，这也是设计数据库采用树结构的原因。
  2. 树结构能提高数据存储和读取的效率，比如利用二叉排序树(Binary Sort Tree)，即可以保证数据的检索速度，同时也可以保证数据的插入、删除、修改的速度。

关于二叉排序树(Binary Sort Tree)，是如何实现高效查找、插入、删除、修改的？？这也是本文探索与介绍的内容。

2、二叉排序树(BST)

2.1、基本介绍

二叉排序树：BST(Binary Sort(Search) Tree)，简称BST 。对于二叉排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。

特别说明：如果有相同的值，可以将该节点放在左子节点或右子节点。

比如针对前面的数据 (7, 3, 10, 12, 5, 1, 9) ，对应的二叉排序树为：
在这里插入图片描述

2.2、二叉排序树的创建和中序遍历

一个数组创建成对应的二叉排序树，并使用中序遍历二叉排序树，比如：数组为 Array(7, 3, 10, 12, 5, 1, 9) ， 创
建成对应的二叉排序树为：

package com.laizhenghua.tree;

/**
 * @description:
 * @author: laizhenghua
 * @date: 2021/11/9 20:11
 */
public class BinarySortTreeTest {
    public static void main(String[] args) {
        Integer[] array = new Integer[]{7, 3, 10, 12, 5, 1, 9};
        // 构建二叉排序树
        BinarySortTree binarySortTree = new BinarySortTree();
        for (Integer value : array) {
            binarySortTree.add(new Node(value));
        }
        // 中序遍历
        binarySortTree.infixOrder(); // 1 3 5 7 9 10 12
    }
}

// 创建二叉排序树
class BinarySortTree {
    private Node root; // 根节点

    // 添加节点方法
    public void add(Node node) {
        if (this.root == null) {
            this.root = node;
        } else {
            root.add(node);
        }
    }
    // 中序遍历
    public void infixOrder() {
        if (root.left != null) {
            root.infixOrder();
        } else {
            System.out.println("BinarySortTree is null");
        }
    }
}

// 创建Node节点
class Node {
    Integer value;
    Node left;
    Node right;

    public Node(Integer value) {
        this.value = value;
    }
    // 递归添加节点，需要满足二叉树排序树要求
    public void add(Node node) {
        if (node == null) {
            return;
        }
        // 和根节点比较value
        if (node.value < this.value) {
            if (this.left == null) {
                this.left = node;
            } else {
                this.left.add(node); // 递归向左子树添加
            }
        } else {
            if (this.right == null) {
                this.right = node;
            } else {
                this.right.add(node); // 递归向右子树添加
            }
        }
    }
    // 中序遍历
    public void infixOrder() {
        if (this.left != null) {
            this.left.infixOrder();
        }
        System.out.println(this);
        if (this.right != null) {
            this.right.infixOrder();
        }
    }

    @Override
    public String toString() {
        return "Node{" + "value=" + value + "}";
    }
}

2.3、二叉排序树的删除

前面我们已经构建出了一颗二叉排序树，不难发现因为它的特殊排列规律，查找时相当于每次都是使用了二分法查找，所以查找效率比较高。那么二叉排序树的删除又是怎样的呢？

二叉排序树的删除情况比较复杂，有下面三种情况需要考虑：
在这里插入图片描述
1、删除叶子节点 (比如：2, 5, 9, 12)

2、删除只有一颗子树的节点 (比如：1)

3、删除有两颗子树的节点. (比如：7, 3, 10)

对删除结点的各种情况的思路分析：

第一种情况：删除叶子节点 (比如：2, 5, 9, 12) 思路：

  1. 需求先去找到要删除的结点 targetNode
  2. 找到 targetNode 的 父结点 parent
  3. 确定 targetNode 是 parent 的左子结点 还是右子结点
  4. 根据前面的情况来对应删除 ①左子结点 parent.left = null ②右子结点 parent.right = null

第二种情况：删除只有一颗子树的节点（比如1）思路：

  1. 需求先去找到要删除的结点 targetNode
  2. 找到 targetNode 的 父结点 parent
  3. 确定 targetNode 的子结点是左子结点还是右子结点
  4. targetNode 是 parent 的左子结点还是右子结点
  5. 如果 targetNode 有左子结点
    1. 如果 targetNode 是 parent 的左子结点parent.left = targetNode.left;
    2. 如果 targetNode 是 parent 的右子结点parent.right = targetNode.left;
  6. 如果 targetNode 有右子结点
    1. 如果 targetNode 是 parent 的左子结点parent.left = targetNode.right;
    2. 如果 targetNode 是 parent 的右子结点parent.right = targetNode.right;

第三种情况：删除有两颗子树的节点(比如：7, 3, 10)思路：

  1. 需求先去找到要删除的结点 targetNode
  2. 找到 targetNode 的父结点 parent
  3. 从 targetNode 的右子树找到最小的结点
  4. 用一个临时变量，将最小结点的值保存 temp = 11
  5. 删除该最小结点
  6. targetNode.value = temp

完整代码示例：

package com.laizhenghua.tree;

/**
 * @description:
 * @author: laizhenghua
 * @date: 2021/11/9 20:11
 */
public class BinarySortTreeTest {
    public static void main(String[] args) {
        Integer[] array = new Integer[]{7, 3, 10, 12, 5, 1, 9, 2};
        // 构建二叉排序树
        BinarySortTree binarySortTree = new BinarySortTree();
        for (Integer value : array) {
            binarySortTree.add(new Node(value));
        }
        binarySortTree.infixOrder(); // 1 2 3 5 7 9 10 12
        // 删除值为2的节点
        binarySortTree.deleteNode(2);
        System.out.println();
        // 中序遍历
        binarySortTree.infixOrder(); // 1 3 5 7 9 10 12

    }
}

// 创建二叉排序树
class BinarySortTree {
    private Node root; // 根节点

    // 添加节点方法
    public void add(Node node) {
        if (this.root == null) {
            this.root = node;
        } else {
            root.add(node);
        }
    }
    // 中序遍历
    public void infixOrder() {
        if (root.left != null) {
            root.infixOrder();
        } else {
            System.out.println("BinarySortTree is null");
        }
    }
    // 查找节点
    public Node searchNode(Integer value) {
        if (this.root == null) {
            System.out.println("BinarySortTree is null");
            return null;
        } else {
            return this.root.searchNode(value);
        }
    }
    // 查找父节点
    public Node searchParentNode(Integer value) {
        if (this.root == null) {
            System.out.println("BinarySortTree is null");
            return null;
        } else {
            return this.root.searchParentNode(value);
        }
    }
    // 删除节点
    public void deleteNode(Integer value) {
        if (root == null) {
            System.out.println("BinarySortTree is null");
        }
        Node targetNode = searchNode(value);
        if (targetNode == null) {
            System.out.printf("This node[value = %s] cannot be found", value);
        }
        // 如果我们发现当前这可二叉树排序树只有一个节点，并且还是要删除的节点
        if (root.left == null && root.right == null) {
            root = null;
            return;
        }
        Node parentNode = searchParentNode(value);
        // 情况1删除叶子节点
        if (targetNode.left == null && targetNode.right == null) {
            if (parentNode.left != null && parentNode.left.value == value) {
                // 删除父节点的左子节点
                parentNode.left = null;
            } else if (parentNode.right != null && parentNode.right.value == value) {
                // 删除父节点的右子节点
                parentNode.right = null;
            }
        } else if (targetNode.left != null && targetNode.right != null) {
            // 删除有两颗子树的节点
            Integer minValue = getAndDeleteRightTreeMin(targetNode.right);
            targetNode.value = minValue;
        } else {
            // 删除只有一颗子树的节点
            if (targetNode.left != null) {
                // 如果要删除的节点又左子节点
                if (parentNode.left.value == value) {
                    parentNode.left = targetNode.left;
                } else {
                    parentNode.right = targetNode.left;
                }
            } else {
                // 如果要删除的节点有右子节点
                if (parentNode.left.value == value) {
                    parentNode.left = targetNode.right;
                } else {
                    parentNode.right = targetNode.right;
                }
            }
        }
    }
    // 传入node节点（当做二叉排序树的根节点）删除并返回以node为根节点的二叉排序树的最小节点的值
    public Integer getAndDeleteRightTreeMin(Node node) {
        Node minValueNode = node;
        while (minValueNode.left != null) {
            minValueNode = minValueNode.left;
        }
        // 此时minValueNode就是以node为根节点的最小值
        deleteNode(minValueNode.value);
        return minValueNode.value;
    }
}

// 创建Node节点
class Node {
    Integer value;
    Node left;
    Node right;

    public Node(Integer value) {
        this.value = value;
    }
    // 递归添加节点，需要满足二叉树排序树要求
    public void add(Node node) {
        if (node == null) {
            return;
        }
        // 和根节点比较value
        if (node.value < this.value) {
            if (this.left == null) {
                this.left = node;
            } else {
                this.left.add(node); // 递归向左子树添加
            }
        } else {
            if (this.right == null) {
                this.right = node;
            } else {
                this.right.add(node); // 递归向右子树添加
            }
        }
    }

    /**
     * 查找指定value的节点
     * @param value 查找节点的value
     * @return 如果找到则返回，找不到则返回null
     */
    public Node searchNode(Integer value) {
        if (this.value == value) {
            // 找到该节点
            return this;
        } else if (this.value > value) {
            // 向左递归查找
            if (this.left != null) {
                return this.left.searchNode(value);
            }
        } else if (this.value < value) {
            // 向右递归查找
            if (this.right != null) {
                return this.right.searchNode(value);
            }
        }
        return null;
    }

    /**
     * 查找指定值的父节点
     * @param value
     * @return 返回父节点，如果没有则返回null
     */
    public Node searchParentNode(Integer value) {
        if (this.right == null && this.left == null) {
            return null;
        }
        if (this.right != null && this.right.value == value) {
            return this;
        } else if (this.left != null && this.left.value == value) {
            return this;
        } else if (this.value > value) {
            // 向左递归查找
            if (this.left != null) {
                return this.left.searchParentNode(value);
            }
        } else if (this.value < value) {
            if (this.right != null) {
                return this.right.searchParentNode(value);
            }
        }
        return null;
    }
    // 中序遍历
    public void infixOrder() {
        if (this.left != null) {
            this.left.infixOrder();
        }
        System.out.println(this);
        if (this.right != null) {
            this.right.infixOrder();
        }
    }

    @Override
    public String toString() {
        return "Node{" + "value=" + value + "}";
    }
}

3、BST删除注意点

前面我们已经完成了BST的构建、添加、查找、删除，看似已经万事大吉了。但是以上代码删除方法写的有漏洞！比如说二叉排序树长这样：
在这里插入图片描述
删除value=7的节点！此时就会报空指针异常。这是为啥？删除情况属于删除只有一颗子树的节点，不难发现当7为根节点时，已经没有父节点了。当去判断parentNode.left.value必定抛出空指针！所以我们还要对删除方法进行改造！

// 删除节点
public void deleteNode(Integer value) {
    if (root == null) {
        System.out.println("BinarySortTree is null");
    }
    Node targetNode = searchNode(value);
    if (targetNode == null) {
        System.out.printf("This node[value = %s] cannot be found", value);
    }
    // 如果我们发现当前这可二叉树排序树只有一个节点，并且还是要删除的节点
    if (root.left == null && root.right == null) {
        root = null;
        return;
    }
    Node parentNode = searchParentNode(value);
    // 情况1删除叶子节点
    if (targetNode.left == null && targetNode.right == null) {
        if (parentNode.left != null && parentNode.left.value == value) {
            // 删除父节点的左子节点
            parentNode.left = null;
        } else if (parentNode.right != null && parentNode.right.value == value) {
            // 删除父节点的右子节点
            parentNode.right = null;
        }
    } else if (targetNode.left != null && targetNode.right != null) {
        // 删除有两颗子树的节点
        Integer minValue = getAndDeleteRightTreeMin(targetNode.right);
        targetNode.value = minValue;
    } else {
        // 删除只有一颗子树的节点
        if (targetNode.left != null) {
            if (parentNode != null) {
                // 如果要删除的节点又左子节点
                if (parentNode.left.value == value) {
                    parentNode.left = targetNode.left;
                } else {
                    parentNode.right = targetNode.left;
                }
            } else {
                root = targetNode.left;
            }
        } else {
            if (parentNode != null) {
                // 如果要删除的节点有右子节点
                if (parentNode.left.value == value) {
                    parentNode.left = targetNode.right;
                } else {
                    parentNode.right = targetNode.right;
                }
            } else {
                root = targetNode.right;
            }
        }
    }
}

EDN

THANK YOU

END

lambda.
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
二叉树的应用：二叉排序树BST和平衡二叉树AVL的构造 课设作业 完整代码
02-10
树型结构是一类重要的非线性数据结构。其中以树和二叉树最为常用，直观看来，树是以分支关系定义的层次结构。树结构在客观世界中广泛存在，如人类社会的族谱和各种社会组织机构都可用树来形象表示。树在计算机领域中也得到广泛应用，如在编译程序中，可用树来表示源程序的语法结构。又如在数据库系统中，树型结构也是信息的重要组织形式之一。 实验内容包含有二： 二叉排序树(Binary Sort Tree)又称二叉查找(搜索)树(Binary Search Tree)。其定义为：二叉排序树或者是空树，或者是满足如下性质的二叉树：1.若它的左子树非空，则左子树上所有结点的值均小于根结点的值；2.若它的右子树非空，则右子树上所有结点的值均大于根结点的值；3.左、右子树本身又各是一棵二叉排序树。 平衡二叉树（Balanced Binary Tree）又被称为AVL树。具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。构造与调整方法。 实验目的： 二叉排序树的实现 用二叉链表作存储结构，生成一棵二叉排序树T。 对二叉排序树T作中序遍历，输出结果。
数据结构之伸展树详解
12-26
1、 概述 二叉查找树（Binary Search Tree，也叫二叉排序树，即Binary Sort Tree）能够支持多种动态集合操作，它可以用来表示有序集合、建立索引等，因而在实际应用中，二叉排序树是一种非常重要的数据结构。 从算法复杂度角度考虑，我们知道，作用于二叉查找树上的基本操作（如查找，插入等）的时间复杂度与树的高度成正比。对一个含n个节点的完全二叉树，这些操作的最坏情况运行时间为O(log n)。但如果因为频繁的删除和插入操作，导致树退化成一个n个节点的线性链（此时即为一个单链表），则这些操作的最坏情况运行时间为O(n)。为了克服以上缺点，很多二叉查找树的变形出现了，如红黑树、
BinarySortTreeDemo.java
04-24
二叉排序树，完整代码。叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。
数据结构与算法复习题.doc
07-11
数据结构与算法复习题 1. 写出以下各词语对应的中文（英） sequential storge structure 顺序存储结构 Abstract Data Type (ADT) 抽象数据类型 二叉排序树 Binary sort tree queue 队列 storge structure 存储结构 time complexity 时间复杂度 线性表 Linear List 二叉树 Binary Tree Depth_First Search 深度优先搜索 singly linked lists 单链表 2. 单项选择题 1、数据结构是一门研究非数值计算的程序设计问题中数据元素的 、数据信息在计算机中的存储结构以及一组相关的运算等的课程。 A: 操作对象　　　Ｂ: 计算方法　　Ｃ: 逻辑结构　　Ｄ: 数据映象 2、某线性表最常用的运算是插入和删除,插入运算是指在表尾插入一个新元素,删除运算 是指删除表头第一个元素,那么采用 存储方式最节省运算时间.。 A: 仅有头指针的单向循环链表 B: 仅有尾指针的单向循环链表 C: 单向链表 D:双向链表 3、一个栈的入栈序列是a，b，c，d，e，
C语言实现二叉查找树（BST）的基本操作
12-22
我们在上一篇博客中讲解了二叉树，这一次我们来实现二叉树的进阶——二叉查找树（Binary Search Tree），又称二插排序树(Binary Sort Tree)。所以简称为BST。二插查找树的定义如下： 　　1.若左子树不为空，则左子树上所有节点的值均小于它的根节点的值； 　　2.若右子树不为空，则右子树上所有节点的值均大于它的根节点的值； 　　3.左右子树也分别为二叉排序树； 　　二叉排序树的一个重要特点是中序遍历是一个递增序列。示例代码上传至： https://github.com/chenyufeng1991/BinarySearchTree  。 　　（1）节点的构造
拆半插入——BinarySort
MisterMister的博客
12-22 1076
package sort.com; public class BinarySort { /** * 程序入口方法 * 拆半插入（二分法拆入）相当于将原来的数据序列从中间一分为二，利用中间的索引 * 改变左右序列的索引值，一直进行到找到合适的插入位置 */public static void main(String[
二叉排序树(Binary Sort Tree)
weixin_34220179的博客
04-28 361
2019独角兽企业重金招聘Python工程师标准>>> ...
用二叉树排序树的作用c语言,C语言数据结构之二叉树排序
weixin_39866487的博客
05-16 454
一、定义与性质定义二叉排序树(Binary Sort Tree)又称二叉查找(搜索)树(Binary Search Tree)。其定义为：二叉排序树或者是空树，或者是满足如下性质的二叉树：①若它的左子树非空，则左子树上所有结点的值均小于根结点的值；②若它的右子树非空，则右子树上所有结点的值均大于根结点的值；③左、右子树本身又各是一棵二叉排序树。上述性质简称二叉排序树性质(BST性质)，故二叉排序树...
BinarySort(二叉排序算法)
scimence的专栏
12-13 7368
BinarySort(二叉排序算法)
Binary Sort Tree
BrownWong的专栏
05-30 622
二叉排序树简介 二叉排序树（Binary Sort Tree，简称BST），又称二叉查找树，是红黑树、AVL树等的基础。它或是一棵空树，或者是具有下列性质的一棵二叉树： 1、若它的左子树不空，则左子树上所有节点的值均小于它的根节点的值； 2、若它的右子树不空，则右子树上所有节点的值均大于它的根节点的值； 3、它的左右子树也分别为二叉排序树。 4、不存在key值相等
BinarySortTree二叉排序树
刚子的博客
10-14 518
深度优先搜索DFS 广度优先搜索BFS 什么时候要用深度优先遍历DFS呢 某些问题会用到，比如，找最近公共子串 深度优先遍历，代码写起来简洁，因为是使用递归调用，使用的栈， https://blog.csdn.net/rodman177/article/details/89771156 结合代码好好整理一下 ...
二叉排序树的基本原理和实现方法（Java）
qq_41291067的博客
10-27 1386
二叉排序树基本介绍： 二叉排序树（BST）: (Binary Sort(Search) Tree), 对于二叉排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。 特别说明：如果有相同的值，可以将该节点放在左子节点或右子节点 比如针对前面的数据 (7, 3, 10, 12, 5, 1, 9，2) ，对应的二叉排序树为： 算法分析： 二叉排序树创建和遍历： ...
数据结构-二叉排序树（图文详细版）
热门推荐
淡沫初夏zz的博客
01-17 5万+
二叉排序树
二叉树
网瘾少年沐安涂
11-16 1953
参考博客浅谈数据结构-二叉树 二叉树的好处（应用） 用递归方法建立二叉树 数据结构（六）——二叉树 前序、中序、后序、层次遍历及非递归实现 查找、统计个数、比较、求深度的递归实现 Java中二叉树存储结构实现 二叉树的好处（应用） 二叉树可以解决什么问题 二叉树（binary tree）-重要性目录 特点 特殊二叉树及其特点 二叉树性质 二叉树遍历 二叉树建立 二叉树作用 特点二叉树是
二叉排序树
lanse_l的博客
07-02 235
二叉排序树的作用 数组删除和插入的效率很低，链表查找的效率很低，而二叉排序树可以让查找，删除，添加（因为二叉排序树是有序的，所以添加也即是插入）的效率都变的很高。 特点： 基于二叉树，但是有一定的规则，每个节点的左子节点总是比它小，右子节点总是比它大 中序遍历就是一个升序的序列 查找效率近似二分查找 节点类 public class TreeNode { public in...
二分法插入排序(Binary Sort)
wenzi0615
10-20 668
/** * 3.2 二分法插入排序: 按二分法找到合适的位置,可以减少比较的次数. * * EX: int[] nums={8,1,4,2,23,10}; < * * 8,1,4,2,23,10 * | * 1,8,4,2,23
二叉排序树BST（Binary Sort/Search Tree）
wazk2008的博客
04-08 500
二叉排序树 1.基本简介 二叉排序树：BST（Binary Sort/Search Tree），对于二叉排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。 特别说明：如果有相同的值，可以将该节点放在左子节点或右子节点。 比如当前数列{7，3，10，12，5，1，9}，对应的二叉排序树为： 二叉排序树的特点：可以高效的完成对数据的查询和添加。 补充： 数组：查询快，在中间位置进行添加和删除的时候较慢，涉及到数据的整体移动 链表：查询慢，添加和删除较快，不需要进行数据
二叉排序树及其应用（详细解读万字长文）
最新发布
sinat_30545761的博客
08-28 616
二叉排序树（Binary Sort Tree）是计算机科学中的一种数据结构，它是一棵二叉树，其中每个节点都有一个值，并且满足以下性质： 对于每个节点，其左子树中的所有节点的值都小于该节点的值，而其右子树中的所有节点的值都大于该节点的值。 二叉排序树具有很多重要的应用，例如在排序算法、搜索算法、数据挖掘等领域中都有广泛的应用。 二叉排序树的构建和遍历算法都相对简单，并且具有较好的时间复杂度。特别是对于查找操作，二叉排序树的时间复杂度为 O(logn)，其中 n 是树中的节点数。
二叉排序树binary_sort_tree
熟能生巧
12-24 3936
当你希望获取快速的查找时间，快速的插入删除时间，并且遍历是有序的 数据结构， 你需要的就是二叉排序树了。 AVL二叉平衡树，红黑树都是binary sort tree,  这就是STL中的map为什么（中序）遍历，key是有序输出的原因！ 注意： 二叉排序树，平均插入，查找O(logn), 但如果不平衡，极端情况，查找为O(n), 一棵斜树。 所以，利用平衡可以提高效率。 为了简化，
二叉搜索树和二叉排序树
08-12
二叉搜索树（Binary Search Tree，BST）和二叉排序树（Binary Sort Tree）是两个概念相同的数据结构，它们都是一种特殊的二叉树。 二叉搜索树是一种有序的二叉树，它满足以下性质： 1. 左子树上的所有节点的值小于根节点的值。 2. 右子树上的所有节点的值大于根节点的值。 3. 左右子树也分别为二叉搜索树。 二叉排序树是一种特殊的二叉搜索树，它满足以下性质： 1. 左子树上的所有节点的值小于根节点的值。 2. 右子树上的所有节点的值大于根节点的值。 3. 左右子树也分别为二叉排序树。 4. 二叉排序树中不存在重复的节点。 可以说，二叉排序树是对二叉搜索树的一种特殊限定，要求节点值不能重复。 需要注意的是，有些教材或资料中可能将二叉搜索树和二叉排序树视为不同的概念，请根据具体的上下文来理解。在一般情况下，这两个术语可以互换使用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

lambda.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值