BinarySortTree二叉排序树

程序员刚子

已于 2022-01-19 22:07:00 修改

阅读量521

点赞数 2

分类专栏：大杂烩文章标签： b树数据结构

于 2020-10-14 17:49:03 首次发布

本文链接：https://blog.csdn.net/qq_33188180/article/details/109078551

版权

大杂烩专栏收录该内容

9 篇文章 2 订阅

订阅专栏

先了解一下数据结构中，树的基本概念

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因
为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：每个结点有零个或多
个子结点；没有父结点的结点称为根结点；每一个非根结点有且只有一个父结点；除了根结点外，每个子结
点可以分为多个不相交的子树。

å¨è¿éæå¥å¾çæè¿°

数据结构-各种树的定义

树的种类：

无序树

树的任意节点的子节点没有顺序关系。

有序树

树的任意节点的子节点有顺序关系。

二叉树

树的任意节点至多包含两棵子树。

满二叉树

叶子节点都在同一层并且除叶子节点外的所有节点都有两个子节点。

完全二叉树

对于一颗二叉树，假设其深度为d（d>1）。除第d层外的所有节点构成满二叉树，且第d层所有节点从左向右连续地紧密排列，这样的二叉树被称为完全二叉树；
PS：这里的满二叉树和完全二叉树取的是国内的定义，国外的定义不一样，有兴趣的可以去看看国外的定义。

平衡二叉树（AVL）

它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树，同时，平衡二叉树必定是二叉搜索树。

二叉查找树（二叉搜索树、BST）

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

霍夫曼树

带权路径最短的二叉树称为哈夫曼树或最优二叉树。

红黑树

红黑树是一颗特殊的二叉查找树，除了二叉查找树的要求外，它还具有以下特性：

每个节点或者是黑色，或者是红色。
根节点是黑色。
每个叶子节点（NIL）是黑色。 [注意：这里叶子节点，是指为空(NIL或NULL)的叶子节点！]
如果一个节点是红色的，则它的子节点必须是黑色的。
从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。

红黑树图例

B-tree（B-树或者B树）

一颗m阶B树的特性：

根结点至少有两个子女（如果B树只有一个根节点，这个根节点的key的数量可以为[1~m-1]）
每个非根节点所包含的关键字个数 j 满足：⌈m/2⌉ - 1 <= j <= m - 1，节点的值按非降序方式存放，即从左到右依次增加
除根结点以及叶子节点以外的所有结点的度数正好是关键字总数加1，故内部节点的子树个数 k 满足：⌈m/2⌉ <= k <= m
所有的叶子结点都位于同一层

假定：
m：B树的阶
n：非根的内部节点键的个数
t：m阶B树的节点能存在的最小的度
则有：
⌈m/2⌉ - 1 <= n <= m - 1
t - 1 <= n <= 2t -1

B+树

m阶B+树是m阶B-tree的变体，它的定义大致跟B-tree一致，不过有以下几点不同：

有n棵子树的结点中含有n个关键字，每个关键字不保存数据，只用来索引，所有数据都保存在叶子节点，其中⌈m/2⌉ <= n <= m
所有的叶子结点中包含了全部关键字的信息，及指向含这些关键字记录的指针，且叶子结点本身依关键字的大小自小而大顺序链接
所有的非终端结点可以看成是索引部分，结点中仅含其子树（根结点）中的最大（或最小）关键字
通常在B+树上有两个头指针，一个指向根结点，一个指向关键字最小的叶子结点

B*树

B*树是B+树的变体，除了B+树的要求之外，还有以下特性：

⌈m*2/3⌉ <= n <=m 这里的n是除根节点之外的内部节点的键
增加内部节点中兄弟节点的指针，由左边指向右边

B*树

关于广度优先搜索与深度优先搜索

深度优先遍历(DFS)和广度优先遍历(BFS)

什么时候要用深度优先遍历DFS呢

某些问题会用到，比如，找最近公共子串

深度优先遍历，代码写起来简洁，因为是使用递归调用，使用的栈，

开始进入正题

二叉排序树

二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。在一般情况下，查询效率比链表结构要高

也被成为 ordered binary tree（有序二叉树）或 sorted binary tree（排序二叉树）,有如下性质：

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

一棵二叉查找树是一棵二叉树，每个节点都含有一个Comparable的键（以及对应的值）。

每个节点的键都大于左子树中任意节点的键而小于右子树中任意节点的键。

每个节点都有两个链接，左链接、右链接，分别指向自己的左子节点和右子节点，链接也可以指向null。

尽管链接指向的是节点，可以将每个链接看做指向了另一棵二叉树。这个思路能帮助理解二叉查找树的递归方法。

和数组，链表的比较

数据：查找快 O（1），插入慢O（N）需要移动插入点之后的所有数据。
链表：查找慢 O(N) ，插入快 O（1）每次查找都需要遍历一遍

于是作为平衡的Binary Search Tree出现了
查找平均O（logN）最差O（N）
插入平均O（logN）最差O（N）

开始上代码

注意Node类是一个内部类，在使用时注意方法。

后面会有详细的图解

package dataStructure;

public class BinarySortTree {

	public class Node{
        int value;
        Node left;
        Node right;
        public Node(int  value){this.value = value;}
        
        /**
         * 增加节点
         * @param node
         */
        public void add(Node node){
            if(node == null) return;
            //判断传入的节点的值比当前子树的根节点的值大还是小
            // this  代表当前子树的根节点
            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);
                }
            }
        }

        /**
         * 前序遍历二叉排序树
         * @param node
         */
        public void middleOder(Node node){
            if(node == null){
                return;
            }
            middleOder(node.left);
            System.out.println(node.value);
            middleOder(node.right);
        }

        /**
         * 查找某一节点
         * @param value
         * @return
         */
        public Node search(int value){
            if(this.value == value){
                return this;
            }
            else if(value < this.value){
                if(this.left == null){
                    return null;
                }
                 return this.left.search(value);
            }
            else{
                if(this.right == null){
                    return null;
                }
                return  this.right.search(value);
            }

        }
        
        /**
         * 查找父节点
         * @param value
         * @return
         */
        public Node searchParent(int value) {
            if((this.left != null && this.left.value == value) || (this.right != null && this.right.value == value)){
                return this;
            }
            else{
                if(this.value > value&& this.left != null){
                    return this.left.searchParent(value);
                }
                else if(this.value < value && this.right !=null){
                    return this.right.searchParent(value);
                }
            }
            return null;
        }
      }
	// 内部类结束


	// 对内部类的实例化，调用内部类方法需要使用
    Node root;
    

     //向二叉排序树中添加节点
    public void add(Node node){
        if(root == null){
            root = node;
        }
      else{
            root.add(node);
        }
    }
    
    // 前序遍历
    public void frontShow(){
        if(root != null){
            this.root.middleOder(root);
        }
    }
    
    //查找节点
    public Node SearchNode(int value){
        if(root == null)
            return null;
        else{
            return root.search(value);
        }
    }

    // 删除
    public void delete(int value) {
        if (root == null)
            return;
        else{
            Node target = SearchNode(value);
            //如果没有这个节点
            if(target == null){
                return;
            }
            //找到他的父节点
            Node parent = searchParent(value);
            //要删除的节点是叶子结点
            if(target.left == null && target.right == null){
                //要删除的节点是节点的左子节点
                if(parent.left.value == value){
                    parent.left =null;
                }
                else{
                    parent.right = null;
                }
            }
            //要删除的节点有两个子节点的情况
            else if(target.left != null && target.right != null){
                   //删除右子树中值最小的节点，并获取到该节点的值
                int min = minDelete(target.right);
                //替换目标节点中的值
                target.value = min;
            }
            else{
                //需要删除的目标节点的左节点不为空
                if(target.left != null){
                    //要删除的子节点是其父节点的左子节点，并且有左节点而没有有节点
                    if(parent.left.value == value){
                        parent.left = target.left;
                    }
                    //要删除的子节点是其父节点的右子节点，并且有左节点而没有有节点
                    else{
                        parent.right = target.left;
                    }
                }
                //需要删除的目标节点的右节点不为空
                else{
                    //要删除的节点是父节点的左节点，并且有右节点儿没有左节点
                    if(parent.left.value == value){
                        parent.left = target.right;
                    }
                    //要删除的节点是其父节点的右节点，并且有右孩子没有左孩子
                    else{
                        parent.right = target.right;
                    }
                }


            }

        }
    }


     //删除一颗树中最小的节点
    public int minDelete(Node node){
        Node target = node;
        while(target.left != null){
            target = target.left;
        }
       delete(target.value);
        return target.value;

    }

     //查找父节点
    public Node searchParent(int value){
        if(root == null){
            return null;
        }
        else{
            return root.searchParent(value);
        }
    }
   
    
    public static void main(String[] args){
        int[] arr = new int[]{7,3}; //,3,10,12,5,1,9
        BinarySortTree binTree = new BinarySortTree();
        for(int i : arr){
            binTree.add(binTree.new Node(i));
        }
        
//        binTree.delete(7);
        
        //查看树中的值
        binTree.frontShow();
        
        //查找
//        Node node = binTree.new Node(3);
//        Node res = binTree.SearchNode(node.value);
//        System.out.println(res.value);
        
       // Node temp = binTree.SearchNode(20);
        //System.out.println(temp.value);
    }
}

其中最复杂的二叉树删除操作

如果删除的是叶子节点，就直接置为null 就意味着删除，如图，直接把8变为null

如果删除的节点有左右两个子节点，就找到右子树上最小的节点，将这个节点替换为要删除的节点，代码中操作就是，将这个节点置为null，然后返回这个节点的值，赋值给要删除的节点。如图，需要删除的是3，我们找到3右边最小的节点4，然后将4变为null，再把3变为4

要删除的节点，有左子节点但是没右子节点，或者有右子节点但是没左子节点。如图，需要删除7，我们直接把8连到5下面就好了

拙略的理解

个人博客：wggz.top

个人微信公众号：后端开发充电宝

欢迎关注👏

程序员刚子

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
BinarySortTree二叉排序树

深度优先搜索DFS广度优先搜索BFS什么时候要用深度优先遍历DFS呢某些问题会用到，比如，找最近公共子串深度优先遍历，代码写起来简洁，因为是使用递归调用，使用的栈，https://blog.csdn.net/rodman177/article/details/89771156结合代码好好整理一下...
复制链接

扫一扫