【数据结构&算法】二叉排序树

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

树系列：

文章目录

一、前言

最近在深入了解MySQL索引，发现MySQL索引主要用B+树实现的。本人对树这种数据结构，一直以来掌握都是模棱两可的状态，现在希望通过写一个关于树的专题系列，来掌握树这种数据结构，为深入了解MySQL索引打下基础，做到心中有"树"。

二、定义

二叉排序树(Binary Sort(Search) Tree) 也叫二叉搜索树

  • 若左子树不空，则左子树上所有结点的值均小于它的根结点的值
  • 若右子树不空，则右子树上所有结点的值均大于它的根结点的值
  • 左、右子树也分别为二叉排序树
  • 二叉排序树也可以是一个空树

在这里插入图片描述

三、类结构

public class BinarySortTree<K extends Comparable<? super K>, V> {
    private Node root;

    private class Node {
        private K key;
        private V value;
        private Node left;
        private Node right;

        public Node(K key, V value) {
            this.key = key;
            this.value = value;
        }

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

四、插入

思路:

  • 若二叉树为空，则首先单独生成根结点。
  • 首先执行查找算法，找出被插结点的父亲结点。
  • 判断被插结点是其父亲结点的左结点或者右结点，将被插结点作为叶子结点插入。

注意：新插入的结点总是叶子结点。

   public void add(K key, V value) {
        Node node = new Node(key, value);
        if (this.root == null) {
            this.root = node;
            return;
        }
        this.add(this.root, node);
    }

    private void add(Node root, Node node) {
        if (node.key.compareTo(root.key) < 0) {
            if (root.left == null) {
                root.left = node;
            } else {
                add(root.left, node);
            }
        } else {
            if (root.right == null) {
                root.right = node;
            } else {
                add(root.right, node);
            }
        }
    }

五、查找

思路：

  • 如果二叉排序树为空，返回null
  • 如果根结点的键等于要查找的键，返回根结点的值
  • 否则，递归的在子树中查找，如果要查找的键小于根结点的键在左子树中查找，反之在右子树中查找

效率:
查找效率和二叉树的高度有关，最好的情况是，即由n个结点构成的高度为
⌊log2n⌋+1的二叉排序树，效率为O(log2n)。

在这里插入图片描述
最坏的情况是单向生长的二叉排序树，即n个结点高度为n的二叉排序树，其效率为O(n)
在这里插入图片描述

 public V get(K key) {
        if (this.root == null) {
            return null;
        }
        Node node = getNode(this.root, key);
        if (node == null) {
            return null;
        }
        return node.value;
    }
    private Node getNode(Node root, K key) {
        if (root == null) {
            return null;
        }
        if (root.key.compareTo(key) == 0) {
            return root;
        }
        if (root.key.compareTo(key) > 0) {
            return getNode(root.left, key);
        } else {
            return getNode(root.right, key);
        }
    }

六、删除

思路：
二叉排序树的删除相对麻烦点，分为三种情况

  • 删除的是叶子结点
  • 删除的结点只有左子树/右子树
  • 删除结点左右子树都存在
public boolean delete(K key) {
        if (this.root == null) {
            return false;
        }
        Node targetNode = getNode(this.root, key);
        if (targetNode == null) {
            return false;
        }
        Node parentNode = getParentNode(this.root, key);

        //删除的是叶子结点
        if (targetNode.left == null && targetNode.right == null) {
            //只有根结点
            if (parentNode == null) {
                this.root = null;
                return true;
            }
            if (parentNode.left != null && parentNode.left.key.compareTo(targetNode.key) == 0) {
                parentNode.left = null;
                return true;
            }
            if (parentNode.right != null && parentNode.right.key.compareTo(targetNode.key) == 0) {
                parentNode.right = null;
                return true;
            }
        }
        //删除的结点只有左子树
        if (targetNode.left != null && targetNode.right == null) {
            if (parentNode == null) {
                this.root = targetNode.left;
                return true;
            }
            //删除结点是父结点的左结点
            if (parentNode.left != null && parentNode.left.key.compareTo(targetNode.key) == 0) {
                parentNode.left = targetNode.left;
                return true;
            }
            //删除结点是父结点的右结点
            if (parentNode.right != null && parentNode.right.key.compareTo(targetNode.key) == 0) {
                parentNode.right = targetNode.left;
                return true;
            }
        }
        //删除的结点只有右子树
        if (targetNode.right != null && targetNode.left == null) {
            if (parentNode == null) {
                this.root = targetNode.right;
                return true;
            }
            if (parentNode.left != null && parentNode.left.key.compareTo(targetNode.key) == 0) {
                parentNode.left = targetNode.right;
                return true;
            }
            if (parentNode.right != null && parentNode.right.key.compareTo(targetNode.key) == 0) {
                parentNode.right = targetNode.right;
                return true;
            }
        }
        //删除结点左右子树都存在
        if (targetNode.right != null && targetNode.left != null) {
            //从右子树早到最小的结点
            Node minNode = getMinNode(targetNode.right);
            //删除minNode
            delete(minNode.key);
            targetNode.key = minNode.key;
            targetNode.value = minNode.value;
        }
        return false;
    }
    
    //查找当前结点
   private Node getNode(Node root, K key) {
        if (root == null) {
            return null;
        }
        if (root.key.compareTo(key) == 0) {
            return root;
        }
        if (root.key.compareTo(key) > 0) {
            return getNode(root.left, key);
        } else {
            return getNode(root.right, key);
        }
    }
    
    //查找父结点
     private Node getParentNode(Node root, K key) {
        if (root == null) {
            return null;
        }
        if (root.left != null) {
            if (root.left.key.compareTo(key) == 0) {
                return root;
            }
            if (root.key.compareTo(key) > 0) {
                return getParentNode(root.left, key);
            }
        }
        if (root.right != null) {
            if (root.right.key.compareTo(key) == 0) {
                return root;
            }
            if (root.key.compareTo(key) < 0) {
                return getParentNode(root.right, key);
            }
        }
        return null;
    }
   //查找左子树值最小的结点，也就是叶子结点
    private Node getMinNode(Node node) {
        Node targetNode = node;
        while (targetNode.left != null) {
            targetNode = targetNode.left;
        }
        return targetNode;
    }

七、全部代码

public class BinarySortTree<K extends Comparable<? super K>, V> {
    private Node root;

    private class Node {
        private K key;
        private V value;
        private Node left;
        private Node right;

        public Node(K key, V value) {
            this.key = key;
            this.value = value;
        }

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

    /**
     * 添加结点
     * @param key
     * @param value
     */
    public void add(K key, V value) {
        Node node = new Node(key, value);
        if (this.root == null) {
            this.root = node;
            return;
        }
        this.add(this.root, node);
    }

    private void add(Node root, Node node) {
        if (node.key.compareTo(root.key) < 0) {
            if (root.left == null) {
                root.left = node;
            } else {
                add(root.left, node);
            }
        } else {
            if (root.right == null) {
                root.right = node;
            } else {
                add(root.right, node);
            }
        }
    }

    /**
     * 获取值
     * @param key
     * @return
     */
    public V get(K key) {
        if (this.root == null) {
            return null;
        }
        Node node = getNode(this.root, key);
        if (node == null) {
            return null;
        }
        return node.value;
    }

    /**
     * 获取当前结点
     * @param root
     * @param key
     * @return
     */
    private Node getNode(Node root, K key) {
        if (root == null) {
            return null;
        }
        if (root.key.compareTo(key) == 0) {
            return root;
        }
        if (root.key.compareTo(key) > 0) {
            return getNode(root.left, key);
        } else {
            return getNode(root.right, key);
        }
    }

    /**
     * 获取父结点
     * @param root
     * @param key
     * @return
     */
    private Node getParentNode(Node root, K key) {
        if (root == null) {
            return null;
        }
        if (root.left != null) {
            if (root.left.key.compareTo(key) == 0) {
                return root;
            }
            if (root.key.compareTo(key) > 0) {
                return getParentNode(root.left, key);
            }
        }
        if (root.right != null) {
            if (root.right.key.compareTo(key) == 0) {
                return root;
            }
            if (root.key.compareTo(key) < 0) {
                return getParentNode(root.right, key);
            }
        }
        return null;
    }

    /**
     * 查找左子树值最小的结点，也就是叶子结点
     * @param node
     * @return
     */
    private Node getMinNode(Node node) {
        Node targetNode = node;
        while (targetNode.left != null) {
            targetNode = targetNode.left;
        }
        return targetNode;
    }

    /**
     * 删除结点
     * @param key
     * @return
     */
    public boolean delete(K key) {
        if (this.root == null) {
            return false;
        }
        Node targetNode = getNode(this.root, key);
        if (targetNode == null) {
            return false;
        }
        Node parentNode = getParentNode(this.root, key);

        //删除的是叶子结点
        if (targetNode.left == null && targetNode.right == null) {
            //只有根结点
            if (parentNode == null) {
                this.root = null;
                return true;
            }
            if (parentNode.left != null && parentNode.left.key.compareTo(targetNode.key) == 0) {
                parentNode.left = null;
                return true;
            }
            if (parentNode.right != null && parentNode.right.key.compareTo(targetNode.key) == 0) {
                parentNode.right = null;
                return true;
            }
        }
        //删除的结点只有左子树
        if (targetNode.left != null && targetNode.right == null) {
            if (parentNode == null) {
                this.root = targetNode.left;
                return true;
            }
            //删除结点是父结点的左结点
            if (parentNode.left != null && parentNode.left.key.compareTo(targetNode.key) == 0) {
                parentNode.left = targetNode.left;
                return true;
            }
            //删除结点是父结点的右结点
            if (parentNode.right != null && parentNode.right.key.compareTo(targetNode.key) == 0) {
                parentNode.right = targetNode.left;
                return true;
            }
        }
        //删除的结点只有右子树
        if (targetNode.right != null && targetNode.left == null) {
            if (parentNode == null) {
                this.root = targetNode.right;
                return true;
            }
            if (parentNode.left != null && parentNode.left.key.compareTo(targetNode.key) == 0) {
                parentNode.left = targetNode.right;
                return true;
            }
            if (parentNode.right != null && parentNode.right.key.compareTo(targetNode.key) == 0) {
                parentNode.right = targetNode.right;
                return true;
            }
        }
        //删除结点左右子树都存在
        if (targetNode.right != null && targetNode.left != null) {
            //从右子树早到最小的结点
            Node minNode = getMinNode(targetNode.right);
            //删除minNode
            delete(minNode.key);
            targetNode.key = minNode.key;
            targetNode.value = minNode.value;
        }
        return false;
    }

    /**
     * 前序遍历
     */
    public void preOrder() {
        if (this.root == null) {
            return;
        }
        preOrder(this.root);
    }

    private void preOrder(Node node) {
        System.out.println(node);
        if (node.left != null) {
            preOrder(node.left);
        }
        if (node.right != null) {
            preOrder(node.right);
        }
    }
}
三深(sanshen)
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构复习题——判断题
weixin_46448596的博客
01-11 2663
数据元素是数据的最小单位F。数据元素是数据的基本单位。数据的逻辑结构是指数据的各数据项之间的逻辑关系F。逻辑结构就是数据元素间的逻辑关系,而不是数据元素内部的数据项之间的关系。二叉排序树又称“二叉搜索树”,是一种左子树比根结点小,右子树比根结点大的特殊二叉树的形式。冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法。若一个栈的输入序列为1,2,3,…,n，输出序列的第一个元素是i，则第j个（1≤j≤i）输出元素是不确定的。
二叉排序树的高度分析
weixin_34366546的博客
04-14 924
一，介绍 对于二叉排序树而言，其相关操作与树的高度息息相关。设树中有N个节点， 尽管各个操作的平均时间复杂度为O(logN)，但当输入的序列有序时，构造出来的树是一个单分支的树，其高度为O(N) 故对二叉排序树的各个操作（如，findMax、contains、findMin...）的时间复杂度也退化成O(N)    二：实现思路 现在分析给定一个输入序列，根据该输入序列构造一棵二叉排序...
二叉树4：二叉树求树高度(超级详细)
qq_43591406的博客
12-10 3万+
一、思路 什么是树高？ 树的高度(或深度)就是树中结点的最大层数。 在这里 二、代码实现 typedef struct TreeNode{ int data;//数据域 TreeNode *RChild;//右孩子指针 TreeNode *LChild;//左孩子指针 }TreeNode, *BiTree; int PostTreeHeight(BiTree *T){ //通过后序遍历实现求树的高度 int h = 0, hl = 0, hr = 0; if (T==NULL){ retu
二叉排序树_求二叉树的高度
u011925500的专栏
02-15 4231
如果定义一颗二叉树的高度就是从根到叶子的最长距离。试编码求二叉树的高度。 其实，二叉树的高度就是它的左子树和右子树中高度最大值 + 1 另外考虑: 当待排序的数据本来就是有序的情况，会发生什么？ 请参考《数据结构》教材解决这个问题。 class BiTree { private int data; private BiTree left; private Bi
【无标题】pta树判断题答案
weixin_62432151的博客
04-30 2379
数据结构与算法
数据结构实验-二叉排序树算法
10-26
一、问题描述 根据给定的关键字序列，实现二叉排序树的基本操作。 输入格式：8, 10, 5, 6, 3, 13 二、实验目的 ...1、构造二叉排序树的存储结构。 2、实现创建、查找、插入、删除、平均查找长度等操作。
数据结构实验：二叉排序树的插入和删除算法
最新发布
10-17
因此，在插入之前，首先在二叉排序树中检查待插入的数据元素，如果查找成功，说明树中已经存在这个数据元素，则不再插入:如果查找不成功，说明树中不存在关键字等于给定值的数据元素。 在二叉排序树中删除一个数据...
数据结构课程设计二叉排序树的实现
10-06
二叉排序树的实现 二叉排序补充概念(也可以参考书上第九章第二节) 左子树的数据总是小于根和右子树的数据,这种就叫做二叉排序树,简单一点,二叉排序树左边的数据小于右边. ...课程设计数据结构二叉排序树
数据结构平衡二叉排序树
02-13
将输入的所有非0整数按输入次序插入二叉排序树来构造平衡的二叉排序树。输出平衡的二叉排序树的先序和中序递归遍历次序；按中序递归遍历次序输出平衡的二叉排序树各结点的平衡因子。注意：二叉树结点存储结构中应...
实现二叉排序树的各种算法
07-25
SCAU数据结构的综合实验报告 实现二叉排序树的各种算法 因为里面有源程序和报告文档，所以压缩成一个rar文件，只需要解压后即可使用。 包括： 实验的源代码 根据代码写出来的实验报告
二叉排序树、平衡二叉树、红黑树、B树、B+树
24考研人晴落的博客
10-31 5158
全民制作人们，大家好。我是练习时长两天半的个人练习册，喜欢B树，B+树，BST树， AVL树，来redblack~
二叉树相关
Hello World!
08-10 1619
刚刚我们说过了二叉树有两种存储方式顺序存储，和链式存储，顺序存储就是用数组来存，这个定义没啥可说的，我们来看看链式存储的二叉树节点的定义方式。int val;};大家会发现二叉树的定义 和链表是差不多的，相对于链表 ，二叉树的节点里多了一个指针， 有两个指针，指向左右孩子。int val;}}}二叉树的递归遍历递归算法的三个要素。每次写递归，都按照这三要素来写，可以保证写出正确的递归算法！........................
数据结构之平衡二叉树
w_Antetokounmpo的博客
04-11 918
树结构简介 树结构本身是一种天然的组织结构，将数据使用树结构存储后，会大幅高效率。 什么是二叉树 和链表一样，动态数据结构 class Node{ E e; Node left; //左孩子 Node right; //右孩子 } 多叉树（多个子结点） 二叉树具有唯一根节点 二叉树中每个结点最多有两个孩子，没有孩子的结点称之为叶子结点 二叉树中每个结点最多有一个父亲结点，根节点没有...
二叉排序树
清风
04-30 5178
二叉排序树 1.定义 二叉排序树(BST)，又称为二叉树搜索树和二叉查找树。 定义： 如果它的左子树非空，则左子树中的所有结点的值都小于根节点的值 反之，若右子树非空，则右子树上所有的结点的值都大于等于根节点的值 其左右子树本身也是二叉排序树 二叉排序树 该二叉树的中序遍历的结果一定是有序的，如上的中序遍历的结果为3,12,24,37,45,53,61,78,90,99 2.二叉排序树的操作 二叉排序树有关的一些操作可以包含search查找，minimum查找最小值，maxi
[C++日常小题] 计算二叉查找树的高度
从入门到扑街
01-01 3608
Description给定一个二叉查找树，要求计算其高度，每个二叉查找树将给出先序与中序的遍历。例如：一个二叉查找树其先序遍历为：16, 10, 4, 15, 23 ; 中序遍历为 4, 10, 15, 16, 23，则其高度为2（假定空树高度为-1，只有根节点的数高度为0）Input第一行输入测试用例个数。对于每个测试用例，第一行是节点个数n，第二行是key值的先序遍历，第三行是key值的中序遍历
小算法：求一棵二叉树的高度以及求一个节点的左右子树的高度
qq_45273552的博客
10-24 3140
求一棵二叉树的高度以及求一个节点的左右子树的高度 前言： 最近在学习平衡二叉排序树时，在计算二树的高度时笔者学到了一种相当精妙的算法，在此分享一下。 问题： 根据如上图构建一棵二叉树，并求出它的高度。以及写两个方法，传一个节点，可以分别求出它左右子树的高度。 求树的高度 我们只需在树的节点类中写如下方法： 返回的是以当前节点为根节点的树的高度 public int height() { return Math.max(left==null?0:left.height(),right==null?0:r
二叉树的深度和高度
Mamba_Stan的博客
09-07 4253
给定一个二叉树, 找出其最大深度。二叉树的深度为根节点到最远叶子节点最长路径上的节点数。如二叉树 [ 3, 9, 20, null, null, 15, 7 ]的最大深度为3:先看一个简单的情况:对于节点 3, 最大深度自然是左右子节点 + 1, 左右子节点都有可能为空, 但只要有一个, 树的最大高度就是 1 + 1 = 2。然后再增加几个节点:而对于节点 3, 则是左右子树深度最大的那个然后 + 1, 具体谁更大, 并不关心。
【数据结构】之二叉排序树的实现（C语言）
xiangjunyes的博客
10-01 969
文章目录二叉排序树二叉排序树的查找操作二叉排序树的插入操作二叉排序树的删除操作总结 如果我们要查找的数据集是有序线性表，并且是顺序存储的，查找可以用折半，插值，等查找算法来实现。可惜，因为有序，在插入和删除操作上，就需要耗费大量的时间。 有没有一种既可以使得插入和删除的效率不错，又可以比较高效率的实现查找的算法呢？ 二叉排序树 二叉排序树，又称为二叉查找树。它或者是一颗空树，或者是具有下列性质的二叉树。 若他的左子树不为空，则左子树上所有结点的值均小于他的根节点的值。 若他的右子树不为空，则右子树上所有结
二叉树高度的三种计算方法
热门推荐
BackToMe的博客
02-10 5万+
计算二叉树的高度可以采用几种不同的算法。 算法一：采用后序遍历二叉树，结点最大栈长即为二叉树的高度； 算法二：层次遍历二叉树，最大层次即为二叉树的高度； 算法三：采用递归算法，求二叉树的高度。 /法1：后序遍历，结点最大栈长即为树的高度 //法2：层次遍历，层次即为高度 //法3：递归求树高 //调试程序输入二叉树：-+a##*b##-c##d##/e##f## //程序输出该二叉树的高
二叉排序树表数据结构
08-27
二叉排序树是一种二叉树数据结构，也称为二叉查找树或二叉搜索树。它要么是一棵空树，要么满足以下条件：对于任意节点，其左子树中的所有节点的值小于它的值，而右子树中的所有节点的值大于它的值。这个特点使得在二叉排序树中进行查找操作具有高效性能，接近于折半查找。如果二叉排序树不平衡，它的深度可能达到n，查找效率将变为O(n)，相当于顺序查找。因此，为了获得较好的查找性能，需要构造一棵平衡的二叉排序树。 二叉排序树的存储结构一般使用链式存储结构，每个节点包含一个数据元素以及两个指向左子树和右子树的指针。可以使用递归或迭代的方式实现创建、查找、插入、删除等操作，以及计算平均查找长度等指标。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* [数据结构-二叉排序树（图文详细版）](https://blog.csdn.net/qq_55660421/article/details/122530387)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *3* [数据结构实验-二叉排序树算法](https://download.csdn.net/download/whales996/10746805)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值