精华内容
下载资源
问答
  • 大概解释意思:这种树最基本操作是LL和RR两个单旋转函数,这两个函数和链表插入函数挺相像。这两个函数要牢记。 其次是LR和RL两个双旋转函数,要在心里绘制出这两种树形状,这样调用LL还是RR很明了了。...

    平衡二叉树

    首先该树挺简单的。


    大概解释个意思:这种树的最基本的操作是LL和RR两个单旋转函数,这两个函数和链表的插入函数挺相像的。这两个函数要牢记。

    其次是LR和RL两个双旋转函数,要在心里绘制出这两种树的形状,这样调用LL还是RR很明了了。

    1,在进行增删节点时,和二叉查找树算法一致,不过是多了一步判断左右子树高度并对不符合规格限制的树单旋转抑或是双旋转,并更新高度(这一步很关键)。

    2,在LL函数和RR函数的最后要附带更新高度的操作

    3,删除节点和搜索树一致,不过是查找树可以找左树最大抑或是右树最小删除,但是平衡树必须在更高大的子树删去(为了更易平衡,否则删一下就要换一下根节点orz)。增加的节点一定是叶子节点,这个和搜索树一样。

    以下代码:

    #include <stdio.h>
    #include <stdlib.h>
    #include <algorithm>
    using namespace std;
    typedef struct BiNode
    {
    	int data;
    	int height;
    	struct BiNode *lchild;
    	struct BiNode *rchild;
    }BiNode,*BiTree;
    int FindMax(BiTree root)
    {
    	if(root==NULL)
    	{
    
    		return 0;
    	}
    	else
    	{
    		BiTree temp;
    		temp=root;
    		while(temp->rchild!=NULL)
    		{
    			temp=temp->rchild;
    		}
    		return temp->data;
    	}
    }
    int FindMin(BiTree root)
    {
    	if(root==NULL)
    	{
    
    		return 0;
    	}
    	else
    	{
    		BiTree temp;
    		temp=root;
    		while(temp->lchild!=NULL)
    		{
    			temp=temp->lchild;
    		}
    		return temp->data;
    	}
    }
    int GetHeight(BiTree root)
    {
    	if(root==NULL)
    	{
    
    		return 0;
    	}
    	else
    	{
    		return root->height;
    	}
    }
    BiTree LL(BiTree &root)
    {
    	BiTree temp=root->lchild;
    	root->lchild=temp->rchild;
    	temp->rchild=root;
    	root->height=max(GetHeight(root->lchild),GetHeight(root->rchild))+1;
    	temp->height=max(GetHeight(temp->lchild),GetHeight(temp->rchild))+1;
    	return temp;
    }
    BiTree RR(BiTree &root)
    {
    	BiTree temp=root->rchild;
    	root->rchild=temp->lchild;
    	temp->lchild=root;
    	root->height=max(GetHeight(root->lchild),GetHeight(root->rchild))+1;
    	temp->height=max(GetHeight(temp->lchild),GetHeight(temp->rchild))+1;
    	return temp;
    }
    BiTree LR(BiTree &root)
    {
    	root->lchild=RR(root->lchild);
    	return LL(root);
    }
    BiTree RL(BiTree &root)
    {
    	root->rchild=LL(root->rchild);
    	return RR(root);
    }
    void Insert(BiTree &root,int x)
    {
    	if(root==NULL)
    	{
    		BiTree temp=(BiTree)malloc(sizeof(BiNode));
    		temp->data=x;
    		temp->lchild=temp->rchild=NULL;
    		temp->height=0;
    		root=temp;
    	}
    	else if(root->data<x)
    	{
    		Insert(root->rchild,x);
    		if(GetHeight(root->rchild)-GetHeight(root->lchild)>1)
    		{
    			if(GetHeight(root->rchild->rchild)-GetHeight(root->rchild->lchild)>1)
    			{
    				root=RR(root);
    			}
    			else
    			{
    				root=RL(root);
    			}
    		}
    		else
    		{
    			root->height=max(GetHeight(root->lchild),GetHeight(root->rchild))+1;
    		}
    	}
    	else if(root->data>x)
    	{
    		Insert(root->lchild,x);
    		if(GetHeight(root->lchild)-GetHeight(root->rchild)>1)
    		{
    			if(GetHeight(root->lchild->lchild)-GetHeight(root->lchild->rchild)>1)
    			{
    				root=LL(root);
    			}
    			else
    			{
    				root=LR(root);
    			}
    		}
    		else
    		{
    			root->height=max(GetHeight(root->lchild),GetHeight(root->rchild))+1;
    		}
    	}
    }
    bool Delete(BiTree &root,int x)
    {
    	if(root==NULL)
    	{
    		return false;
    	}
    	else if(root->data==x)
    	{
    		if(root->lchild!=NULL&&root->rchild!=NULL)
    		{
    			if(GetHeight(root->lchild)>GetHeight(root->rchild))
    			{
    				root->data=FindMin(root->rchild);
    				Delete(root->rchild,root->data);
    			}
    			else
    			{
    				root->data=FindMax(root->lchild);
    				Delete(root->lchild,root->data);
    			}
    		}
    		else if(root->lchild!=NULL||root->rchild!=NULL)
    		{
    			BiTree temp=(BiTree)malloc(sizeof(BiNode));
    			root=root->lchild?root->lchild:root->rchild;
    			delete(temp);
    		}
    		else
    		{
    			delete(root);
    		}
    	}
    	else if(root->data>x)
    	{
    		Delete(root->lchild,x);
    		if(GetHeight(root->rchild)-GetHeight(root->lchild)>1)
    		{
    			if(GetHeight(root->rchild->rchild)-GetHeight(root->rchild->lchild)>1)
    			{
    				root=RR(root);
    			}
    			else
    			{
    				root=RL(root);
    			}
    		}
    		else
    		{
    			root->height=max(GetHeight(root->lchild),GetHeight(root->rchild))+1;
    		}
    	}
    	else if(root->data<x)
    	{
    		Delete(root->rchild,x);
    		if(GetHeight(root->lchild)-GetHeight(root->rchild)>1)
    		{
    			if(GetHeight(root->lchild->lchild)-GetHeight(root->lchild->rchild)>1)
    			{
    				root=LL(root);
    			}
    			else
    			{
    				root=LR(root);
    			}
    		}
    		else
    		{
    			root->height=max(GetHeight(root->lchild),GetHeight(root->rchild))+1;
    		}
    	}
    	return true;
    }
    溜了,打dota去了。
    展开全文
  • 集群的意思就是本来一个项目只有一份,现在复制几份一模一样的相同部署到服务器上。就算瘫痪了一个,还有其他几个。 负载均衡 如果不做负载均衡,就算做了集群,所有的请求都请求到一台服务器上,其他的几台服务器都...

    单点故障

    系统只有一个,当系统崩溃之后就直接瘫痪了,不能在继续处理业务了。解决方案:集群。

    集群

    集群的意思就是本来一个项目只有一份,现在复制几份一模一样的相同部署到服务器上。就算瘫痪了一个,还有其他几个。

    负载均衡

    如果不做负载均衡,就算做了集群,所有的请求都请求到一台服务器上,其他的几台服务器都是空闲的,这样就没有起到减轻服务器负载的效果,负载的作用就是按照一定的算法,按照一定的平衡将请求分配到不同的服务器上。

    进行了负载均衡之后,负载均衡的系统又有出现单点故障,因此负载均衡的系统又做了集群,通过一定的手段,先只使用一个,当一个挂掉之后,剩下的负载均衡系统在顶上。(keepalived)

    弹性

    有的时候系统会忽然有特别大的访问量,但是平时的访问量又不是特别多,就比如:双11。如果这种出现情况,去部署大量的实体服务器就会增到成本。因此就使用虚拟的服务器,当双11过掉之后,再把这些虚拟的服务器删除,就达到了服务器的弹性变化。
    例如:
    docker。

    失效转移

    做了集群的系统,假设一个用户登录了,然后再集群的a系统中登录了,然后a系统挂了,这时候找个用户的请求交给了集群b系统,这时候用户的这些状态信息就不存了,用户就需要重新登录,这种情况肯定是不允许出现的。
    解决方案:
    1、将用户的状态信息复制到所有集群上。
    2、使用一个第三者,将用户状态信息保存到第三者上,然后所有的集群系统都去找第三者要状态信息。

    服务的注册和发现

    当集群项目有大量的地址需要维护,因此就引入了注册中心,注册中心中提供一个名称,集群项目的地址都映射到这个地址上。注册中心给这些服务发送心跳,判断服务是否可用。

    展开全文
  • P2880 平衡的阵容

    2018-12-02 23:04:00
    在这里介绍一种新算法(十分优秀):ST表  这个算法,其实就是求一... 那么首先明白概念性解释,对于dp[i][j],意思是以i为起点,长度为2j区间里最大值(注意我表述)。  那么就很简单了,主要思想就是...

      在这里介绍一种新的算法(十分优秀):ST表

      这个算法,其实就是求一段区间内最大值或者最小值是多少,当然就是一种降低时间复杂度的优化。

      显然线段树是不行的(复杂度太高O(mlogn)),所以妄想写线段树的人就放弃吧~      :3 

      那么首先明白概念性解释,对于dp[i][j],意思是以i为起点,长度为2j的区间里的最大值(注意我的表述)。

      那么就很简单了,主要思想就是每次一分为二,分别求最大值,再求整个的最大值。

      注意不要有区间重叠(要不就麻烦了),长度也可以优化( i +( 1 << j )- 1 <= n),-1排去第i个点的长度,因为dp[i][j-1]并不包括第i+2j-1的那个点。

      直接上代码:

    #include<cstdio>
    #include<iostream>
    #include<cmath>
    using namespace std;
    #define maxn 50005
    int dp[maxn][21],dj[maxn][21];
    int n,q,a[maxn],b[maxn];
    void Deal_now()
    {
        for(int i=1;i<=n;i++)
        {
            dp[i][0]=a[i];
            dj[i][0]=a[i];
        }
        for(int j=1;(1<<j)<=n;j++)
            for(int i=1;i+(1<<j)-1<=n;i++)
            {
                dp[i][j]=max(dp[i][j-1],dp[i+(1<<(j-1))][j-1]);
                dj[i][j]=min(dj[i][j-1],dj[i+(1<<(j-1))][j-1]);
            }    
        for(int i=1;i<=n;i++)
             b[i]=log2(i);
    }
    int query(int L,int R)
    {
        int k=b[R-L+1];
        int ans1=max(dp[L][k],dp[R-(1<<k)+1][k]);
        int ans2=min(dj[L][k],dj[R-(1<<k)+1][k]);
        return ans1-ans2;
    }
    int main()
    {
        scanf("%d%d",&n,&q);
        for(int i=1;i<=n;i++)
            scanf("%d",&a[i]);
        Deal_now();
        for(int i=1;i<=q;i++)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            printf("%d\n",query(x,y)); 
        }return 0;
    }

     

    转载于:https://www.cnblogs.com/popo-black-cat/p/10056118.html

    展开全文
  • poj 2892 随机平衡二叉树解法

    千次阅读 2011-10-27 20:47:08
    首先解释下题目意思: 输入n和m,你表示数轴长度,当然这里数轴是从1开始正整数,m表示接下来有m个操作。 D x: The x-th village was destroyed.  就是摧毁数轴上x值 Q x: The Army comma

    这种题就是标准的模板题,只要一个Treap上去就AC了,所以没有什么价值,唯一的价值就是用来学习Treap前驱和后继函数在动态数据中的应用。

    首先解释下题目意思:

    输入n和m,你表示数轴的长度,当然这里的数轴是从1开始的正整数,m表示接下来有m个操作。

    D x: The x-th village was destroyed. 

    就是摧毁数轴上的x值

    Q x: The Army commands requested the number of villages that x-th village was directly or indirectly connected with including itself.

    询问x最左和最右没有被摧毁的两个数轴上点的距离.

    R: The village destroyed last was rebuilt. 

    重新修复最近一个被摧毁的点

    Q x 的查询操作很容易让人想到平衡二叉树中的求前驱和后继函数,因此这题就解决了,

    各种平衡二叉树均能推倒之,我是用Treap来写的。

    具体的解法就是把D操作中的x insert到Treap中,R操作的时候就把最近的一次摧毁的点remove掉,

    当然这里要另外开一个数组来记录所有被摧毁的点,便于查找最近被摧毁的点

    Q的时候就找前驱p和后继q,最后的答案就是q->key - p->key - 1;

    这里开始的时候有个小技巧,就是把数轴的0点和n+1点也insert到Treap里面,

    这样避免了求前驱和后继的时候返回的是null。

    如果有不了解Treap(随机平衡二叉树)的可以见http://blog.csdn.net/acceptedxukai/article/details/6910685

    #include <iostream>
    #include <cstdio>
    #include <cstdlib>
    #include <cstring>
    #include <cmath>
    #include <algorithm>
    #include <set>
    #include <map>
    #include <ctime>
    #include <vector>
    #include <queue>
    using namespace std;
    #define LL long long
    const int N = 10005;
    const int MAX = 1<<30;
    class Treap
    {
    public :
        struct Node
        {
            int key,cnt,fix;
            Node *left,*right;
            Node(int e) : key(e),cnt(1),fix(rand()) {}
        }*root,*null;
    
        Treap()
        {
            null = new Node(MAX);
            null->cnt = 0;
            root = null->right = null->left = null;
        }
    
        //右旋
        void right_rat(Node *&x)
        {
            Node *y = x->left;
            x->left = y->right;
            y->right = x;
            x = y;
        }
    
        //左旋
        void left_rat(Node *&x)
        {
            Node *y = x->right;
            x->right = y->left;
            y->left = x;
            x = y;
        }
    
        void insert(Node *&x,int e)
        {
            if(x == null)
            {
                x = new Node(e);
                x->left = x->right = null;
            }
            else if(e < x->key)
            {
                insert(x->left,e);
                if(x->left->fix < x->fix)right_rat(x);
            }
            else if(e > x->key)
            {
                insert(x->right,e);
                if(x->right->fix < x->fix) left_rat(x);
            }
            else ++x->cnt;
        }
    
        //删除函数
        void remove(Node *&x,int e)
        {
            if(x == null) return;
            else if(e <x->key) remove(x->left,e);
            else if(e > x->key) remove(x->right,e);
            else if(--x->cnt <= 0)
            {
                if(x->left == null || x->right == null)
                {
                    Node *y = x;
                    x = (x->left != null)? x->left : x->right;
                    delete y;
                }
                else
                {
                    if(x->left->fix < x->right->fix)
                    {
                        right_rat(x);
                        remove(x->right,e);
                    }
                    else
                    {
                        left_rat(x);
                        remove(x->left,e);
                    }
                }
            }
        }
    
        //前驱
        Node* Pred(Node* x,Node* y,int e)
        {
            if (x == null)
                return y;
            if (e < x->key)
                return Pred(x->left,y,e);
            return Pred(x->right,x,e);
        }
        //后继
        Node *Succ(Node *x,Node *y,int e)
        {
            if(x == null) return y;
            if(e <= x->key) return Succ(x->left,x,e);
            return Succ(x->right,y,e);
        }
    
        int count(int e)
        {
            Node *p = Pred(root,null,e);//求前驱
            Node *q = Succ(root,null,e);//求后继
            return (q->key - p->key - 1) < 0 ? 0 : (q->key - p->key - 1);
        }
    };
    
    int str[50005];
    
    int main()
    {
        srand(time(0));
        Treap tree;
        int n,m,p,cnt=0;
        tree.insert(tree.root,0);//插入0点
        scanf("%d %d",&n,&m);
        tree.insert(tree.root,n+1);//插入n+1点
        for(int i = 0 ; i < m ; i ++)
        {
            char ch[3];
            scanf("%s",ch);//用字符串输入比较方便,char太麻烦了
            if(strcmp(ch,"D") == 0)
            {
                scanf("%d",&p);
                str[cnt++]=p;
                tree.insert(tree.root,p);
            }
            else if(strcmp(ch,"Q") == 0)
            {
                scanf("%d",&p);
                printf("%d\n",tree.count(p));
            }
            else
            {
                p = str[cnt-1];
                cnt--;
                tree.remove(tree.root,p);
            }
            //getchar();
        }
        return 0;
    }



    展开全文
  • 全称Balance-tree(平衡多路查找树),平衡的意思是左边和右边分布均匀。多路的意思是相对于二叉树而言的,二叉树就是二路查找树,查找时只有两条路,而B-tree有多条路,即父节点有多个子节点。 一、术语 阶:...
  • R语言解决数据不平衡问题

    千次阅读 2019-07-07 11:16:23
    ​ 首先我们要知道第一个问题就是“什么是数据不平衡”,从字面意思上进行解释就是数据分布不均匀。在我们做有监督学习时候,数据中有一个类比例远大于其他类,或者有一个类比值远小于其他类时,我们就可以...
  • 在兰州装修做装修这么多年,碰到不少朋友问我,家里装修新房或旧房翻新该用什么材料门,我在这里专门为朋友们解释一二。实木复合门和实木门和高分子门都是指门材质,烤漆门是用表面工艺命名,通常实木门都是...
  • 这道题的意思就是对于 ai ,在前i个数中找一个与ai差值最小的数,做法还是很多的,我们可以直接用set做,也可以用邻接表做,还可以用treap做,代码是treap的 这题就是用treap找一个前驱(这里不是严格小于,因为等于...
  • (有任何问题欢迎留言或私聊 题意:  题目意思非常简单,两种操作,一个是查询[L,R]第k大,还有就是单点修改值。 方法非常多,什么分块,...具体看代码中的解释。 推荐:qsc学姐分块教学 AC代码: ...
  • PostgreSql Gist索引

    2017-07-27 11:09:06
    GiST的意思是通用的搜索树(Generalized Search Tree)。 它是一种平衡树结构的访问方法,在系统中作为一个基本模版,可以使用它实现任意索引模式。B-trees, R-trees和许多其它的索引模式都可以用GiST实现。上面一段高能...
  • postgresql----Gist索引

    2016-06-29 23:08:00
    GiST的意思是通用的搜索树(Generalized Search Tree)。 它是一种平衡树结构的访问方法,在系统中作为一个基本模版,可以使用它实现任意索引模式。B-trees, R-trees和许多其它的索引模式都可以用GiST实现。 上面一段...
  • 从字面意思上来看,负载均衡就是做资源动态平衡分配,使资源使用效率更高。在这个设备资源有限、性能和网络速度却要求非常高IT领域,这个设备(或功能)还是很重要。 先解释下什么叫做“负载均衡”? ...
  • 介绍几个曲线图

    千次阅读 2008-11-22 15:51:00
    虽然下面几张图中的曲线可不是曲线救“站”的意思,但倘若你能找到适合自己站点的那个顶峰,寻求平衡,并能抓住机会超越,肯定能获得长久的发展(文章来源自这里,稍做解释,具体还请点击下面的链接)Barry Schwartz...
  • 负载均衡

    2019-09-19 10:21:29
    负载均衡Load Balance,也叫负载分担,意思就是将负载进行平衡、分摊到多个操作单元上进行执行,例如Web服务器、FTP服务器、企业应用服务器和其它任务服务器等,从而共同完成工作任务。是解决高性能,单点故障(高...
  • 1.2.0 请解释下为什么鹿晗发布恋情时候,微博系统会崩溃,如何解决? 1.2.1 现有一批邮件需要发送给订阅顾客,且有一个集群(集群节点数不定,会动态扩容缩容)来负责具体邮件发送任务,如何让系统尽快地...
  • 大话数据结构

    2019-01-10 16:35:22
    感情上发生了问题,为了向女友解释一下,我准备发一条短信,一共打了75个字。最后八个字是“我恨你是不可能”,点发送。后来得知对方收到,只有70个字,短信结尾是“……我恨你”。 5.5.1串顺序存储结构 129 ...
  • 大话数据结构 程杰

    2018-09-01 10:06:43
    感情上发生了问题,为了向女友解释一下,我准备发一条短信,一共打了75个字。最后八个字是“我恨你是不可能”,点发送。后来得知对方收到,只有70个字,短信结尾是“……我恨你”。 5.5.1串顺序存储结构 129 ...
  • 5.3 串比较 126 5.4 串抽象数据类型 127 5.5 串存储结构 128 感情上发生了问题,为了向女友解释一下,我准备发一条短信,一共打了75个字。最后八个字是"我恨你是不可能",点发送。后来得知对方收到,只有...
  • 大话数据结构-程杰

    2014-07-13 23:45:52
    感情上发生了问题,为了向女友解释一下,我准备发一条短信,一共打了75个字。最后八个字是"我恨你是不可能",点发送。后来得知对方收到,只有70个字,短信结尾是"……我恨你"。 5.5.1 串顺序存储结构 129 ...
  • 感情上发生了问题,为了向女友解释一下,我准备发一条短信,一共打了75个字。最后八个字是“我恨你是不可能”,点发送。后来得知对方收到,只有70个字,短信结尾是“……我恨你”。 5.5.1串顺序存储结构 129 ...
  • 感情上发生了问题,为了向女友解释一下,我准备发一条短信,一共打了75个字。最后八个字是“我恨你是不可能”,点发送。后来得知对方收到,只有70个字,短信结尾是“……我恨你”。 5.5.1串顺序存储结构 129 ...
  • 而C中定义了一些字母前加"\"来表示常见那些不能显示ASCII字符,如\0,\t,\n等,就称为转义字符,因为后面字符,都不是它本来ASCII字符意思了。  转义字符 意义 ASCII码值(十进制)  \a 响铃(BEL) 007  \b...
  • 测试培训教材

    2014-04-01 12:10:48
    缺乏尺度会让测试失去平衡,缺乏标准会让测试工作难以衡量。 2、如何搭建测试管理平台? 首要问题是流程规范化。 (1) 测试进入和退出标准。 (2) 协作流程。 (3) 缺陷跟踪管理流程。 (4) 工具平台引入。...
  • 9.8.1 理解其他关键字的意思 9.8.2 理解列的类型 9.8.3 用SHOW和DESCRIBE来查看数据库 9.8.4 创建索引 9.9 理解MySQL的标识符 9.10 选择列数据类型 9.10.1 数字类型 9.10.2 日期和时间类型 9.10.3 字符串...

空空如也

空空如也

1 2
收藏数 25
精华内容 10
关键字:

平衡的意思解释