【数据结构-7】二叉搜索树/AVL树/红黑树

最新推荐文章于 2024-07-14 01:31:01 发布
最新推荐文章于 2024-07-14 01:31:01 发布
阅读量294 收藏 1
点赞数 9
文章标签： 数据结构 java 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lnx97111/article/details/137386604
版权

学习目标：

掌握基于二叉树变化的数据结构

学习内容：

例如：

  1. 二叉搜索树
  2. AVL树
  3. 红黑树

二叉搜索树

构建

public class BSTree {
    static class BSTNode {
        int key;
        Object value;
        BSTNode left;
        BSTNode right;

        public BSTNode(int key) {
            this.key = key;
        }

        public BSTNode(int key, Object value) {
            this.key = key;
            this.value = value;
        }

        public BSTNode(int key, Object value, BSTNode left, BSTNode right) {
            this.key = key;
            this.value = value;
            this.left = left;
            this.right = right;
        }
    }

    BSTNode root;
}

根据key获取值

    public Object get(int key) {
        BSTNode node = root;
        while (node != null) {
            if (key < node.key) {
                node = node.left;
            } else if (key > node.key) {
                node = node.right;
            } else {
                return node.value;
            }
        }
        return null;
    }

返回最大最小值

    public Object min(){
        if(root == null)return null;
        BSTNode p = root;
        while(p.left!=null){
            p = p.left;
        }
        return p.value;
    }

    public Object max(){
        if(root==null)return  null;
        BSTNode p = root;
        while(p.right!=null){
            p = p.right;
        }
        return p.value;
    }

put（有则覆盖，无则存入）

public void put(int key,Object value){
    BSTNode p = root;
    BSTNode parent = null;
    while(p!=null){
        if(key<p.key){
            parent = p;
            p = p.left;
        } else if (key>p.key) {
            parent = p;
            p = p.right;
        }else {
            //找到了
            p.value = value;
            return;
        }
    }
    if(parent==null){
        root = new BSTNode(key, value);
        return;
    }

    //没找到
    if(key<parent.key){
        parent.left = new BSTNode(key,value);
    }else{
        parent.right = new BSTNode(key,value);
    }
}

找前任

需要重写max()和min()，改成有参方法

public Object predecessor(int key) {
    BSTNode p = root;
    BSTNode node = null;
    while (p != null) {
        if (key < p.key) {
            p = p.left;
        } else if (key > p.key) {
            node = p;
            p = p.right;
        } else {
            break;
        }
    }
    //没找到节点
    if (p == null) {
        return null;
    }
    /*
     * 找到节点
     * 情况1.节点有左子树，返回左子树最大值
     * 情况2：节点没有左子树，返回离它最近的，自左而来的祖先
     * */
    if (p.left != null) {
        return max(p.left);
    }
    return node != null ? node.value : null;
}

找后继

public Object successor(int key) {
    BSTNode p = root;
    BSTNode node = null;
    while (p != null) {
        if (key < p.key) {
            node = p;
            p = p.left;
        } else if (key > p.key) {
            p = p.right;
        } else {
            break;
        }
    }
    //没找到节点
    if (p == null) {
        return null;
    }
    if (p.right != null) {
        return min(p.right);
    }
    return node != null ? node.value : null;
}

根据关键字删除

public BSTNode delete(int key) {
    BSTNode p = root;
    BSTNode parent = null;
    while (p != null) {
        if (key < p.key) {
            parent = p;
            p = p.left;
        } else if (key > p.key) {
            parent = p;
            p = p.right;
        } else {
            break;
        }
    }
    if (p == null) {
        return null;
    }
    //执行删除操作
    if (p.left == null) {
        //情况1：左孩子空，右孩子非空
        //情况3：被删除节点左右孩子为空，已经涵盖在内
        shift(parent, p, p.right);
    }
    if (p.right == null) {
        //情况2：左孩子非空，右孩子空
        shift(parent, p, p.left);
    } else {
        //情况4：左右孩子都有
        //4.1被删除节点的后继结点
        BSTNode s = p.right;
        BSTNode sParent = p;
        while (s.left != null) {
            sParent = s;
            s = s.left;
        }
        //4.2处理后继节点后事
        if (sParent != p) {
            //不相邻
            shift(sParent, s, s.right);
            s.right = p.right;
        }
        //4.3后继取代被删除节点
        shift(parent,p,s);
        s.left = p.left;
    }
    return p;
}

/*
 * 托孤方法
 * */
private void shift(BSTNode parent, BSTNode deleted, BSTNode child) {
    if (parent == null) {
        root = child;
    } else if (parent.left == deleted) {
        parent.left = child;
    } else {
        parent.right = child;
    }
}

范围查询

查询小于key的所有key对应的值

public List<Object> less(int key){
    ArrayList<Object> result = new ArrayList<>();
    BSTNode p = root;
    LinkedList<BSTNode> stack = new LinkedList<>();
    while(p!=null||!stack.isEmpty()){
        if(p!=null){
            stack.push(p);
            p = p.left;
        }else {
            BSTNode pop = stack.pop();
            //处理值
            if(pop.key<key){
                result.add(pop.value);
            }else {
                break;
            }
            p = pop.right;
        }
    }
    return result;
}

二叉搜索树相关练习

查找最近公共祖先节点

public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
    //如果p和q在a的两侧，说明a是p和q的最近祖先节点
    TreeNode a = root;
    while (p.val < a.val && q.val < a.val || p.val > a.val && q.val > a.val) {
        if (p.val < a.val){
            a = a.left;
        }else{
            a = a.right;
        }
    }
    return a;
}

验证二叉搜索树

static ArrayList<Integer> list = new ArrayList<>();

//验证二叉搜索树
public static boolean isBSTree(TreeNode root) {
    inOrder(list, root);
    System.out.println(list);
    for (int i = 0; i < list.size() - 1; i++) {
        if (list.get(i) > list.get(i + 1)) {
            return false;
        }
    }
    return true;
}

private static void inOrder(ArrayList<Integer> list, TreeNode root) {
    if (root == null) return;
    inOrder(list, root.left);
    list.add(root.val);
    inOrder(list, root.right);
}

范围求和

//求范围和
int sum = 0;

public int sumRange(TreeNode root, int low, int high) {
    TreeNode p = root;
    inOrder(root,low,high);
    return sum;
}

private void inOrder(TreeNode node, int low, int high) {
    if (node == null) return;
    inOrder(node.left, low, high);
    if (node.val > high) {
        return;
    }
    if (node.val > low) {
        sum += node.val;
    }
    inOrder(node.right, low, high);
}

AVL树

AVL树：自平衡二叉搜索树，任意左右子树高度差不超过1，插入和删除节点时自动平衡

构造AVL树

public class AVLTree {
    static class AVLNode {
        int key;
        Object value;
        AVLNode left;
        AVLNode right;
        int height = 1;

        public AVLNode(int key, Object value) {
            this.key = key;
            this.value = value;
        }

        public AVLNode(int key) {
            this.key = key;
        }

        public AVLNode(int key, Object value, AVLNode left, AVLNode right) {
            this.key = key;
            this.value = value;
            this.left = left;
            this.right = right;
        }

    }

    //求节点高度(处理node==null的高度)
    private int height(AVLNode node) {
        if (node == null) return 0;
        return node.height;
    }

    //更新节点高度（新增，删除，旋转）
    private void updateHeight(AVLNode node) {
        node.height = Math.max(height(node.left), height(node.right)) + 1;
    }

    //平衡因子(balance factor) = 左子树高度-右子树高度
    private int bf(AVLNode node) {
        // 0 1 -1 都是平衡的，其他值都是不平衡
        return height(node.left) - height(node.right);
    }

    //参数：要旋转的节点，返回值：新的根节点
    private AVLNode rightRotate(AVLNode red) {
        AVLNode yellow = red.left;
        AVLNode green = yellow.right;
        yellow.right = red; //上位
        red.left = green; //换爹
        updateHeight(red);
        updateHeight(yellow);
        return yellow;
    }

    private AVLNode leftRotate(AVLNode red) {
        AVLNode yellow = red.right;
        AVLNode green = yellow.left;
        yellow.left = red;
        red.right = green;
        updateHeight(red);
        updateHeight(yellow);
        return yellow;
    }

    //先左旋左子树，再右旋根节点
    private AVLNode leftRightRotate(AVLNode node) {
        node.left = leftRotate(node.left); //更新左子节点
        return rightRotate(node);
    }

    //先右旋右子树，再左旋根节点
    private AVLNode rightLeftRotate(AVLNode node) {
        node.right = rightRotate(node.right);
        return leftRotate(node);
    }

    //检查节点是否失衡，重新平衡代码
    private AVLNode balance(AVLNode node) {
        if (node == null) {
            return null;
        }
        int bf = bf(node);

        if (bf > 1 && bf(node.left) >= 0) { // LL
            return rightRotate(node);
        } else if (bf > 1 && bf(node.left) < 0) { // LR
            return leftRightRotate(node);
        } else if (bf < -1 && bf(node.right) > 0) { // RL
            return rightLeftRotate(node);
        } else if (bf < -1 && bf(node.right) <= 0) { // RR
            return leftRightRotate(node);
        }
        return node;
    }

}

新增

public void put(int key,Object value){
    root = doPut(root,key,value);
}

private AVLNode doPut(AVLNode node,int key,Object value){
    //1.找到空位，创建新节点返回
    if(node == null){
        return new AVLNode(key,value);
    }
    //2.key已经存在，直接更新
    if(key == node.key){
        node.value = value;
        return node;
    }
    //3.继续查找
    if(key<node.key){
        node.left = doPut(node.left,key,value);
    }else {
        node.right = doPut(node.right,key,value);
    }
    updateHeight(node);
    return balance(node);
}

删除

private AVLNode doRemove(AVLNode node, int key) {
    //1.node==null
    if (node == null) {
        return null;
    }
    //2.没找到key
    if (key < node.key) {
        node.left = doRemove(node.left, key);
    } else if (key > node.key) {
        node.right = doRemove(node.right, key);
    } else {
        //3.找到key 3.1没有孩子 3.2只有一个孩子 3.3有两个孩子
        if (node.left == null && node.right == null) {
            return null;
        } else if (node.left == null) {
            node = node.right;
        } else if (node.right == null) {
            node = node.left;
        } else {
            AVLNode s = node.right;
            while (s.left != null) {
                s = s.left;
            }
            //s为后继节点
            s.right = doRemove(node.right, s.key);
            s.left = node.left;
            node = s;
        }
    }

    //4.更新高度
    updateHeight(node);
    //5.balance
    return balance(node);
}

红黑树

红黑树也是一种自平衡的二叉搜索树，相比于AVL，插入和删除时旋转次数更少。

特点：
1.所有节点都有两种颜色：红和黑
2.所有null视为黑色
3.红色节点不能相邻
4.根节点是黑色
5.从根到任意一个叶子节点，路径中黑色节点数一样

【代码建议结合演示图分析】

public class RedBlackTree {
    enum Color {
        RED, BLACK;
    }

    private Node root;

    private static class Node {
        int key;
        Object value;
        Node left;
        Node right;
        Node parent; //父节点
        Color color = RED; //新节点默认红色

        //是否是左孩子
        boolean isLeftChild() {
            return parent != null && parent.left == this;
        }

        //叔叔
        Node uncle() {
            if (parent == null || parent.parent == null) {
                return null;
            }
            if (parent.isLeftChild()) {
                return parent.parent.right;
            } else {
                return parent.parent.left;
            }
        }

        //兄弟
        Node sibling() {
            if (parent == null) {
                return null;
            }
            if (this.isLeftChild()) {
                return parent.right;
            } else {
                return parent.left;
            }
        }
    }

    //判断红黑
    boolean isRed(Node node) {
        return node != null && node.color == RED;
    }

    boolean isBlack(Node node) {
        return node == null || node.color == BLACK;
    }

    //右旋 1.parent的处理 2.旋转后新根的父子关系
    private void rightRotate(Node pink) {
        Node parent = pink.parent;
        Node yellow = pink.left;
        Node green = yellow.right;
        if (green != null) {
            green.parent = pink;
        }
        yellow.right = pink;
        yellow.parent = parent;
        pink.left = green;
        pink.parent = yellow;
        if(parent==null){
            root = yellow;
        }else if (parent.left == pink) {
            parent.left = yellow;
        } else {
            parent.right = yellow;
        }
    }
}
BancroftLee
关注
  • 9
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【软考】数据结构 - 树结构 - 平衡二叉搜索树 （AVL树）
本本本添哥
08-11 148
AVL树是一种具有自平衡特性的二叉搜索树AVL树的名字来源于它的发明者们：G. M. Adelson-Velsky和E. M. Landis。AVL树虽然是一种自平衡的二叉搜索树，但它并不是唯一的自平衡二叉搜索树。其他常见的自平衡二叉搜索树，还包括红黑树、Splay树等。
数据结构 --二叉搜索树
sdjn_lyn的博客
02-26 951
二叉搜索树 二叉搜索树定义 二叉搜索树也称为二叉查找树、二叉排序树，是一种插入、删除、查找操作性能都不错的数据结构 二叉搜索树首先还是一棵二叉树，但是这个二叉树有一些特点：对于树中的每个结点， 如果左子树存在，那么左子树中所有结点的值都小于该结点的值 如果右子树存在，那么右子树中所有结点的值都大于该结点的值 树中没有值相等的结点 下图就是一棵二叉搜索树，可见满足上述二叉搜索树的特点 二叉搜索...
算法与数据结构--二叉搜索树与自平衡二叉搜索树
bjjx123456的博客
12-25 686
二叉搜索树作为一种经典的数据结构，它既有链表的快速插入与删除操作的特点，又有数组快速查找的优势；所以应用十分广泛，例如在文件系统和数据库系统一般会采用这种数据结构进行高效率的排序与检索操作。根据插入元素的落点，调整策略分为四种情况，插入元素落入以下4个子树的情况分别对应着四种状态。注：字典的 "member运算" 指的是检查字典中是否存在某个特定的键的操作，即查询操作。A连接左子树的右子树，A称为B的右子树。注：上图的沿路径回溯检查指的是沿插入路径回溯检查。这时候对根结点使用左旋操作。
数据结构--二叉搜索树
weixin_66905164的博客
05-22 1328
二叉搜索树的概念；二叉树的实现；结点类；函数接口总览；实现二叉树；二叉搜索树的应用；K模型；KV模型；二叉搜索树的性能分析
【数据结构】二叉搜索树/搜索二叉树(C++实现)
Brant_zero的博客
11-05 2159
二叉搜索树的概念、二叉搜索树的实现，二叉搜索树的插入、二叉搜索树的删除、二叉搜索树的查找、二叉搜索树性能分析，二叉搜索树key模型、二叉搜索树key-value模型
【二叉树进阶】红黑树（Red Black Tree） - 平衡二叉搜索树
codewinter的博客
06-21 3161
红黑树，是一种平衡二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是 Red 或 Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出2倍，因而是接近平衡的。AVL树和红黑树：红黑树更多是一种折中的选择，它舍弃平衡二叉树的严格平衡，换取节点插入时尽可能少的调整。因为红黑树的旋转情况少于AVL树，使得红黑树整体性能略优于AVL树，不然map和set底层怎么会用红黑树呢，包括很多语言的库里面都用了红黑树。如果发明AVL树的人是天才的话，那么发明红
二叉搜索树、AVL树、红黑树详解
weixin_44783506的博客
08-25 603
AVL树 + 红黑树 详细介绍
数据结构（Python实现）------二叉搜索树
Avery123123的博客
01-03 1076
数据结构（Python实现）------ 二叉搜索树数据结构（Python实现）------二叉搜索树二叉搜索树简介基本概念Python实现验证二叉搜索树二叉搜索树迭代器 数据结构（Python实现）------二叉搜索树 二叉搜索树简介 基本概念 这篇文章之后，我们提供了一个习题来让你验证一个树是否是二叉搜索树。 你可以运用我们上述提到的性质来判断。 前一章介绍的递归思想也可能会对你解决这个...
详解二叉搜索树 --- key模型和key/value模型
阿润菜菜的博客
04-17 1686
带你学习二叉搜索树 --- key模型和key/value模型
数据结构-二叉搜索树
m0_61433144的博客
08-07 1656
二叉搜索树也称二叉排序树或者二叉查找树，它是在普通二叉树上加入一些特性所形成的： 1，若左子树非空，则左子树上所有结点的值均小于根结点的值。 2，若右子树非空，则右子树上所有结点的值均大于根结点的值。 3，其左右子树也分别是一棵二叉搜索树。......
基于C语言的数据结构-二叉搜索树bitTree
06-25
为了保持较好的性能，可以使用自平衡的二叉搜索树，如AVL树或红黑树，它们通过旋转操作保持树的平衡。 在"基于C语言的数据结构-二叉搜索树bitTree"这个压缩包中，可能包含了实现上述操作的源代码示例。学习这些代码...
二叉搜索树，红黑树，AVL平衡树，B树
05-08
二叉搜索树（Binary Search Tree，BST）是一种特殊的二叉树数据结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的指针和一个指向右子树的指针。在二叉搜索树中，对于任意节点： 1. 所有左...
数据结构实验--基于二叉排序树的商品查询系统
10-16
为了解决这个问题，可以使用自平衡二叉搜索树，如AVL树或红黑树。但在这个实验中，可能没有涉及自平衡二叉树，而是专注于基础的二叉排序树操作。 在调试过程中，需要对各种操作进行测试，确保它们都能正确地在二叉...
BST.rar_bst_二叉搜索树_数据结构动画_树 动画
09-23
为了解决这个问题，出现了自平衡二叉搜索树，如AVL树和红黑树，它们通过旋转操作确保树的高度保持在log(n)级别。 6. 应用场景：二叉搜索树广泛应用于数据库索引、文件系统、缓存系统等领域，因其快速查找、插入和...
二叉树-基于C++实现的二叉搜索树.zip
04-26
为了解决这个问题，可以使用自平衡二叉搜索树，如AVL树或红黑树。这些树在插入和删除节点时会自动进行旋转操作，以保持大致的平衡状态，从而确保操作的时间复杂度接近于O(log n)。 总之，二叉搜索树是一种重要的...
数据结构（初阶3.单链表）
最新发布
2401_83968713的博客
07-14 499
一、单链表1.1概念与结构1.2结点1.3链表的性质1.4链表的打印二、实现单链表SList.hSList.c申请新节点尾插头插尾删头删在指定位置之前插入数据在指定位置之后插入数据删除指定位置结点删除指定位置之后的结点销毁结点test.c。
数据结构【顺序表】
qq_67578580的博客
07-12 1209
我们需要创建一个seqlist.h头文件，seqlist.c文件存放函数，还有一个.c的测试文件。
数据结构之顺序表
m0_73634434的博客
07-10 430
线性表(List)由零个或多个数据组成的有限数列，线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表，链表，栈，队列，字符串。
数据结构和算法（0-1）----递归
yanminghe66666的博客
07-09 619
递归算法，爬楼梯等解法

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值