数据结构之二叉搜索树

最新推荐文章于 2024-03-25 18:55:55 发布

野心与梦

最新推荐文章于 2024-03-25 18:55:55 发布

阅读量1.7w

点赞数 1

分类专栏：数据结构与算法文章标签：数据结构算法

本文链接：https://blog.csdn.net/weixin_45690643/article/details/130234897

版权

数据结构与算法专栏收录该内容

14 篇文章 0 订阅

订阅专栏

概念

二叉搜索树又叫二叉查找树，二叉排序树；特性：任意一个点的左子树小于该点，右子树大于该点

为什么又叫做二叉排序树呢？

中序遍历一定有序，上图中序遍历为0 3 4 5 6 8

为什么叫二叉查找树？

左子树<父节点，右子树>父节点，二分查找算法，可以排除一半的空间

操作性能

删除	1、要删除的结点是叶子结点 O(1) 2、要删除的结点只有一个子树（左或者右）O(1) 3、要删除的结点有两颗子树：找后继结点，而且后继结点的左子树一定为空【后继节点：删除节点右子树最左边的节点】
查找	logn
插入	logn 插入的时候每次都是和根结点比较。一直要找到它应该插入的位置。肯定会插在叶子结点。那么其实大家可以看到插入其实就是查找

用途

二叉搜索树有哪些应用呢？主要用于搜索
退化这也叫二叉树
为什么（退化了）？怎么解决呢？不要变成一个链条一样

通过上面两个图我们发现，二叉树的结构就决定了其搜索的性能，那么我们应该怎么优化呢？
因此就有了AVL树和红黑树

AVL树（自平衡二叉树）：AVL属于实验室状态的，红黑树才是我们项目中用的

AVL树：平衡二叉树，它的左右子树高度之差不超过1这样确实可以避免一条直线型的结构

红黑树

实现二叉搜索树

MyTreeNode.java
BinarySearchTree.java
演示网站：https://www.cs.usfca.edu/~galles/visualization/BST.html

节点定义

package datastructure.tree;

import datastructure.queue.LinkedListQueue;

/**
 * 节点
 *
 * @author zw
 * @create 2023-04-03 16:12
 */
public class MyTreeNode<T extends Comparable<T>> {
    public int color;   // 红黑树颜色
    public int weight;     //表示是频率(权重),哈夫曼树
    public T data;
    public MyTreeNode<T> left;
    public MyTreeNode<T> right;
    public MyTreeNode<T> parent;

    @Override
    public String toString() {
        return "Node [color=" + color + ", left=" + left.data + ", right=" + right.data + ", parent="
                + parent.data + "]" + "\r\n";
    }

    public MyTreeNode(T data, MyTreeNode<T> left, MyTreeNode<T> right) {
        this.data = data;
        this.left = left;
        this.right = right;
    }

    public MyTreeNode(T data) {
        this.data = data;
    }

    public MyTreeNode(T data, int weight) {
        this.data = data;
        this.weight = weight;
    }

    // 用于节点的层数
    public int getNodeDepth(BinaryNode root) {
        return root.equals(this) ? 0 : (1 + Math.max(getNodeDepth(root.left), getNodeDepth(root.right)));
    }


    /**
     * 查找后继节点
     *
     * @return
     */
    public MyTreeNode findSuccessorsNode() { // 查找node的后继节点
        if (this.right == null) { // 表示没有右边 那就没有后继
            return this;
        }
        MyTreeNode cur = this.right;
        MyTreeNode pre = this.right; // 开一个额外的空间 用来返回后继节点，因为我们要找到为空的时候，那么其实返回的是上一个节点
        while (cur != null) {
            pre = cur;
            cur = cur.left; // 注意后继节点是要往左边找，因为右边的肯定比左边的大，我们要找的是第一个比根节点小的，所以只能往左边
        }
        return pre; // 因为cur会变成null，实际我们是要cur的上一个点，所以就是pre来代替
    }

    /**
     * 前序遍历：根(输出) 左 右 时间复杂度？O(n) N^2 O(2*n)=>O(n);
     */
    public void pre(MyTreeNode root) {
        System.out.print(root.data); // 根
        if (root.left != null) pre(root.left); // 左
        if (root.right != null) pre(root.right); // 右
    }

    public void pre() {
        pre(this);
    }

    /**
     * 中序遍历：左 根(输出)  右
     */
    public void in(MyTreeNode root) {
        if (root.left != null) in(root.left); // 左
        System.out.print(root); // 根
        if (root.right != null) in(root.right); // 右
    }

    public void in() {
        in(this);
    }

    /**
     * 后序遍历：左  右 根(输出)
     */
    public void post(MyTreeNode root) {
        if (root.left != null) post(root.left); // 左
        if (root.right != null) post(root.right); // 右
        System.out.print(root.data); // 根
    }

    public void post() {
        post(this);
    }

    /**
     * 广度优先遍历：层次遍历
     * 算法思想：
     * （1）我们定义一个队列，先将根结点入队；
     * （2）当前结点是队头结点，将其出队并访问；
     * （3）若当前结点的左结点不为空将左结点入队；若当前结点的右结点不为空将其入队即可。
     */
    private void bfs(MyTreeNode root) {
        LinkedListQueue<MyTreeNode> queue = new LinkedListQueue<MyTreeNode>(100);
        // 添加元素到队尾
        queue.add(root);
        while (!queue.isEmpty()) {
            // 取出队头元素
            MyTreeNode head = queue.poll();
            System.out.print(head.data);
            // 将左节点添加到队列
            if (head.left != null) queue.add(head.left);
            // 将右边节点添加队列
            if (head.right != null) queue.add(head.right);
        }
    }

    public void bfs() {
        bfs(this);
    }


    /**
     * 兄弟节点
     *
     * @return
     */
    public MyTreeNode brotherNode() {
        if (this.isLeftNode()) return this.parent.right;
        if (this.isRightNode()) return this.parent.left;
        return null;
    }

    /**
     * 叔叔节点
     *
     * @return
     */
    public MyTreeNode uncleNode() {
        if (this.parent == null) return null;
        else if (this.parent.isLeftNode()) return this.parent.parent.right;
        else if (this.parent.isRightNode()) return this.parent.parent.left;
        return null;
    }

    /**
     * 大于
     *
     * @param data
     * @return
     */
    public boolean gt(T data) {
        return this.data.compareTo(data) > 0;
    }

    public boolean gt(MyTreeNode<T> node) {
        return this.data.compareTo(node.data) > 0;
    }

    /**
     * 等于
     *
     * @param data
     * @return
     */
    public boolean equals(T data) {
        return this.data.compareTo(data) == 0;
    }

    /**
     * 小于
     *
     * @param data
     * @return
     */
    public boolean lt(T data) {
        return this.data.compareTo(data) < 0;
    }

    public boolean lt(MyTreeNode<T> node) {
        return this.data.compareTo(node.data) < 0;
    }

    public boolean isRootNode() {
        return this.parent == null;
    }

    public boolean isLeftNode() {
        return this.equals(this.parent.left);
    }

    public boolean isRightNode() {
        return this.equals(this.parent.right);
    }

    public boolean isLeaf() {
        return this.left == null && this.right == null;
    }

    public boolean isLeftLeaf() {
        return (this.left == null && this.right == null)
                && this.equals(this.parent.left);
    }

    public boolean isRightLeaf() {
        return (this.left == null && this.right == null)
                && this.equals(this.parent.right);
    }

    /**
     * 存在2个子节点
     *
     * @return
     */
    public boolean have2ChildNode() {
        return this.left != null && this.right != null;
    }

    /**
     * 只存在左子节点
     *
     * @return
     */
    public boolean onlyLeftChildNode() {
        return this.left != null && this.right == null;
    }

    /**
     * 只存在右子节点
     *
     * @return
     */
    public boolean onlyRightChildNode() {
        return this.left == null && this.right != null;
    }

    /**
     * 打印当前节点树
     */
    public void show() {
        // 得到树的深度
        int treeDepth = getTreeDepth(this);

        // 最后一行的宽度为2的（n - 1）次方乘3，再加1
        // 作为整个二维数组的宽度
        int arrayHeight = treeDepth * 2 - 1;
        int arrayWidth = (2 << (treeDepth - 2)) * 3 + 1;
        // 用一个字符串数组来存储每个位置应显示的元素
        String[][] res = new String[arrayHeight][arrayWidth];
        // 对数组进行初始化，默认为一个空格
        for (int i = 0; i < arrayHeight; i++) {
            for (int j = 0; j < arrayWidth; j++) {
                res[i][j] = " ";
            }
        }

        // 从根节点开始，递归处理整个树
        writeArray(this, 0, arrayWidth / 2, res, treeDepth);

        // 此时，已经将所有需要显示的元素储存到了二维数组中，将其拼接并打印即可
        for (String[] line : res) {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < line.length; i++) {
                sb.append(line[i]);
                if (line[i].length() > 1 && i <= line.length - 1) {
                    i += line[i].length() > 4 ? 2 : line[i].length() - 1;
                }
            }
            System.out.println(sb.toString());
        }
    }

    private void writeArray(MyTreeNode<T> currNode, int rowIndex, int columnIndex, String[][] res, int treeDepth) {
        // 保证输入的树不为空
        if (currNode == null) return;
        // 先将当前节点保存到二维数组中
        res[rowIndex][columnIndex] = String.valueOf(currNode.data)+"|" + String.valueOf(currNode.color);

        // 计算当前位于树的第几层
        int currLevel = ((rowIndex + 1) / 2);
        // 若到了最后一层，则返回
        if (currLevel == treeDepth)
            return;
        // 计算当前行到下一行，每个元素之间的间隔（下一行的列索引与当前元素的列索引之间的间隔）
        int gap = treeDepth - currLevel - 1;

        // 对左儿子进行判断，若有左儿子，则记录相应的"/"与左儿子的值
        if (currNode.left != null) {
            res[rowIndex + 1][columnIndex - gap] = "/";
            writeArray(currNode.left, rowIndex + 2, columnIndex - gap * 2, res, treeDepth);
        }

        // 对右儿子进行判断，若有右儿子，则记录相应的"\"与右儿子的值
        if (currNode.right != null) {
            res[rowIndex + 1][columnIndex + gap] = "\\";
            writeArray(currNode.right, rowIndex + 2, columnIndex + gap * 2, res, treeDepth);
        }
    }


    /**
     * 用于获得树的层数
     *
     * @return
     */
    public int getTreeDepth(MyTreeNode<T> currNode) {
        return currNode == null ? 0 : (1 + Math.max(getTreeDepth(currNode.left), getTreeDepth(currNode.right)));
    }
}

查询操作

/**
 * 查询data是否存在
 */
public MyTreeNode<T> find(MyTreeNode<T> root, T data) {
    MyTreeNode<T> current = root;
    while (current != null) {
        if (current.gt(data)) {
            current = current.left;
        } else if (current.lt(data)) {
            current = current.right;
        } else {
            return current;
        }
    }
    return null;
}

插入操作

/**
 * 插入
 *
 * @param currNode 
 * @param data
 */
public void insert(MyTreeNode<T> currNode, T data) {
    // 判断应该插入左边还是右边
    if (currNode.gt(data)) { // 根节点currNode >插入节点：插入左边
        if (currNode.left == null) { // 左边为空则插入
            MyTreeNode insertNode = new MyTreeNode(data);
            currNode.left = insertNode;
            insertNode.parent = currNode;
        } else { // 否则继续往下查找插入位置
            insert(currNode.left, data);
        }
    } else { // 根节点< 插入节点：插入右边
        if (currNode.right == null) { // 左边为空则插入
            MyTreeNode insertNode = new MyTreeNode(data);
            currNode.right = insertNode;
            insertNode.parent = currNode;
        } else { // 否则继续往下查找插入位置
            insert(currNode.right, data);
        }
    }
}

删除操作（必须会）

    /**
     * 删除节点
     *
     * @param root 从root节点开始查询删除
     * @param data
     * @return
     */
    public void remove(MyTreeNode<T> root, T data) {
        // 查找删除的节点
        MyTreeNode<T> delNode = find(root, data);
        if (delNode == null) {
            return; // 要删除的值不在树中
        }
        // 要删除的结点是叶子结点 O(1)
        System.out.println(String.format("叶子:%s\t有左子树：%s\t有右子树：%s\t有2子树:%s",
                delNode.isLeaf(),delNode.onlyLeftChildNode(), delNode.onlyRightChildNode(),delNode.have2ChildNode()));
        removeLeafNode(delNode);
        // 要删除的结点只有一个子树（左或者右）O(1)
        removeNodeOnlyOneNode(delNode);
        // 要删除的结点有两颗子树：找后继结点，而且后继结点的左子树一定为空
        removeNodeHaveTwoNode(delNode);
    }

删除叶子节点

    /**
     * 删除叶子节点
     *
     * @param delNode
     */
    private void removeLeafNode(MyTreeNode<T> delNode) {
        if (delNode.isLeaf()) {
            // 判断当前节点是根节点，还是左节点、右节点
            if (delNode.isRootNode()) {
                root = null;
            } else if (delNode.isLeftNode()) { // 左节点
                delNode.parent.left = null;
            } else if (delNode.isRightNode()) { // 右节点
                delNode.parent.right = null;
            }
        }
    }

要删除的结点只有一个子树

 /**
     * 要删除的结点只有一个子树（左或者右）O(1)
     *
     * @param delNode
     */
    private void removeNodeOnlyOneNode(MyTreeNode<T> delNode) {
        // -----------删除节点只存在左节点---------------
        if (delNode.onlyLeftChildNode()) {
            if (delNode.isRootNode()) {
                root = delNode.left;
                root.parent = null;
            }
            // 删除节点是左节点
            //              parentNode
            //         delNode      null
            //     leftNode
            else if (delNode.isLeftNode()) {     // 左节点
                delNode.parent.left = delNode.left;
                delNode.left.parent = delNode.parent;
            }
            // 删除节点是右节点
            //                  parentNode
            //                null  delNode
            //                  leftNode
            else if (delNode.isRightNode()) { // 右节点
                delNode.parent.right = delNode.left;
                delNode.left.parent = delNode.parent;
            }
        }
        // ----------删除节点存在右节点--------------
        if (delNode.onlyRightChildNode()) {
            if (delNode.isRootNode()) {
                root = root.right;
                root.parent = null;
            }
            // 删除节点是左节点
            //             parentNode
            //         delNode      null
            //             rightNode
            else if (delNode.isLeftNode()) {
                delNode.parent.left = delNode.right;
                delNode.right.parent = delNode.parent;
            }
            // 删除节点是右节点
            //                  parentNode
            //                null  delNode
            //                  leftNode
            else if (delNode.isRightNode()) {
                delNode.parent.right = delNode.right;
                delNode.right.parent = delNode.parent;
            }
        }
    }

要删除的结点有两颗子树

/**
     * 要删除的结点有两颗子树
     *
     * @param delNode
     * @param delNode
     */
    private void removeNodeHaveTwoNode(@NotNull MyTreeNode<T> delNode) {
        if (delNode.have2ChildNode()) {
            // 查找当前节点的后继节点【第一个右节点的最左节点,后继节点左节点一定为null】
            MyTreeNode<T> successorsNode = delNode.findSuccessorsNode();
            System.out.println(String.format("后继节点= 叶子:%s\t有左子树：%s\t有右子树：%s\t有2子树:%s",
                    successorsNode.isLeaf(),successorsNode.onlyLeftChildNode(), successorsNode.onlyRightChildNode(),successorsNode.have2ChildNode()));
            // 后继节点和删除节点进行交换，首先后继节点的左节点是肯定为空的
            delNode.data = successorsNode.data;
            // 1. 删除后继节点
            // 1.1 要删除的结点是叶子结点 O(1)
            //              root
            //            a      b  删除b:后继节点为f，将f和b交换，在删除b
            //           c d    e f
            removeLeafNode(successorsNode);
            // 1.2 要删除的结点只有一个子树（左或者右）O(1)
            //              root
            //            a      b  删除b:后继节点为h，将h和b交换，在删除b
            //           c d    e f
            //                 g h
            removeNodeOnlyOneNode(successorsNode);
        }
    }

测试用例

完整代码BinarySearchTree.java MyTreeNode.java

    public static void main(String[] args) {
        BinarySearchTree binarySearchTree = new BinarySearchTree();
        int[] input = {15, 10, 19, 8, 13, 16, 28, 5, 9, 12, 14, 20, 30, 25};
        for (int data : input) {
            binarySearchTree.insert(data);
            System.out.println(String.format("-------插入%s--------", data));
            binarySearchTree.root.show();

        }
        System.out.println("----------------------------------");
        int[] remove = {15, 8, 5, 12, 19, 16, 14, 30, 9, 13, 20, 28, 25, 10};
        for (int data : remove) {
            System.out.println(String.format("-------删除%s--------", data));
            binarySearchTree.remove(data);
            MyTreeNode root = binarySearchTree.root;
            if (root != null)  root.show();
        }
    }

运行结果

-------插入15--------
15
-------插入10--------
   15  
  /    
 10    
-------插入19--------
   15  
  / \  
 10  19
-------插入8--------
      15     
    /   \    
  10      19 
 /           
8            
-------插入13--------
      15     
    /   \    
  10      19 
 / \         
8   13       
-------插入16--------
      15     
    /   \    
  10      19 
 / \     /   
8   13  16   
-------插入28--------
      15     
    /   \    
  10      19 
 / \     / \ 
8   13  16  28
-------插入5--------
            15           
         /     \         
      10          19     
    /   \       /   \    
  8       13  16      28 
 /                       
5                        
-------插入9--------
            15           
         /     \         
      10          19     
    /   \       /   \    
  8       13  16      28 
 / \                     
5   9                    
-------插入12--------
            15           
         /     \         
      10          19     
    /   \       /   \    
  8       13  16      28 
 / \     /               
5   9   12               
-------插入14--------
            15           
         /     \         
      10          19     
    /   \       /   \    
  8       13  16      28 
 / \     / \             
5   9   12  14           
-------插入20--------
            15           
         /     \         
      10          19     
    /   \       /   \    
  8       13  16      28 
 / \     / \         /   
5   9   12  14      20   
-------插入30--------
            15           
         /     \         
      10          19     
    /   \       /   \    
  8       13  16      28 
 / \     / \         / \ 
5   9   12  14      20  30
-------插入25--------
                        15                       
                    /       \                    
                10              19               
             /     \         /     \             
          8           13  16          28         
        /   \       /   \           /   \        
      5       9   12      14      20      30     
                                   \             
                                    25           
----------------------------------
-------删除15--------
叶子:false	有左子树：false	有右子树：false	有2子树:true
后继节点= 叶子:true	有左子树：false	有右子树：false	有2子树:false
                        16                       
                    /       \                    
                10              19               
             /     \               \             
          8           13              28         
        /   \       /   \           /   \        
      5       9   12      14      20      30     
                                   \             
                                    25           
-------删除8--------
叶子:false	有左子树：false	有右子树：false	有2子树:true
后继节点= 叶子:true	有左子树：false	有右子树：false	有2子树:false
                        16                       
                    /       \                    
                10              19               
             /     \               \             
          9           13              28         
        /           /   \           /   \        
      5           12      14      20      30     
                                   \             
                                    25           
-------删除5--------
叶子:true	有左子树：false	有右子树：false	有2子树:false
                        16                       
                    /       \                    
                10              19               
             /     \               \             
          9           13              28         
                    /   \           /   \        
                  12      14      20      30     
                                   \             
                                    25           
-------删除12--------
叶子:true	有左子树：false	有右子树：false	有2子树:false
                        16                       
                    /       \                    
                10              19               
             /     \               \             
          9           13              28         
                        \           /   \        
                          14      20      30     
                                   \             
                                    25           
-------删除19--------
叶子:false	有左子树：false	有右子树：true	有2子树:false
            16           
         /     \         
      10          28     
    /   \       /   \    
  9       13  20      30 
           \   \         
            14  25       
-------删除16--------
叶子:false	有左子树：false	有右子树：false	有2子树:true
后继节点= 叶子:false	有左子树：false	有右子树：true	有2子树:false
            20           
         /     \         
      10          28     
    /   \       /   \    
  9       13  25      30 
           \             
            14           
-------删除14--------
叶子:true	有左子树：false	有右子树：false	有2子树:false
      20     
    /   \    
  10      28 
 / \     / \ 
9   13  25  30
-------删除30--------
叶子:true	有左子树：false	有右子树：false	有2子树:false
      20     
    /   \    
  10      28 
 / \     /   
9   13  25   
-------删除9--------
叶子:true	有左子树：false	有右子树：false	有2子树:false
      20     
    /   \    
  10      28 
   \     /   
    13  25   
-------删除13--------
叶子:true	有左子树：false	有右子树：false	有2子树:false
      20     
    /   \    
  10      28 
         /   
        25   
-------删除20--------
叶子:false	有左子树：false	有右子树：false	有2子树:true
后继节点= 叶子:true	有左子树：false	有右子树：false	有2子树:false
   25  
  / \  
 10  28
-------删除28--------
叶子:true	有左子树：false	有右子树：false	有2子树:false
   25  
  /    
 10    
-------删除25--------
叶子:false	有左子树：true	有右子树：false	有2子树:false
10
-------删除10--------
叶子:true	有左子树：false	有右子树：false	有2子树:false
EMPTY!

野心与梦

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
数据结构之二叉搜索树

*** 节点// 红黑树颜色 public int weight;//表示是频率(权重),哈夫曼树 public T data;} // 用于节点的层数 public int getNodeDepth(BinaryNode root) {} /*** 查找后继节点* @return// 查找node的后继节点 if(this . right == null) {// 表示没有右边那就没有后继 return this;
复制链接

扫一扫