算法导论复习十四章

最新推荐文章于 2022-09-14 20:37:13 发布
最新推荐文章于 2022-09-14 20:37:13 发布
阅读量298 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cclive1601/article/details/9148081
版权 
//持续更新

#include <iostream>//动态顺序统计，要分析好对于新添加的信息size在插入，删除以及旋转的时候的变换，直接从这种变化出发进行解决是最好的，也可以采用一种修正后的调整就是插入之后再进行调整之类
#define RED 1
#define BLACK 0
using namespace std;
struct node
{
	int key;
	node* p;
	node* left;
	node* right;
	bool color;
	int size;
	node(){
		key=0;
		p=NULL;
		left=NULL;
		right=NULL;
		color=RED;
		size=1;
	}
	node(int k):key(k){
		p=NULL;
		left=NULL;
		right=NULL;
		color=RED;
		size=1;
	}
	node(int k ,int s):key(k),size(s){
		p=NULL;
		left=NULL;
		right=NULL;
		color=RED;//这个是nil使用的
	}
	node& operator=(node& other)
	{	
		if(this!=&other)
		{
			this->key=other.key;
			this->p=other.p;
			this->color=other.color;
			this->left=other.left;
			this->right=other.right;
		}
		return *this;
	}
	void init()
	{
		size=left->size+right->size+1;
	}
};
struct rbtree
{
	node* root;//根
	node* nil;//哨兵
	rbtree()
	{
		int k;
		cin>>k;
		root=new node(k);
		root->color=BLACK;
		nil=new node(100000,0);//size为0
		nil->color=BLACK;
		root->p=nil;//一开始根节点就指向该值
		root->left=nil;//最初的时候如此的进行设计。
		root->right=nil;
	}
	void letf_rotate(node*);//o(1)
	void right_rotate(node*);//o(1)
	void rb_insert_fixup(node*);
	void rb_insert(node*);//o(lgn)
	void rb_delete_fixup(node*);
	node* rb_delete(node*);//o(lgn)
	node* rb_successor(node*);//辅助
	node* rb_min(node*);//辅助
	node* os_select(node*,int);
	int os_rank(node*);
};

node* rbtree::os_select(node* x,int i)
{
	int r=x->left->size+1;
	if(r==i)
		return x;
	else if(r<i)
		return os_select(x->left,i);
		else 
			return os_select(x->right,r-1);
}

int rbtree::os_rank(node *x)
{
	int r=x->left->size+1;
	node* y=x;
	while(y!=root)
	{
		if(y=y->p->right)
		{
			r=r+y->p->left->size+1;
			y=y->p;
		}
	}
	return r;
}


void rbtree::letf_rotate(node* px)
{
	node* py=px->right;
	if(py!=nil)
	{
		px->right=py->left;
		if(py->left!=nil)
			py->left->p=px;
		py->p=px->p;
		if(px==nil)
			root=py;
		if(px==px->p->left)
			px->p->left=py;
		else
			px->p->right=py;
		py->left=px;
		px->p=py;
	}
	else
	{
		cerr<<"left of px is null "<<endl;
		return ;//一般情况下函数返回值为void 可以如此；
	}
	py->size=px->size;
	px->size=px->left->size+px->right->size+1;
	cout<<"finished! "<<endl;
}

void rbtree::right_rotate(node* px)//13.2-1
{
	node* py=px->left;
	if(py!=nil)
	{
		px->left=py->right;
		if(py->right!=nil)
			py->right->p=px;
		py->p=px->p;
		if(px->p==nil)
			root=py;
		if(px==px->p->left)
			px->p->left=py;
		else
			px->p->right=py; 
		py->right=px;
		px->p=py;
	}else
	{
		cerr<<"right of px is nil "<<endl;
		return ;
	}
	py->size=px->size;
	px->size=px->left->size+px->right->size+1;
	cout<<"finishede!"<<endl;
}
/************rbtree_insert()************************/
void rbtree::rb_insert_fixup(node* pz)
{
	  node* py=new node();
	  while(pz->p->color==RED)//对于红黑树，插入一个点为红，只要保证最后的树是满足红黑树的五个性质即可，插入的是红点，黑高度不影响，那么插入
	  {//红点，会造成的影响是：如果插入的点成为根节点的话；以及插入节点的父节点为红。这里以插入节点的父节点为红做判断。
		if(pz->p==pz->p->p->left)
		{
			py=pz->p->p->right;//py为pz的叔叔
			if(py->color==RED)//情况1：叔叔为红的时候
			{
				pz->p->color=BLACK;
				py->color=BLACK;
				pz->p->p->color=RED;//修改颜色使父辈变黑，爷爷变红，这样节点黑高度不受影响，原因是pz为红，pz父辈为红，那么对应必定有祖父辈，插入前的rbtree为
				//正常的，父辈不会为根，那么存在祖父辈，如果祖父辈为红，父辈怎么会为红呢？祖父辈必定为黑以保证插入前的rbtree是正常。
				pz=pz->p->p;
			}else 
			{
				if(pz==pz->p->right)//情况2：叔叔为黑，且pz是右孩子
				{
					pz=pz->p;
					letf_rotate(pz);
				}
				pz->p->color=BLACK;//情况3：叔叔为黑，pz是左孩子
				pz->p->p->color=RED;
				right_rotate(pz->p->p);
			}
		}else if(pz->p==pz->p->p->right)
		{
			py=pz->p->p->left;//叔叔
			if(py->color==RED)
			{
				pz->p->color=BLACK;
				py->color=BLACK;
				pz->p->p->color=RED;
				pz=pz->p->p;
			}else
			{
				if(pz==pz->p->left)
				{
					pz=pz->p;
					right_rotate(pz);
				}
				pz->p->color=BLACK;
				pz->p->p->color=RED;
				letf_rotate(pz->p->p);
			}
		}
	  }
	root->color=BLACK;//这里的做法，可以避免插入的节点成为根节点，黑高度还是不受影响，只是大了一个
//	delete py;
}
void rbtree::rb_insert(node* pz)//红黑树是二叉查找树，插入节点先图红，可以保证节点黑高度，插入的是类似二叉查找树的插入
{
	node* py=nil;
	node* px=root;
	while(px!=nil)
	{
		px->size++;
		py=px;
		if(pz->key>px->key)
			px=px->right;
		else
			px=px->left;
	}
	pz->p=py;
	if(py==nil)
		root=pz;
	else 
		if(pz->key<py->key)
			py->left=pz;
		else
			py->right=pz;
	pz->left=nil;
	pz->right=nil;
	pz->color=RED;
	rb_insert_fixup(pz);
//	delete py;
//	delete px;
}


int main()
{
	rbtree* rb=new rbtree();
	node* p1=new node(1);
	node* p2=new node(2);
	node* p3=new node(3);
	//	rb->letf_rotate(p1);//一开始运行此处的时候会报错，原因很简单，在上面的py->left等都是空的。所以赋值的时候会出错的。勿怪了
	//	rb->right_rotate(p2);
	rb->rb_insert(p1);
	rb->rb_insert(p2);
	rb->rb_insert(p3);
	return 0;
}




/*
  区间树：同样是基于红黑树的结构进行添加的区间特性，和14.1节的特性（添加了size特性）都是一个道理;

  区间概念：即[t1,t2](t1<=t2),把区间当做是一个对象i，相应的可以知道的就是区间存在的有的域
low[i]=t1,high[i]=t2；

  区间存在着对应的关系：1，重叠；2，区间1，在区间2左边即high[i1]<low[i2]；3，区间1在区间2右边，即high[i2]<low[i1]

  区间树的操作：1，插入：把包含区间域的元素插入到区间树中；2，删除：把包含区间域的某元素从树中删除；3，查找：即在区间树中
查找某一个区间域对象，如果没有就返回null

  基础数据结构：基于红黑树，每一个节点x包含区间域int[x]，节点x关键值为区间的低端点low[int[x]]，还有声明的就是使用的是中序遍历

  附加信息：每一个节点中还包含了一个值max[x]，表示为以x为根的子树中所有区间的端点最大值；

  信息的维护：对于附加信息就表示为：对于节点x，对应的最大值max[x]表示为max[x]=max(high[x],max[left[x]],max[right[x]]);
  
*/
#include <iostream>
#include <algorithm>
#define RED 1
#define BLACK 0
using namespace std;
struct range
{
	int start;
	int end;
	range()
	{
		cin>>start;
		cin>>end;
	}
	bool overlap(range rge)
	{
		if(this->start>rge.end||this->end<rge.start)
			return false;
		return true;
	}
	range& operator=(range& other)
	{
		if(this!=&other)
		{
			this->start=other.start;
			this->end=other.end;
		}
		return *this;
	}
};
struct node
{
	int key;
	node* p;
	node* left;
	node* right;
	bool color;
	range rge;
	int Max;
	node(){
		key=0;
		p=NULL;
		left=NULL;
		right=NULL;
		color=RED;
		rge.start=0;
		rge.end=0;
		Max=rge.end;
	}
	node(int k):key(k){
		p=NULL;
		left=NULL;
		right=NULL;
		color=RED;
		rge.start=0;
		rge.end=0;
		Max=rge.end;
	}
	node(int k,int s,int e):key(k){
		rge.start=s;
		rge.end=e;
		p=NULL;
		left=NULL;
		right=NULL;
		color=RED;
		Max=rge.end;
	}
	node& operator=(node& other)
	{	
		if(this!=&other)
		{
			this->key=other.key;
			this->p=other.p;
			this->color=other.color;
			this->left=other.left;
			this->right=other.right;
			this->Max=other.Max;
			this->rge=other.rge;
		}
		return *this;
	}
};
struct rbtree
{
	node* root;//根
	node* nil;//哨兵
	rbtree()
	{
		int k;
		cin>>k;
		root=new node(k);
		root->color=BLACK;
		nil=new node(100000);
		nil->color=BLACK;
		root->p=nil;
		root->left=nil;
		root->right=nil;
	}
	void letf_rotate(node*);
	void right_rotate(node*);
	void rb_insert_fixup(node*);//这里需要的是插入区间，我们使用节点代替。
	void rb_insert(node*);
	void rb_delete_fixup(node*);
	node* rb_delete(node*);
	node* rb_successor(node*);
	node* rb_min(node*);
	node* rb_search(node*);
	int max(int ,int);
};
/*
	对于插入的是某一个节点，相应的在插入的时候需要调整的是维护的最大值。
*/

int rbtree::max(int a,int b)
{
	return a>b?a:b;
}
node* rbtree::rb_search(node* pz)
{
	node* px=root;
	while(px!=nil&&!(pz->rge.overlap(px->rge)))
	{
		if(px->left!=nil&&px->left->Max>=pz->rge.start)
		{
			px=px->left;
		}else 
			px=px->right;
	}
	return px;
}
void rbtree::letf_rotate(node* px)
{
	node* py=px->right;
	if(py!=nil)
	{
		px->right=py->left;
		if(py->left!=nil)
			py->left->p=px;
		py->p=px->p;
		if(px==nil)
			root=py;
		if(px==px->p->left)
			px->p->left=py;
		else
			px->p->right=py;
		py->left=px;
		px->p=py;
	}
	else
	{
		cerr<<"left of px is null "<<endl;
		return ;
	}
	py->Max=px->Max;
	int MAX=max(px->left->Max,px->right->right->Max);
	px->Max=max(px->rge.end,MAX);
	cout<<"finished! "<<endl;
}

void rbtree::right_rotate(node* px)
{
	node* py=px->left;
	if(py!=nil)
	{
		px->left=py->right;
		if(py->right!=nil)
			py->right->p=px;
		py->p=px->p;
		if(px->p==nil)
			root=py;
		if(px==px->p->left)
			px->p->left=py;
		else
			px->p->right=py; 
		py->right=px;
		px->p=py;
	}else
	{
		cerr<<"right of px is nil "<<endl;
		return ;
	}
	py->Max=px->Max;
	int MAX=max(px->left->Max,px->right->right->Max);
	px->Max=max(px->rge.end,MAX);
	cout<<"finishede!"<<endl;
}//旋转的时候需要调整区间的值
void rbtree::rb_insert_fixup(node* pz)
{
	  node* py=new node();
	  while(pz->p->color==RED)
	  {
		  if(pz->p==pz->p->p->left)
		{
			py=pz->p->p->right;
			if(py->color==RED)
			{
				pz->p->color=BLACK;
				py->color=BLACK;
				pz->p->p->color=RED;
				pz=pz->p->p;
			}else 
			{
				if(pz==pz->p->right)
				{
					pz=pz->p;
					letf_rotate(pz);
				}
				pz->p->color=BLACK;
				pz->p->p->color=RED;
				right_rotate(pz->p->p);
			}
		}else if(pz->p==pz->p->p->right)
		{
			py=pz->p->p->left;
			if(py->color==RED)
			{
				pz->p->color=BLACK;
				py->color=BLACK;
				pz->p->p->color=RED;
				pz=pz->p->p;
			}else
			{
				if(pz==pz->p->left)
				{
					pz=pz->p;
					right_rotate(pz);
				}
				pz->p->color=BLACK;
				pz->p->p->color=RED;
				letf_rotate(pz->p->p);
			}
		}
	  }
	root->color=BLACK;
}

void rbtree::rb_insert(node* pz)
{//插入以及删除的时候需要进行修改
	node* py=nil;
	node* px=root;
	while(px!=nil)
	{
		px->Max=max(pz->Max,px->Max);
		py=px;
		if(pz->key>px->key)
			px=px->right;
		else
			px=px->left;
	}
	pz->p=py;
	if(py==nil)
		root=pz;
	else 
		if(pz->key<py->key)
			py->left=pz;
		else
			py->right=pz;
	pz->left=nil;
	pz->right=nil;
	pz->color=RED;
	rb_insert_fixup(pz);
}


node* rbtree::rb_min(node* pz)
{
	while (pz->left!=nil)
	{
		pz=pz->left;
	}
	return pz;
}

node* rbtree::rb_successor(node* pz)//中序遍历求后继
{
	node* py=new node();
	if(pz->right!=nil)
		return rb_min(pz->right);
	py=pz->p;
	while (py!=nil&&pz==py->right)
	{
		pz=py;
		py=py->p;
	}
	return py;
}

void rbtree::rb_delete_fixup(node* pz)
{
	node* pw=new node();
	while(pz!=root&&pz->color==BLACK)//为根节点，整体黑高度不影响，为红，后面会涂黑。
	{
		if(pz==pz->p->left)
		{
			pw=pz->p->right;
			if(pw->color==RED)//只有是父节点是黑色的情况pw才可能是红色。
			{
				pz->p->color=RED;
				pw->color=BLACK;
				letf_rotate(pz->p);
				pw=pz->p->right;
			}//情况1
			if (pw->left->color==BLACK&&pw->right->color==BLACK)
			{
				pw->color=RED;//只用堆pw修改，pz实际上是黑的，去掉一重还是黑，不要改，但是pw要；
				pz=pz->p;//此操作结束后，pz为红，结束并涂黑，如果pz为黑，还要pz加一重黑
			}
			else
			{
				if(pw->right->color==BLACK)//情况3
				{
					pw->left->color=BLACK;
					pw->color=RED;
					right_rotate(pw);
					pw=pz->p->right;
				}//情况4
				pw->color=pz->p->color;
				pz->p->color=BLACK;
				pw->right->color=BLACK;
				letf_rotate(pz->p);
				pz=root;
			}
		}
		else if(pz==pz->p->right)
		{
			pw=pz->p->left;//叔叔
			if(pw->color=RED)
			{
				pz->p->color=RED;
				pw->color=BLACK;
				right_rotate(pz->p);
				pw=pz->p->left;
			}
			if(pw->left->color==BLACK&&pw->right->color==BLACK)
			{
				pw->color=RED;
				pz=pz->p;
			}
			else 
			{
				if(pw->right->color==BLACK)
				{
					pw->left->color=BLACK;
					pw->color=RED;
					letf_rotate(pw);
					pw=pz->p->left;
				}
				pw->color=pz->p->color;
				pz->p->color=BLACK;
				pw->right->color=BLACK;
				right_rotate(pz->p);
				pz=root;
			}
		}	
	}
	pz->color=BLACK;
}

node* rbtree::rb_delete(node* pz)
{
	node* py=new node();
	node* px=new node();
	node* p=new node();
	if (pz->left==nil||pz->right==nil)
	{
		py=pz;
		p=py->p;
		p->Max=p->rge.end;
		while(p->Max==py->Max)
		{
			p->Max=max(p->Max,max(p->left->Max,p->right->Max));
			p=p->p;
		}
	}
	else 
		py=rb_successor(pz);
	p=py->p;
	p->Max=p->rge.end;
	while(p->Max==py->Max)
	{
		p->Max=max(p->Max,max(p->left->Max,p->right->Max));
		p=p->p;
	}
	if(py->left!=nil)
		px=py->left;
	else 
		px=py->right;
	px->p=py->p;
	if(py==nil)
		root=px;
	else 
		if(py==py->p->left)
			py->p->left=px;
		else
			py->p->right=px;
	if(py!=pz)
	{
		pz->key=py->key;
		pz->rge=py->rge;
		pz->Max=py->Max;
		p=pz->p;
		while(p->Max<pz->Max)
		{
			p->Max=pz->Max;
			p=p->p;
		}
	}
	if (py->color==BLACK)
	{
		rb_delete_fixup(px);
	}
	return py;
}




/*********************main_function()************************************/

int main()
{
	rbtree* rb=new rbtree();
	node* p1=new node(1);
	node* p2=new node(2);
	node* p3=new node(3);
	rb->rb_insert(p1);
	rb->rb_insert(p2);
	rb->rb_insert(p3);
	rb->rb_delete(p2);
	delete p1;
	delete p2;
	delete p3;
	return 0;
}













                

        

        

    




    

      

        

            

              
                
                  cclive1601
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
山东大学软件学院算法导论复习笔记

				
			

			

				

					06-03
				

			

		

		

			
				
山东大学软件学院算法导论课程的复习笔记。文件里面包含了五份笔记，涵盖BFS、DFS、SCC、Topological、MST、ShortestPath、maxflow。主要是对PPT的内容的整理概括。个人整理不易，其中的图片都是自己绘制的，就是...

			
		

	



                

              
                



	

		

			

				
					
《算法导论》第14章 数据结构的扩张 (1)动态顺序统计

				
			

			

				

					一个2年工作经验的程序测试员
				

				

					04-08
					
					137
					
				

			

		

		

			
				


《数据结构扩张》是《算法导论》第三部分的最后一章。在介绍学习了这么多种数据
结构之后，简要介绍了当这些基本数据结构不满足需求时，如何扩张它们来满足需求。
这才是学习算法的目的，能够根据需求选择合适的数据结构和算法，并在无法满足需求
时能够扩张它。这才是对算法的思想和本质的学习！

可以将本章看做深入学习的前奏吧，因为紧接着就要开始进入第四部分《高级设计和分析
技术》了。那么赶快...

			
		

	



                


  
              

                


	

		

			

				
					
《算法导论》第14章 数据结构的扩张 (2)

				
			

			

				

					一个2年工作经验的程序测试员
				

				

					04-09
					
					112
					
				

			

		

		

			
				


在上一节中，我们为树结点添加size域表示每颗子树的大小，即包含的结点个数，扩张了
二叉查找树为其增加顺序统计量的查找功能。更为自然的想法是直接添加顺序统计量rank域
到每个树结点上。这一节我们就来看下在这样的设计下，如何扩张来完成上一节相同的功能。

当我们插入一个结点到二叉树中，假设它的顺序统计量为5，那么之前二叉树中顺序统计量
大于5的结点都要更新。也就是说插入一个新结点...

			
		

	





	

		

			

				
					
算法导论-第14章

				
			

			

				

					人非生而知之者，孰能无惑？
				

				

					06-19
					
					967
					
				

			

		

		

			
				
数据扩张，说简单一点就是，在基本数据结构上加点东西。干什么？能有新操作，而且易于维护。
3个事情
1.顺序统计操作
2.一个扩张定理
3.一个查询区间


关于第一：
我加一个新的东西叫size——它是每个结点的为根，这个树里面有多少个结点，包括自己
为什么加？
因为它和很方便的在红黑树里面找到，第i个大的元素。方便。。。
公式
size[x]=size[left[x]+s

			
		

	



		

			
		



	

		

			

				
					
《算法导论》第14章 数据结构的扩张 个人笔记

				
			

			

				

					Amber07的笔记本
				

				

					05-23
					
					461
					
				

			

		

		

			
				
第14章 数据结构的扩张 14.1 动态顺序统计 14.2 如何扩张数据结构 14.3 区间树

			
		

	





	

		

			

				
					
《算法导论》第14章-数据结构的扩张 14.1-动态顺序统计 14.2-如何扩张数据结构

				
			

			

				

					Toby的博客
				

				

					09-14
					
					306
					
				

			

		

		

			
				
本文为《算法导论》第14章-数据结构的扩张 14.1-动态顺序统计 14.2-如何扩张数据结构的笔记，欢迎参考和提出建议！

			
		

	





	

		

			

				
					
算法导论期末复习习题

				
			

			

				

					01-03
				

			

		

		

			
				
面向对象: 煎熬备考期末复习的莘莘学子

			
		

	





	

		

			

				
					
山东大学2018算法导论图论考试复习总结

				
			

			

				

					07-15
				

			

		

		

			
				
山东大学2018算法导论图论考试复习总结，只考图论部分所以只有图论部分的总结。 本人于考试周吐血总结，包含的内容如下。 算法导论-图论 复习 优质的复习资料 1 基本的图算法 1.1 图的表示 1.2 BFS：广度优先搜索 ...

			
		

	





	

		

			

				
					
算法导论复习

				
			

			

				

					01-13
				

			

		

		

			
				
研究生算法导论复习 考试范围 考试重点，考试例题

			
		

	





	

		

			

				
					
算法导论 黑皮书 期末复习笔记 

				
			

			

				

					01-10
				

			

		

		

			
				
算法导论 黑皮书 期末复习笔记

			
		

	





	

		

			

				
					
算法导论 第14章 14.3 区间树

				
			

			

				

					yukid2012的专栏
				

				

					11-07
					
					580
					
				

			

		

		

			
				
一、综述

1.区间树

区间树中一种对动态集合进行维护的红黑树，该集合中的每个元素x都包含一个区间int[x]

2.基础数据结构

红黑树，其中每个结点x包含一个区间域int[x]，x的关键字为区间的低端点

3.附加信息

max[x]：以x为根的子树中所有区间的 端点的最大值

4.对信息的维护

max[x] = max(high[int[x]], max

			
		

	





	

		

			

				
					
算法导论代码　第14章 数据结构的扩张

				
			

			

				

					MoXiaopeng的专栏
				

				

					12-30
					
					636
					
				

			

		

		

			
				
第14章 数据结构的扩张
14.1 动态顺序统计
#include 
#include 
#include 
typedef struct red_black_tree_type *tree;
enum color_enum {
	color_red,
	color_black
};
struct tree_node {
	void *key;
	enum color_enum color;

			
		

	





	

		

			

				
					
算法导论 14章 数据结构的扩张(二) 区间树

				
			

			

				

					V然成风
				

				

					02-05
					
					1002
					
				

			

		

		

			
				
区间树——红黑树的扩张
          将红黑树进行扩张以支持由区间构成的动态集合，其节点主要除红黑树节点常规信息之外，还有一个区间信息，这样的一颗树称之为区间树。我们将利用14.2节总结的红黑树扩张的四个步骤来讨论如何进行扩充以得到区间树。
步骤1：基础数据结构
        毫无疑问，我们将选择红黑树。该区间树的每个节点有一个区间信息，对于节点x，即为int[x]，用low表示in

			
		

	





	

		

			

				
					
算法导论 第十四章 数据结构的扩张

				
			

			

				

					pokeyode的专栏
				

				

					01-13
					
					619
					
				

			

		

		

			
				
14.1动态顺序统计

			
		

	





	

		

			

				
					
算法导论 第十四章：区间树

					
热门推荐

				
			

			

				

					dllTimes
				

				

					07-16
					
					1万+
					
				

			

		

		

			
				
区间树是一种对动态集合进行维护的红黑树，具体设计如下：
step1:基础数据结构
   我们选择的基础数据结构式红黑树，其中每个节点增加

			
		

	





	

		

			

				
					
算法导论 14章 数据结构的扩张

				
			

			

				

					博客
				

				

					05-12
					
					373
					
				

			

		

		

			
				
本章介绍了两种红黑树的扩张一，动态顺序统计秩：在集合线性序中的位置，中序遍历树时输出的位置。顺序统计树：向红黑树的结构中添加一个size域，表示包含自身节点的当前节点的子树节点的数目。（1）查找给定秩的元素OS_SELECT(x,i)
     r = size[left[x]]+1; //先计算x的处于的位置
     if i = r         //x正好是第i小的关键字

			
		

	





	

		

			

				
					
工艺计算MBBR.xls

				
			

			

				

					05-03
				

			

		

		

			
				
污水处理计算书

			
		

	





	

		

			

				
					
object-tracking.zip

				
			

			

				

					05-03
				

			

		

		

			
				
object-tracking.zip

			
		

	





	

		

			

				
					
pyopenjtalk-0.3.3

					
最新发布

				
			

			

				

					05-03
				

			

		

		

			
				
win10/win11下使用， 包含pyopenjtalk-0.3.3-cp39-cp39-win_amd64.whl，pyopenjtalk-0.3.3-cp310-cp310-win_amd64.whl，pyopenjtalk-0.3.3-cp311-cp311-win_amd64.whl三个版本的whl文件，解决GPT_SoVITS中pip install安装pyopenjtalk失败。

			
		

	





	

		

			

				
					
算法导论期末复习python

				
			

			

				

					10-30
				

			

		

		

			
				
使用Python语言进行算法导论的复习是一种很好的选择。Python是一种强大且易于上手的编程语言，具有简洁的语法和丰富的库支持。下面是几个复习的重点：  1. 熟悉Python的基本语法和数据结构：掌握Python的基本数据...

			
		

	



              



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

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值