算法训练营 查找算法（平衡二叉树）

最新推荐文章于 2024-04-30 23:53:05 发布
最新推荐文章于 2024-04-30 23:53:05 发布
阅读量670 收藏 1
点赞数
文章标签： 算法 b树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_20144897/article/details/123481006
版权

平衡二叉树

  • 二叉查找树的查找、插入、删除的时间复杂度均线性正比于二叉查找树的高度，高度越小，效率越高。
  • 最好的情况下，每次都一分为二，左右子树的节点数均为n/2，左右子树的高度也一样。

原理 AVL树

  • 平衡二叉查找树，简称平衡二叉树（AVL）
  • 平衡二叉树或为空树，或为具有以下性质的平衡二叉树：①左右子树高度差的绝对值不超过1；②左右子树也是平衡二叉树
  • 平衡二叉树除了具有适度平衡性，还具有局部性：①在单次插入、删除后，至多有O(1)处出现不平衡；②总可以在O(logn)时间内，使这O(1)处不平衡重新调整为平衡。
  • 对平衡二叉树在动态修改后出现的不平衡，只需局部（最小不平衡子树）调整平衡即可，不需要对整颗树进行调整。

调整平衡的方法

  • 调整平衡可以分为4种情况： LL型、RR型、LR型、RL型。
LL型
  • 插入新节点x后，从该节点向上找到最近的不平衡节点A，如果最近不平衡节点到新节点的路径前两个都是左子树L，就是LL型。
  • 即将节点x插入A的左子树的左子树中，A的左子树因插入新节点而高度增加，造成A的平衡因子由1增加为2，失去平衡。需要进行LL旋转（顺时针）调整平衡。
  • LL旋转：A顺时针旋转到B的右子树，B原来的右子树T_{3}被抛弃，A旋转后正好左子树空闲，将这个被抛弃的子树 T 3 T_{3} T3​放到A的左子树中即可。
  • 旋转之后，A、B两个节点的左右子树高度之差均为0，满足平衡条件，C的左右子树未变，仍然平衡。
AVLTree LL_Rotation(AVLTree &T)//LL旋转
{
    AVLTree temp=T->lchild;
    T->lchild=temp->rchild;
    temp->rchild=T;
    updateHeight(T);//更新高度
    updateHeight(temp);
    return temp;
}
RR型
  • 插入新节点x后，从该节点向上找到最近不平衡节点A，如果最近不平衡节点到新节点的路径前两个都是右子树R，就是RR型。需要进行RR旋转（逆时针）调整平衡。
  • RR旋转：A逆时针旋转到B的左子树，B原来的左子树T_{2}被抛弃，A旋转后正好右子树空闲，将这个被抛弃的子树 T 2 T_{2} T2​放到A右子树中即可。
  • 旋转之后，A、B两个节点的左右子树高度之差均为0，满足平衡条件，C的左右子树未变，仍然平衡。
AVLTree RR_Rotation(AVLTree &T)//RR旋转
{
    AVLTree temp=T->rchild;
    T->rchild=temp->lchild;
    temp->lchild=T;
    updateHeight(T);//更新高度
    updateHeight(temp);
    return temp;
}
LR型
  • 插入新节点x后，从该节点向上找到最近不平衡节点A，如果最近不平衡节点到新节点的路径前两个依次是左子树L、右子树R，就是LR型。
  • LR旋转：分两次旋转。C逆时针旋转到A、B之间，C原来的左子树 T 2 T_{2} T2​被抛弃，B正好右子树空闲，将这个被抛弃的子树 T 2 T_{2} T2​放到B右子树中；这时已经转变为LL型，进行LL旋转即可，实际上也可以看作C固定不动，B进行RR旋转，然后进行LL旋转。
  • 旋转之后，A、B两个节点的左右子树高度之差均为0，满足平衡条件，C的左右子树未变，仍然平衡。
AVLTree LR_Rotation(AVLTree &T)//LR旋转
{
     T->lchild=RR_Rotation(T->lchild);
     return LL_Rotation(T);
}
RL型
  • 插入新节点x后，从该节点向上找到最近不平衡节点A，如果最近不平衡节点到新节点的路径前两个依次是右子树R、左子树L，就是RL型。
  • RL旋转：分两次旋转。C顺时针旋转到A、B之间，C原来的右子树 T 3 T_{3} T3​被抛弃，B正好左子树空闲，这个被抛弃的子树 T 3 T_{3} T3​放到B左子树；这时已经转变为RR型，做RR旋转即可，实际上，也可以看作C固定不动，B进行LL旋转，然后进行RR旋转。
  • 旋转之后，A、B两个节点的左右子树高度之差均为0，满足平衡条件，C的左右子树未变，仍然平衡。
AVLTree RL_Rotation(AVLTree &T)//RL旋转
{
    T->rchild=LL_Rotation(T->rchild);
    return RR_Rotation(T);
}

平衡二叉树的插入

  • 在平衡二叉树中插入新的数据元素 x x x，首先要查找其插入的位置，在查找过程中，用 p p p指针记录当前节点，用 f f f指针记录 p p p的双亲。
  1. 在平衡二叉树中查找 x x x，如果查找成功，则什么也不做，返回 p p p；如果查找失败，则执行插入操作。
  2. 创建一个新节点 p p p存储 x x x，该节点的双亲为 f f f，高度为1。
  3. 从新节点子父 f f f出发，向上查找最近的不平衡节点。逐层检查各代祖先节点，如果平衡，则更新其高度，继续向上查找；如果不平衡，则判断失衡类型（沿着高度最大的子树判断，刚插入新节点的子树必然高度大），并作出相应的调整，返回p。
AVLTree Insert(AVLTree &T,int x)
{
    if(T==NULL) //如果为空，创建新结点
    {
        T=new AVLNode;
        T->lchild=T->rchild=NULL;
        T->data=x;
        T->height=1;
        return T;
     }
    if(T->data==x) return T;//查找成功，什么也不做，查找失败时才插入
    if(x<T->data)//插入到左子树
    {
        T->lchild=Insert(T->lchild,x);//注意插入后饭后结果挂接到T->lchild
        if(Height(T->lchild)-Height(T->rchild)==2)//插入后看是否平衡，如果不平衡显然是插入的那一边高度大
        {                                         //沿着高度大的那条路径判断
            if(x<T->lchild->data)//判断是LL还是LR,即插入的是lchild节点的lchild 还是rchild
                T=LL_Rotation(T);
            else
                T=LR_Rotation(T);
        }
    }
    else//插入到右子树
    {
        T->rchild=Insert(T->rchild,x);
        if(Height(T->rchild)-Height(T->lchild)==2)
        {
            if(x>T->rchild->data)
                T=RR_Rotation(T);
            else
                T=RL_Rotation(T);
        }
    }
    updateHeight(T);
    return T;
}

平衡二叉树的创建

  • 平衡二叉树的创建和二叉查找树的创建类似，只是插入操作多了调整平衡而已。可以从空树开始，按照输入关键字的顺序依次进行插入操作，最终得到一颗平衡二叉树。
  1. 初始化平衡二叉树为空树，T = NULL。
  2. 输入一个关键字x，将x插入平衡二叉树T中。
  3. 重复步骤2，直到关键字输入完毕。
AVLTree CreateAVL(AVLTree &T)
{
    int n,x;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>x;
        T=Insert(T,x);
    }
    return T;
}

平衡二叉树的删除

  • 进行删除操作时需要一直从删除节点之父向上检查，发现不平衡便立即调整，然后继续向上检查，直到树根。
  1. 在平衡二叉树中查找x，如果查找失败，则返回；如果查找成功，则执行删除操作（同二叉查找树的删除操作）。
  2. 从实际被删除节点之父g出发（当被删除节点有左右子树时，令其直接前驱（或直接后继）代替其位置，删除其之间前驱，实际被删除节点为其之间前驱（或直接后继）），向上寻找最近的不平衡节点。逐层检查各代祖先节点，如果平衡，则更新其高度，继续向上寻找；如果不平衡，则判断失衡类型（沿着高度大的子树判断），并做相应的调整。
  3. 继续向上检查，一直到树根。
AVLTree adjust(AVLTree &T)//删除结点后，需要判断是否还是平衡，如果不平衡，就要调整
{
    if(T==NULL) return NULL;
    if(Height(T->lchild)-Height(T->rchild)==2)//沿着高度大的那条路径判断
    {
        if(Height(T->lchild->lchild)>=Height(T->lchild->rchild))
            T=LL_Rotation(T);
        else
            T=LR_Rotation(T);
    }
    if(Height(T->rchild)-Height(T->lchild)==2)//沿着高度大的那条路径判断
    {
        if(Height(T->rchild->rchild)>=Height(T->rchild->lchild))
            T=RR_Rotation(T);
        else
            T=RL_Rotation(T);
    }
    updateHeight(T);
    return T;
}

AVLTree Delete(AVLTree &T,int x)
{
    if(T==NULL) return NULL;
    if(T->data==x)//如果找到删除节点
    {
        if(T->rchild==NULL)//如果该节点的右孩子为NULL,那么直接删除
        {
            AVLTree temp=T;
            T=T->lchild;
            delete temp;
        }
        else//否则，将其右子树的最左孩子作为这个节点，并且递归删除这个节点的值
        {
           AVLTree temp;
           temp=T->rchild;
           while(temp->lchild)
              temp=temp->lchild;
           T->data=temp->data;
           T->rchild=Delete(T->rchild,T->data);
           updateHeight(T);
        }
        return T;
    }

    if(T->data>x)//调节删除节点后可能涉及的节点
        T->lchild=Delete(T->lchild,x);
    if(T->data<x)
        T->rchild=Delete(T->rchild,x);
    updateHeight(T);
	T=adjust(T);
    return T;
}

整体算法实现

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

typedef struct AVLNode{
   int data;
   int height;
   struct AVLNode *lchild;
   struct AVLNode *rchild;
}*AVLTree;

AVLTree Empty(AVLTree &T)//删除树
{
    if(T==NULL) return NULL;
    Empty(T->lchild);
    Empty(T->rchild);
    delete T;
    return NULL;
}

inline int Height(AVLTree T)//计算高度
{
    if(T==NULL) return 0;
    return T->height;
}

void updateHeight(AVLTree &T)
{
     T->height=max(Height(T->lchild),Height(T->rchild))+1;
}

AVLTree LL_Rotation(AVLTree &T)//LL旋转
{
    AVLTree temp=T->lchild;
    T->lchild=temp->rchild;
    temp->rchild=T;
    updateHeight(T);//更新高度
    updateHeight(temp);
    return temp;
}

AVLTree RR_Rotation(AVLTree &T)//RR旋转
{
    AVLTree temp=T->rchild;
    T->rchild=temp->lchild;
    temp->lchild=T;
    updateHeight(T);//更新高度
    updateHeight(temp);
    return temp;
}

AVLTree LR_Rotation(AVLTree &T)//LR旋转
{
     T->lchild=RR_Rotation(T->lchild);
     return LL_Rotation(T);
}

AVLTree RL_Rotation(AVLTree &T)//RL旋转
{
    T->rchild=LL_Rotation(T->rchild);
    return RR_Rotation(T);
}

AVLTree Insert(AVLTree &T,int x)
{
    if(T==NULL) //如果为空，创建新结点
    {
        T=new AVLNode;
        T->lchild=T->rchild=NULL;
        T->data=x;
        T->height=1;
        return T;
     }
    if(T->data==x) return T;//查找成功，什么也不做，查找失败时才插入
    if(x<T->data)//插入到左子树
    {
        T->lchild=Insert(T->lchild,x);//注意插入后饭后结果挂接到T->lchild
        if(Height(T->lchild)-Height(T->rchild)==2)//插入后看是否平衡，如果不平衡显然是插入的那一边高度大
        {                                         //沿着高度大的那条路径判断
            if(x<T->lchild->data)//判断是LL还是LR,即插入的是lchild节点的lchild 还是rchild
                T=LL_Rotation(T);
            else
                T=LR_Rotation(T);
        }
    }
    else//插入到右子树
    {
        T->rchild=Insert(T->rchild,x);
        if(Height(T->rchild)-Height(T->lchild)==2)
        {
            if(x>T->rchild->data)
                T=RR_Rotation(T);
            else
                T=RL_Rotation(T);
        }
    }
    updateHeight(T);
    return T;
}

AVLTree adjust(AVLTree &T)//删除结点后，需要判断是否还是平衡，如果不平衡，就要调整
{
    if(T==NULL) return NULL;
    if(Height(T->lchild)-Height(T->rchild)==2)//沿着高度大的那条路径判断
    {
        if(Height(T->lchild->lchild)>=Height(T->lchild->rchild))
            T=LL_Rotation(T);
        else
            T=LR_Rotation(T);
    }
    if(Height(T->rchild)-Height(T->lchild)==2)//沿着高度大的那条路径判断
    {
        if(Height(T->rchild->rchild)>=Height(T->rchild->lchild))
            T=RR_Rotation(T);
        else
            T=RL_Rotation(T);
    }
    updateHeight(T);
    return T;
}

AVLTree Delete(AVLTree &T,int x)
{
    if(T==NULL) return NULL;
    if(T->data==x)//如果找到删除节点
    {
        if(T->rchild==NULL)//如果该节点的右孩子为NULL,那么直接删除
        {
            AVLTree temp=T;
            T=T->lchild;
            delete temp;
        }
        else//否则，将其右子树的最左孩子作为这个节点，并且递归删除这个节点的值
        {
           AVLTree temp;
           temp=T->rchild;
           while(temp->lchild)
              temp=temp->lchild;
           T->data=temp->data;
           T->rchild=Delete(T->rchild,T->data);
           updateHeight(T);
        }
        return T;
    }

    if(T->data>x)//调节删除节点后可能涉及的节点
        T->lchild=Delete(T->lchild,x);
    if(T->data<x)
        T->rchild=Delete(T->rchild,x);
    updateHeight(T);
	T=adjust(T);
    return T;
}

void Preorder(AVLTree T)//前序遍历方便看树的结果
{
    if(T==NULL) return ;
    cout<<T->data<<"\t"<<T->height<<endl;
    Preorder(T->lchild);
    Preorder(T->rchild);
}

 void Inorder(AVLTree T)//中序遍历方便看树的结果
{
    if(T==NULL) return ;
    Inorder(T->lchild);
    cout<<T->data<<"\t"<<T->height<<endl;
    Inorder(T->rchild);
}

 void Posorder(AVLTree T)//后序遍历方便看树的结果
{
    if(T==NULL) return ;
    Posorder(T->lchild);
    Posorder(T->rchild);
    cout<<T->data<<"\t"<<T->height<<endl;
}

void show(AVLTree T)
{
    Preorder(T);
    cout<<endl;
    Inorder(T);
    cout<<endl;
    Posorder(T);
}

AVLTree CreateAVL(AVLTree &T)
{
    int n,x;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>x;
        T=Insert(T,x);
    }
    return T;
}
int main()
{
    int x;
    AVLTree root=NULL;
    root=Empty(root);
    CreateAVL(root);
    show(root);
    cin>>x;
    root=Delete(root,x);
    show(root);
    return 0;
}

输入：

6
25 18 5 10 15 17
5

输出：

15      3
10      2
5       1
18      2
17      1
25      1

5       1
10      2
15      3
17      1
18      2
25      1

5       1
10      2
17      1
25      1
18      2
15      3

15      3
10      1
18      2
17      1
25      1

10      1
15      3
17      1
18      2
25      1

10      1
17      1
25      1
18      2
15      3
羽星_s
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
平衡二叉查找树算法代码
12-17
平衡二叉查找树代码 AVL 二叉树 查找树
平衡树的调整 案例与代码
堂吉诃德的专栏
10-28 863
一,分析平衡二叉查找树有什么意义？    平衡二叉查找树是对二叉查找树的改进，那二叉查找树哪些地方是不尽人意的呢？ 在分析二叉查找树的平均查找长度时，会发现，二叉查找树的平均查找长度与二叉查找树 的形态有关系，最坏的情况是退化为链表，查找变为线性查找，平均查找长度为(n 1)/2.最 好的情况就是树的形态与折半查找的判断树形式。平均查找长度为logN。 平衡二叉树就是为了保证
java数据结构与算法总结(二十七)--二叉查找树、平衡二叉树、红黑树的效率比较
秋天的猿
02-22 403
原文链接 查找、插入、删除操作的最坏时间复杂度 二叉查找树 平衡二叉树 红黑树 查找 O(n) O(logn) Olog(n) 插入 O(n) O(logn) Olog(n) 删除 O(n) O(logn) Olog(n) 二叉查找树因可能退化成链表，故其性能最差。平衡二叉树和红黑树是带有平衡条件的二叉查找树，故它们的效率也较高。 平衡二叉树的插入/删除操作带来的旋转操作可能会达到logn次，而红黑树的插入/.
（三.1）二叉查找（排序）树、平衡二叉树、红黑树
FixedStar 的博客
07-13 240
二叉搜索树（BST） 1、性质： ①非空左子树的所有键值小于其根节点的键值 ②非空右子树的所有键值大于其根节点的键值 ③左右子树都是二叉搜索树 二、查找效率 任何一个数据的查找过程都需要从根结点出发，沿某一个路径朝叶子结点前进。因此查找中数据比较次数与树的形态密切相关。 当树中每个结点左右子树高度大致相同时，树高为logN。则平均查找长度与logN成正比...
浅谈算法和数据结构: 八 平衡查找树之2-3树
weixin_34357928的博客
03-25 419
前面介绍了二叉查找树(Binary Search Tree)，他对于大多数情况下的查找和插入在效率上来说是没有问题的，但是他在最差的情况下效率比较低。本文及后面文章介绍的平衡查找树的数据结构能够保证在最差的情况下也能达到lgN的效率，要实现这一目标我们需要保证树在插入完成之后始终保持平衡状态，这就是平衡查找树(Balanced Search Tree)。在一棵具有N 个节点的树中，我们希望该树的高...
什么是平衡二叉树（AVL）
程序员吴师兄的博客
01-31 1324
前言 Wiki:在计算机科学中，AVL树是最早被发明的自平衡二叉查找树。在AVL树中，任一节点对应的两棵子树的最大高度差为1，因此它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下的时间复杂度都是{\displaystyle O(\log {n})} 。增加和删除元素的操作则可能需要借由一次或多次树旋转，以实现树的重新平衡。AVL 树得名于它的发明者 G. ...
平衡二叉树（AVL树）
学习日常分享
02-17 1178
为什么引入“平衡二叉树” 二叉搜索树上实现查找的时间复杂度与从根节点到所查对象节点的路径成正比，最坏情况下等于树的高度。 在构造二叉搜索树时，如果输入对象的序列恰好是按其关键码大小有序，则结果将产生一棵单支树。 例如：输入序列为{11,39,46,38,75} 在这样的树上查找所需要的时间是O(n)（与节点个数成正比）。 平衡二叉树的定义 平衡树（Balanced Tree）：高度为O(logn)的树。 平衡二叉树（Balanced Binary Tree）：由阿德尔森一维尔斯和兰迪斯（Adelson-V
【数据结构与算法】二叉树+二叉搜索树+平衡二叉树+红黑树--效率比较
kevin的博客
05-28 1302
分析方法： [ 二叉树用到递归，与二叉树高度有关，有多高，就有多少次递归，时间复杂度就是"O(树高)" 二叉树的高度与节点关系： 假设节点为N，则树的高度保持在logN附近；所以二叉树的查找效率一般是O(logN) ] 1二叉树 --任意的 2二叉搜索树： --是二叉树经过排序的，任意一个节点都满足左节点值小于等于父节点，右节点值大于等于父节点 [ 又称二叉查找树，亦称为二叉排序树 查找性能： [ 数目为N，树高保持logN附近，查找递归需要logN次，时间复杂度为O(logN) 当先...
二叉树，平衡二叉树，红黑树，b树，b+树，b*树的缺点与优点以及使用场景
ff_simon的博客
09-20 9828
1、二叉查找树的缺点 二叉查找树，相信大家都接触过，二叉查找树的特点就是左子树的节点值比父亲节点小，而右子树的节点值比父亲节点大，如图 基于二叉查找树的这种特点，我们在查找某个节点的时候，可以采取类似于二分查找的思想，快速找到某个节点。n 个节点的二叉查找树，正常的情况下，查找的时间复杂度为 O（logn）。 之所以说是正常情况下，是因为二叉查找树有可能出现一种极端的情况，例如 这种情况也是满...
Java常见的8种数据结构
热门推荐
muranfei的博客
01-30 1万+
数据结构是指数据在计算机内存空间中或磁盘中的组织形式 算法是完成特定任务的过程 二分法查找 r=2^s s：查找步数 r查找范围 幂函数 s=log2® 已知范围获取需要的次数 对数 算法复杂度使用O(N)函数进行标示 主要是去除常数 看运行时间受数据项个数的影响 常见排序 参考地址 https://blog.csdn.net/muranfei/article/details/80923996 栈 对列 优先级对列 栈按照“后进先出”、“先进后出”的原则来存储数据，先插入的数...
平衡二叉树算法.zip
04-24
搜索算法：搜索算法用于在数据集中查找特定元素的算法。常见的搜索算法包括线性搜索、二分搜索等。 图算法：图算法用于处理图结构的数据，如最短路径算法（如Dijkstra算法、Floyd-Warshall算法）、最小生成树算法...
JavaScript数据结构之二叉树的查找算法示例
10-20
主要介绍了JavaScript数据结构之二叉树的查找算法,结合具体实例形式分析了javascript针对二叉树节点最小值、最大值的相关查找操作实现技巧,需要的朋友可以参考下
二叉树查找算法实现例子程序
12-24
BinarySearchTree 类包含了插入方法 insert 和查找方法 search。insert 方法用于向树中插入新的节点，search 方法用于查找指定值的节点。
基础二叉树算法的C++实现
11-10
基础二叉树算法的C++实现
排序算法、二分查找、二叉树查找
01-12
排序算法、二分查找、二叉树查找
Codeforces Round 941 (Div. 2) （A~D）
weixin_61825750的博客
04-28 678
然后考虑若此时存在两个堆，那么对于Alice而言，其操作可以使得小的那个堆只剩下1，下一步Bob必须选1，然后Alice就胜利了。相反，若小的那个堆一开始就是1，那么Alice就输了。接下来推广到若干堆的情况：对于任意一方而言，若最小堆不是1，那么便可以控制胜利，于是我们只需要枚举到最小堆不是1的情况即可，然后看是谁在操作就是谁赢。思路：若要使得所有方格同色，关键在于四个角上的颜色，若对角上的颜色一样就能直接将所有格子变为同色。思路：首先处理 < k 的部分，我们可以通过二进制的思想来构造整数，例如。
密度峰值聚类(DPC)算法（Python3实现）
helloWorld的博客
04-27 751
密度峰值聚类（Density peaks clustering, DPC）算法是由Rodriguez和Laio于2014年提出的一种聚类分析算法。其原始文献名是在在 Science上发表的，论文名称为“Clustering by Fast Search and Find of Density Peaks”。这种聚类方法该算法是一种基于密度的聚类算法，可以自动确定聚类中心和聚类的数量并适用于处理各种形状和分布的数据集。
算法训练营第十一天 | LeetCode 20 有效的括号、LeetCode 1047 删除字符串中的所有相邻重复项
qq_63149342的博客
04-27 103
注意用的是字符串数组作为输入，而我们要用int型进行计算，这时候就要用到一个string转int类型的库函数stoi函数，aoti是字符数组转int类型。一个是最后循环结束后要判断栈内存是否为空，一个是出栈时要判断栈是否为空，总的来说是考验对于栈内存空间的掌控吧。这一题考栈的性质，相邻字符用未进栈的元素和进栈的元素进行模拟即可，相同且栈不为空即出栈，否则进栈，之后将栈内元素全部导入一个字符串，还要注意要写一个反转函数翻转下即可。LeetCode 1047 删除字符串中的所有相邻重复项。
基于模糊PI控制算法的龙格库塔CSTR模型控制系统simulink建模与仿真
最新发布
熟悉MATLAB/fpga/RK3588/LABVIEW/protus/单片机/dsp/Multisim
04-30 475
基于模糊PI控制算法的龙格库塔CSTR模型控制系统simulink建模与仿真。基于模糊PI控制算法的龙格-库塔（Runge-Kutta, RK）连续搅拌釜反应器（Continuous Stirred Tank Reactor, CSTR）模型控制系统，是将模糊控制理论与经典的数值积分方法相结合的一种先进控制策略。模糊控制是一种基于模糊集合理论和语言变量的控制方法，适用于非线性、时变系统的控制。
代码随想录算法训练营
08-23
代码随想录算法训练营是一个优质的学习和讨论平台，提供了丰富的算法训练内容和讨论交流机会。在训练营中，学员们可以通过观看视频讲解来学习算法知识，并根据讲解内容进行刷题练习。此外，训练营还提供了刷题建议，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

羽星_s

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值