数据结构之平衡二叉树（AVL）

最新推荐文章于 2024-08-15 11:54:06 发布
最新推荐文章于 2024-08-15 11:54:06 发布
阅读量91 收藏
点赞数
文章标签： 二叉树 数据结构 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangshuo2020/article/details/116493931
版权

一、基础知识
在这里插入图片描述
二、AVL树高度求解

package com.ws.数据结构.树.平衡二叉树AVL.创建与高度;

public class AVLTree {
    public static void main(String[] args) {
        int[] arr={4,3,6,5,7,8};
        //创建平衡二叉树对象
        AVL avl=new AVL();
        //添加节点
        for (int i=0;i<arr.length;i++){
            avl.add(new Node(arr[i]));
        }
        //遍历平衡二叉树
        System.out.println("遍历平衡二叉树");
        avl.zhongprintf();

        System.out.println("没有旋转之前");
        System.out.println("树的高度="+avl.getRoot().height());
        System.out.println("左子树的高度="+avl.getRoot().zuoHeight());
        System.out.println("右子树的高度="+avl.getRoot().youHeight());

    }
}
//创建节点
class Node{
    int value;
    Node zuo;
    Node you;

    public Node(int value) {
        this.value = value;
    }

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

    //添加节点
    //递归形式添加平衡二叉排序树
    public void add(Node node){
        if (node==null){
            return;
        }
        //判断传入节点值和子树的根节点的值的关系
        if (node.value<this.value){
            //小于  当前树左子节点为空，就直接挂上
            if (this.zuo==null){
                this.zuo=node;
            }else {
                //递归左子树添加
                this.zuo.add(node);
            }
        }else {
            //大于 当前右子节点为空，就直接挂上
            if (this.you==null){
                this.you=node;
            }else {
                //递归向右子树添加
                this.you.add(node);
            }
        }
    }

    //中序遍历
    public void zhongprintf(){
        if (this.zuo!=null){
            this.zuo.zhongprintf();
        }
        System.out.println(this);
        if (this.you!=null){
            this.you.zhongprintf();
        }
    }

    //返回当前节点的高度 以该节点为根节点的树的高度
    public int height(){
        return Math.max(zuo==null?0:zuo.height(),you==null?0:you.height())+1;
    }

    //返回左子树的额高度
    public int zuoHeight(){
        if (zuo==null){
            return 0;
        }
        return zuo.height();
    }

    //返回右子树的高度
    public int youHeight(){
        if (you==null){
            return 0;
        }
        return you.height();
    }
}
//创建AVL树
class AVL{
    private Node root;

    public Node getRoot() {
        return root;
    }

    //添加节点方法
    public void add(Node node){
        //根节点是空，就直接添加
        if (root==null){
            root=node;
        }else {
            root.add(node);
        }
    }

    //中序遍历
    public void zhongprintf(){
        if (root!=null){
            root.zhongprintf();
        }else {
            System.out.println("当前平衡二叉树为空，不能遍历");
        }
    }
}
遍历平衡二叉树
Node{value=3}
Node{value=4}
Node{value=5}
Node{value=6}
Node{value=7}
Node{value=8}
没有旋转之前
树的高度=4
左子树的高度=1
右子树的高度=3

三、AVL树左旋转
在这里插入图片描述

package com.ws.数据结构.树.平衡二叉树AVL.左旋转;

public class AVLTree {
    public static void main(String[] args) {
        int[] arr={4,3,6,5,7,8};
        //创建平衡二叉树对象
        AVL avl=new AVL();
        //添加节点
        for (int i=0;i<arr.length;i++){
            avl.add(new Node(arr[i]));
        }
        //遍历平衡二叉树
        System.out.println("遍历平衡二叉树");
        avl.zhongprintf();

        System.out.println("旋转之后");
        System.out.println("树的高度="+avl.getRoot().height());//4
        System.out.println("左子树的高度="+avl.getRoot().zuoHeight());//1
        System.out.println("右子树的高度="+avl.getRoot().youHeight());//3


    }
}

//创建节点
class Node{
    int value;
    Node zuo;
    Node you;

    public Node(int value) {
        this.value = value;
    }

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

    //添加节点
    //递归形式添加平衡二叉排序树
    public void add(Node node){
        if (node==null){
            return;
        }
        //判断传入节点值和子树的根节点的值的关系
        if (node.value<this.value){
            //小于  当前树左子节点为空，就直接挂上
            if (this.zuo==null){
                this.zuo=node;
            }else {
                //递归左子树添加
                this.zuo.add(node);
            }
        }else {
            //大于 当前右子节点为空，就直接挂上
            if (this.you==null){
                this.you=node;
            }else {
                //递归向右子树添加
                this.you.add(node);
            }
        }

        //当添加完节点后，如果（右子树的高度-左子树的高度）>1就进行旋转（左旋转）（avl树的特点）
        if (youHeight()-zuoHeight()>1){
            zuoRotate();//左旋转
        }
    }

    //中序遍历
    public void zhongprintf(){
        if (this.zuo!=null){
            this.zuo.zhongprintf();
        }
        System.out.println(this);
        if (this.you!=null){
            this.you.zhongprintf();
        }
    }

    //返回当前节点的高度 以该节点为根节点的树的高度
    public int height(){
        return Math.max(zuo==null?0:zuo.height(),you==null?0:you.height())+1;
    }

    //返回左子树的额高度
    public int zuoHeight(){
        if (zuo==null){
            return 0;
        }
        return zuo.height();
    }

    //返回右子树的高度
    public int youHeight(){
        if (you==null){
            return 0;
        }
        return you.height();
    }

    //左旋转
    private void zuoRotate(){
        //创建新的节点，值是当前节点
        Node newNode=new Node(value);
        //把新的节点的左子树设置成当前节点的左子树
        newNode.zuo=zuo;
        //把新节点的右子树设置成当前节点的右子树的左子树
        newNode.you=you.zuo;
        //把当前节点的值换成右子树的值
        value=you.value;
        //把当前节点的右子树设置成当前节点的右子树的右子树
        you=you.you;
        //把当前节点的左子节点设置成新的节点
        zuo=newNode;
    }
}

//创建AVL树
class AVL{
    private Node root;

    public Node getRoot() {
        return root;
    }

    //添加节点方法
    public void add(Node node){
        //根节点是空，就直接添加
        if (root==null){
            root=node;
        }else {
            root.add(node);
        }
    }

    //中序遍历
    public void zhongprintf(){
        if (root!=null){
            root.zhongprintf();
        }else {
            System.out.println("当前平衡二叉树为空，不能遍历");
        }
    }
}
遍历平衡二叉树
Node{value=3}
Node{value=4}
Node{value=5}
Node{value=6}
Node{value=7}
Node{value=8}
旋转之后
树的高度=3
左子树的高度=2
右子树的高度=2

四、AVL树右旋转
在这里插入图片描述

package com.ws.数据结构.树.平衡二叉树AVL.右旋转;

public class AVLTree {
    public static void main(String[] args) {
        //int[] arr={4,3,6,5,7,8};
        int[] arr={10,12,8,9,7,6};
        //创建平衡二叉树对象
        AVL avl=new AVL();
        //添加节点
        for (int i=0;i<arr.length;i++){
            avl.add(new Node(arr[i]));
        }
        //遍历平衡二叉树
        System.out.println("遍历平衡二叉树");
        avl.zhongprintf();

        System.out.println("旋转之后");
        System.out.println("树的高度="+avl.getRoot().height());//4
        System.out.println("左子树的高度="+avl.getRoot().zuoHeight());//3
        System.out.println("右子树的高度="+avl.getRoot().youHeight());//1
        System.out.println("当前根节点="+avl.getRoot());//8


    }
}

//创建节点
class Node{
    int value;
    Node zuo;
    Node you;

    public Node(int value) {
        this.value = value;
    }

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

    //添加节点
    //递归形式添加平衡二叉排序树
    public void add(Node node){
        if (node==null){
            return;
        }
        //判断传入节点值和子树的根节点的值的关系
        if (node.value<this.value){
            //小于  当前树左子节点为空，就直接挂上
            if (this.zuo==null){
                this.zuo=node;
            }else {
                //递归左子树添加
                this.zuo.add(node);
            }
        }else {
            //大于 当前右子节点为空，就直接挂上
            if (this.you==null){
                this.you=node;
            }else {
                //递归向右子树添加
                this.you.add(node);
            }
        }

        //当添加完节点后，如果（右子树的高度-左子树的高度）>1就进行旋转（左旋转）（avl树的特点）
        if (youHeight()-zuoHeight()>1){
            zuoRotate();//左旋转
        }

        //当添加完一个节点后（左子树高度-右子树高度）>1就进行右旋转
        if (zuoHeight()-youHeight()>1){
            youRotate();//右旋转
        }
    }

    //中序遍历
    public void zhongprintf(){
        if (this.zuo!=null){
            this.zuo.zhongprintf();
        }
        System.out.println(this);
        if (this.you!=null){
            this.you.zhongprintf();
        }
    }

    //返回当前节点的高度 以该节点为根节点的树的高度
    public int height(){
        return Math.max(zuo==null?0:zuo.height(),you==null?0:you.height())+1;
    }

    //返回左子树的额高度
    public int zuoHeight(){
        if (zuo==null){
            return 0;
        }
        return zuo.height();
    }

    //返回右子树的高度
    public int youHeight(){
        if (you==null){
            return 0;
        }
        return you.height();
    }

    //左旋转
    private void zuoRotate(){
        //创建新的节点，值是当前节点
        Node newNode=new Node(value);
        //把新的节点的左子树设置成当前节点的左子树
        newNode.zuo=zuo;
        //把新节点的右子树设置成当前节点的右子树的左子树
        newNode.you=you.zuo;
        //把当前节点的值换成右子树的值
        value=you.value;
        //把当前节点的右子树设置成当前节点的右子树的右子树
        you=you.you;
        //把当前节点的左子节点设置成新的节点
        zuo=newNode;
    }

    //右旋转
    private void youRotate(){
        //创建新的节点，值是当前节点
        Node newNode=new Node(value);
        //把新节点的右子树设置成当前节点的右子树
        newNode.you=you;
        //把新节点的左子节点指向当前节点的左子节点的右子节点
        newNode.zuo=zuo.you;
        //把当前节点的值改成左子节点的值
        value=zuo.value;
        //把当前节点的左子节点指向左子节点的左子节点
        zuo=zuo.zuo;
        //当前节点的右子节点指向新节点
        you=newNode;
    }

}

//创建AVL树
class AVL{
    private Node root;

    public Node getRoot() {
        return root;
    }

    //添加节点方法
    public void add(Node node){
        //根节点是空，就直接添加
        if (root==null){
            root=node;
        }else {
            root.add(node);
        }
    }

    //中序遍历
    public void zhongprintf(){
        if (root!=null){
            root.zhongprintf();
        }else {
            System.out.println("当前平衡二叉树为空，不能遍历");
        }
    }
}
遍历平衡二叉树
Node{value=6}
Node{value=7}
Node{value=8}
Node{value=9}
Node{value=10}
Node{value=12}
旋转之后
树的高度=3
左子树的高度=2
右子树的高度=2
当前根节点=Node{value=8}

五、AVL树双旋转
在这里插入图片描述

package com.ws.数据结构.树.平衡二叉树AVL.双旋转;

public class AVLTree {
    public static void main(String[] args) {
        //int[] arr={4,3,6,5,7,8};
        int[] arr={10,12,8,9,7,6};
        //创建平衡二叉树对象
        AVL avl=new AVL();
        //添加节点
        for (int i=0;i<arr.length;i++){
            avl.add(new Node(arr[i]));
        }
        //遍历平衡二叉树
        System.out.println("遍历平衡二叉树");
        avl.zhongprintf();

        System.out.println("旋转之后");
        System.out.println("树的高度="+avl.getRoot().height());//4
        System.out.println("左子树的高度="+avl.getRoot().zuoHeight());//3
        System.out.println("右子树的高度="+avl.getRoot().youHeight());//1
        System.out.println("当前根节点="+avl.getRoot());//8


    }
}

//创建节点
class Node{
    int value;
    Node zuo;
    Node you;

    public Node(int value) {
        this.value = value;
    }

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

    //添加节点
    //递归形式添加平衡二叉排序树
    public void add(Node node){
        if (node==null){
            return;
        }
        //判断传入节点值和子树的根节点的值的关系
        if (node.value<this.value){
            //小于  当前树左子节点为空，就直接挂上
            if (this.zuo==null){
                this.zuo=node;
            }else {
                //递归左子树添加
                this.zuo.add(node);
            }
        }else {
            //大于 当前右子节点为空，就直接挂上
            if (this.you==null){
                this.you=node;
            }else {
                //递归向右子树添加
                this.you.add(node);
            }
        }

        //当添加完节点后，如果（右子树的高度-左子树的高度）>1就进行旋转（左旋转）（avl树的特点）
        if (youHeight()-zuoHeight()>1){
            //如果它的右子树的左子树的高度大于他的右子树的右子树的高度
            if (you!=null&&you.zuoHeight()>you.youHeight()){
                //先进行对右子节点右旋转
                you.youRotate();
                // 再对当前节点进行左旋转
                zuoRotate();
            }else {
                //直接进行左旋转
                zuoRotate();//左旋转
            }
            return;//平衡后立马返回，要不会进入下一个if
        }

        //当添加完一个节点后（左子树高度-右子树高度）>1就进行右旋转
        if (zuoHeight()-youHeight()>1){
            //如果他左子树的右子树的高度大于他左子树的高度
            if (zuo!=null&&zuo.you.youHeight()>zuo.zuoHeight()){
                //先对左子树左旋转
                zuo.zuoRotate();
                //再对当前节点进行右旋转
                youRotate();
            }else {
                //直接进行右旋转即可
                youRotate();//右旋转
            }
        }
    }

    //中序遍历
    public void zhongprintf(){
        if (this.zuo!=null){
            this.zuo.zhongprintf();
        }
        System.out.println(this);
        if (this.you!=null){
            this.you.zhongprintf();
        }
    }

    //返回当前节点的高度 以该节点为根节点的树的高度
    public int height(){
        return Math.max(zuo==null?0:zuo.height(),you==null?0:you.height())+1;
    }

    //返回左子树的额高度
    public int zuoHeight(){
        if (zuo==null){
            return 0;
        }
        return zuo.height();
    }

    //返回右子树的高度
    public int youHeight(){
        if (you==null){
            return 0;
        }
        return you.height();
    }

    //左旋转
    private void zuoRotate(){
        //创建新的节点，值是当前节点
        Node newNode=new Node(value);
        //把新的节点的左子树设置成当前节点的左子树
        newNode.zuo=zuo;
        //把新节点的右子树设置成当前节点的右子树的左子树
        newNode.you=you.zuo;
        //把当前节点的值换成右子树的值
        value=you.value;
        //把当前节点的右子树设置成当前节点的右子树的右子树
        you=you.you;
        //把当前节点的左子节点设置成新的节点
        zuo=newNode;
    }

    //右旋转
    private void youRotate(){
        //创建新的节点，值是当前节点
        Node newNode=new Node(value);
        //把新节点的右子树设置成当前节点的右子树
        newNode.you=you;
        //把新节点的左子节点指向当前节点的左子节点的右子节点
        newNode.zuo=zuo.you;
        //把当前节点的值改成左子节点的值
        value=zuo.value;
        //把当前节点的左子节点指向左子节点的左子节点
        zuo=zuo.zuo;
        //当前节点的右子节点指向新节点
        you=newNode;
    }

}

//创建AVL树
class AVL{
    private Node root;

    public Node getRoot() {
        return root;
    }

    //添加节点方法
    public void add(Node node){
        //根节点是空，就直接添加
        if (root==null){
            root=node;
        }else {
            root.add(node);
        }
    }

    //中序遍历
    public void zhongprintf(){
        if (root!=null){
            root.zhongprintf();
        }else {
            System.out.println("当前平衡二叉树为空，不能遍历");
        }
    }
}
遍历平衡二叉树
Node{value=6}
Node{value=7}
Node{value=8}
Node{value=9}
Node{value=10}
Node{value=12}
旋转之后
树的高度=3
左子树的高度=2
右子树的高度=2
当前根节点=Node{value=8}
wangshuo（24考研上岸版）
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【数据结构】AVL树——平衡二叉排序树（C语言）
moX980的博客
07-24 405
AVL树——平衡二叉排序树性质调整操作AVL树-左旋AVL树右旋失衡类型LL/RRLR/RL代码演示 性质 当一棵普通的二叉排序树是右边这个样子，树–>链表 那么二叉树的查找效率就由O(logn)退化成了O(n) 右边的树是不平衡的，下面介绍一种平衡二叉排序树——AVL树 AVL树的平衡条件：节点左右子树的高度差<=1 上述条件保证树不会退化成链表 高度h的BS树节点个数 h<=n<=2h-1 高度为h的AVL树节点个数1.5h<=n<=2h-1 low(h) =
数据结构与算法(十四)平衡二叉树(AVL树)
SunSatan的博客
05-12 313
二叉排序树在使用时可能会出现极端的左或右斜树的现象，导致算法效率大大降低，这称为二叉排序树的不平衡。 而我们在使用的时候，总是希望二叉排序树是平衡的，使算法的效率最大化，所以就有了平衡二叉树(AVL树)。 1、平衡二叉树(AVL树) 从平衡二叉树的英文名字，你也可以体会到，它是一种高度平衡的二叉排序树，那什么叫做高度平衡呢？意思是说，要么它是一棵空树，要么它的左子树和右子树都是平衡二叉树...
数据结构篇——平衡二叉树（AVL树）
CZC1999的博客
11-06 368
引入 上一篇写了二叉排序树，构建一个二叉排序树，如果构建序列是完全有序的，则会出现这样的情况： 显然这种情况会使得二叉搜索树退化成链表。当出现这样的情况，二叉排序树的查找也就退化成了线性查找，所以我们需要合理调整二叉排序树的形态，使得树上的每个结点都尽量有两个子结点，这样整个二叉树的高度就会大约在\(log(n)\) 左右，其中 \(n\) 为结点个数。 基本性质 ​ AVL树也称为...
数据结构-平衡二叉树(AVL树)
理科男同学
11-15 2552
目录 1，平衡二叉树的介绍 1.1，二叉排序树存在的问题 1.2，平衡二叉树 1.3，平衡二叉树的创建 1.4，平衡二叉树的查找 2，代码实现 2.1，平衡二叉树的节点类型 2.2，LL旋转（单右旋转） 2.3，RR旋转（单左旋转） 2.4，向avl树中添加一个节点 2.5，求左右子树的高度 2.6，求平衡二叉树的高度 2.7，中序遍历二叉树 2.8，创建一颗平衡二叉树 3，测试代码 1，平衡二叉树的介绍 1.1，二叉排序树存在的问题 在介绍平衡二叉树之前，我们先来看看.
数据结构之平衡二叉树C语言版
Cukor丘克的博客
04-16 4582
作者：Cukor Zhong 什么是平衡二叉树 平衡二叉树是具有平衡属性的有序二叉树，所谓的平衡即当前树的左右子树高度差的绝对值不超过1。因为平衡二叉树是由苏联数学家Adelson-Velskii和Landis提出，所以又称为AVL树。 平衡二叉树的基本特点 是特殊的有序二叉树 左右子树高度差的绝对值不超过1 左右子树仍然是平衡二叉树
数据结构——平衡二叉树(AVL树)之插入
weixin_57023347的博客
06-17 7378
文章目录前言一.定义二.基本操作1.查找，删除2.插入(如何调整)如何调整代码实现插入 前言 首先我们来思考一下一个普通二叉树保存数据，如果想查找一个数据，由于普通二叉树保存数据是随机的，要找到数据的时间复杂度为O(n)。后面为了方便 ，我们又学习二叉搜索树，它的定义是将比根节点小的数放左边，比根节点大的数放右边，并且每一课子树都是二叉搜索树这样使得数据在树上存储有一定 的规律，在一定情况下查找起来很方便。但是，二叉搜索数当给出数据的顺序不同时，二叉搜索树也会不同。比如如果给出的序列为{1，2，3，4，5}
【数据结构】平衡二叉树
Jacky_Feng的博客
01-04 2411
本文主要介绍了平衡二叉树的基本概念及基础操作（查找、平衡、插入、删除）。
数据结构：平衡二叉树
梁辰兴的博客
09-17 455
平衡二叉树（Balanced Binary Tree）是一种特殊的二叉树，它满足任意一个节点的左子树和右子树的高度差不超过1。平衡二叉树的主要优势在于其能够保持较低的树高，从而在插入、删除和查找操作中保持较好的性能。简介平衡二叉树是一种自我平衡的二叉搜索树，它的左子树和右子树的高度差不超过1。平衡二叉树的基本操作包括插入、删除和查找，这些操作的时间复杂度均为O(log n)，其中n为树中节点的数量。平衡二叉树的主要应用场景包括计算机科学、数据结构和算法等领域。图示50/ \30 70。
Java数据结构——平衡二叉树(AVL树)
m0_62969222的博客
05-31 3259
AVL树的引入 搜索二叉树有着极高的搜索效率，但是搜索二叉树会出现以下极端情况： 这样的二叉树搜索效率甚至比链表还低。在搜索二叉树基础上出现的平衡二叉树(AVL树)就解决了这样的问题。当平衡二叉树(AVL树)的某个节点左右子树高度差的绝对值大于1时，就会通过旋转操作减小它们的高度差。 基本概念 AVL树本质上还是一棵二叉搜索树，它的特点是： 本身首先是一棵二叉搜索树。 每个结点的左右子树的高度之差的绝对值（平衡因子）最多为1。也就是说，AVL树，本质上是带了平衡功能的二叉查找树（二叉排序树，二叉搜索树）
数据结构——平衡二叉树之删除
weixin_57023347的博客
07-08 9627
目录 前言 删除结点 调整结点 代码实现 前言 我们知道，在平衡二叉树中插入一个结点可能会改变二叉树的平衡因子，使得平衡因子超过1。但是删除平衡二叉树的一个结点时也会使得二叉树的平衡因子发生改变。也会需要对树进行调整。这篇博客是说明怎么判断调整位置。想了解调整的具体细节的可以看博客数据结构——平衡二叉树(AVL树)之插入。 平衡二叉树删除结点和插入操作类似，首先先删除一个结点，然后对自下向上最近的平衡因子超过1的结点进行调整。 删除结点 首先...
C语言数据结构之平衡二叉树（AVL树）实现方法示例
08-28
C语言数据结构之平衡二叉树（AVL树）实现方法示例 本文将详细介绍C语言数据结构之平衡二叉树（AVL树）实现方法，并结合实例形式分析了C语言平衡二叉树的相关定义与使用技巧。 知识点一：AVL树的定义 AVL树是一种...
广工数据结构实验——平衡二叉树
07-06
在这个实验中，`平衡二叉树数据结构实验.cpp`很可能是实现平衡二叉树（可能是AVL树或红黑树）的C++源代码。它可能包含了基本的二叉树操作（如插入、删除和查找）以及平衡调整算法的实现。源代码可以帮助我们理解如何...
03平衡二叉树_AVLTree.rar_03平衡二叉树_AVLTree_大话数据结构_平衡二叉树
09-21
在数据结构的学习中，理解并掌握AVL树的概念、特性以及操作是至关重要的。 平衡二叉树的概念： 平衡二叉树的主要目标是解决普通二叉搜索树可能产生的高度不平衡问题，以提高查找、插入和删除操作的效率。在AVL树中...
数据结构之平衡二叉树的递归实现
12-05
平衡二叉树（AVL树）是数据结构中的一个重要概念，它是一种自平衡的二叉搜索树，确保了任何节点的两个子树的高度差不超过1。这使得AVL树在查找、插入和删除操作上具有较高的效率。本文将深入探讨平衡二叉树的递归...
【数据结构-前缀哈希】力扣1124. 表现良好的最长时间段
sjsjs11的博客
08-14 366
表现良好的时间段”有两种情况，一种是当前的sum能在哈希表中匹配到sum - 1时（如果是匹配sum的话，这个子段是「劳累的天数」等于「不劳累的天数」。这一题前缀+哈希并不是空间最优，最优空间是使用贪心+栈的做法，虽然空间复杂度都是O(n)，但是实际的空间使用可能高于 O(n)，因为当哈希表需要扩展时，会预留更多的空间以减少哈希冲突。所谓「表现良好的时间段」，意味在这段时间内，「劳累的天数」是严格 大于「不劳累的天数」。输入：hours = [9,9,6,0,6,6,9]
C语言实现排序之快速排序算法
2403_83044722的博客
08-14 392
快速排序（Quick Sort）是一种非常高效且实用的排序算法，它采用分治法（Divide and Conquer）的思想来完成排序。
【数据结构】二叉树篇
2303_79015671的博客
08-14 1196
深入解析数据结构二叉树
数据结构——时间复杂度和空间复杂度
最新发布
2301_80373479的博客
08-15 812
带你了解时间复杂度和空间复杂度
【数据结构】算法复杂度
L286594的博客
08-13 1201
实际中我们计算时间复杂度时，计算的也不是程序的精确的执⾏次数，精确执⾏次数计算起来还是很⿇烦的(不同的⼀句程序代码，编译出的指令条数都是不⼀样的)，计算出精确的执⾏次数意义也不⼤，因为我们计算时间复杂度只是想⽐较算法程序的增⻓量级，也就是当N不断变⼤时T(N)的差别，上⾯我们已经看到了当N不断变⼤时常数和低阶项对结果的影响很⼩，所以我们。通过对复杂度的分析，可以选择更高效的算法，提高程序的执行效率，并在处理大规模问题时提供良好的扩展性和可维护性。随着数据量的增长，算法的空间消耗也会相应增加。
刘汝佳讲解：高级数据结构之平衡二叉树与AVL树
"刘汝佳 高级数据结构" 是一套专门讲解高级数据结构的教程，适合对ACM（国际大学生程序设计竞赛）感兴趣的学员学习。由ACM领域的大师刘汝佳主讲，课程涵盖了平衡二叉树、可并优先队列、线段树和树状数组基础、RMQ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值