Josephus排列-红黑树实现-链表实现

最新推荐文章于 2021-12-14 10:01:55 发布
最新推荐文章于 2021-12-14 10:01:55 发布
阅读量945 收藏
点赞数
分类专栏： 算法导论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shakingWaves/article/details/20153243
版权 
#include <iostream>
#include<ctime>
using namespace std;
typedef struct list{
	int value;
	list *next;
}list, *pList;

pList build_cirle_list(int n)//创建单向循环链表
{
	pList head=new list;
	pList pl,pp=head;
	for(int i=0;i<n;++i){
		pl=new list;
		pl->value=i+1;
		pp->next=pl;
		pp=pl;
	}
	pp->next=head;
	return head;
}

void josephus_permutation(pList & pl,int m)//josephus 排列
{
	pList pp=pl;
	pList pt;//存放输出元素的上一个元素指针
	while (pp!=pp->next){//判断是否已经是头指针，如果是，则所有元素都已经访问，结束循环		
		for(int i=0;i<m;++i){
			pt=pp;
			pp=pp->next;
			if(pp==pl){//若结点是头指针，则 继续访问下一个元素
				pt=pp;
				pp=pp->next;
			}
		}		
		cout<<pp->value<<"\t";
		pt->next=pp->next;
		delete pp;//删除已经访问过的元素
		pp=pt;//重置pp为已访问元素的上一个指针
	}
	cout<<endl;	
}

int main()
{
	srand((unsigned)time(NULL));
	int n;
	while(n=rand()%20,n<7);
	int m;
	while(m=rand()%10,m<2 && m>n);
	n=100,m=20;
	cout<<"Josephus permutation : n = "<<n<<" ,m = "<<m<<endl; 
	pList head=build_cirle_list(n);	
	josephus_permutation(head,m);
	
}

#include<iostream>
#include <ctime>
#include <limits>
using namespace std;

typedef struct rb_node{//带父节点的二叉树
	int value;
	rb_node *left,*right,*parent;
	bool rb;//rb=0表示结点,rb=1表示红结点
	int size;//存储左右子树大小和该结点之和
}rb_node,*pRBNode;

pRBNode nil;//所有结点的公共黑色结点，类似于NULL

void binary_tree_left_rotation(pRBNode &pn,pRBNode y)//二叉搜索树左旋
{
	pRBNode x=y->right;
	y->right=x->left;
	if(x->left!=nil){
		x->left->parent=y;
	}
	x->parent=y->parent;
	if(y->parent==nil){
		pn=x;
	}else if(y==y->parent->left){
		y->parent->left=x;
	}else{
		y->parent->right=x;
	}
	x->left=y;
	y->parent=x;
	x->size=y->size;//更新相应结点值
	y->size=y->left->size+y->right->size+1;
}

void binary_tree_right_rotation(pRBNode &pn,pRBNode x)//二叉搜索树右旋
{
	pRBNode y=x->left;
	x->left=y->right;
	if(y->right!=nil){
		y->right->parent=x;
	}
	y->parent=x->parent;
	if(x->parent==nil){
		pn=y;
	}else if(x==x->parent->left){
		x->parent->left=y;
	}else{
		x->parent->right=y;
	}
	y->right=x;
	x->parent=y;
	y->size=x->size;//更新相应的size值
	x->size=x->left->size+x->right->size+1;
}

void rb_tree_insert_fixup(pRBNode &pn,pRBNode pz)//红黑结点修复
{
	while(pz->parent->rb){//子结点父结点均为红结点
		pRBNode y;
		if(pz->parent==pz->parent->parent->left){//当前结点的父结点是当前结点父结点的父节点的左子树
			y=pz->parent->parent->right;
			if(y->rb){//堂叔为红结点,case one
				pz->parent->rb=0;
				pz->parent->parent->rb=1;
				y->rb=0;
				pz=pz->parent->parent;
			}else{
				if(pz==pz->parent->right){//case two
					pz=pz->parent;
					binary_tree_left_rotation(pn,pz);
				}
				pz->parent->rb=0;		//case three
				pz->parent->parent->rb=1;
				binary_tree_right_rotation(pn,pz->parent->parent);
			}
		}else{//当前结点的父结点是当前结点父结点的父节点的右子树
			y=pz->parent->parent->left;
			if(y->rb){//堂叔结点是红色
				pz->parent->rb=0;
				pz->parent->parent->rb=1;
				y->rb=0;
				pz=pz->parent->parent;
			}else{
				if(pz==pz->parent->left){//case two
					pz=pz->parent;
					binary_tree_right_rotation(pn,pz);
				}
				pz->parent->rb=0;//case three
				pz->parent->parent->rb=1;
				binary_tree_left_rotation(pn,pz->parent->parent);
			}			
		}
		pn->rb=0;
	}
}

void binary_tree_insert(pRBNode &pn,pRBNode pz)
{	
	pRBNode x=pn;
	pRBNode y=nil;
	while (x!=nil){
		y=x;
		x->size++;//相应路径上的结点的子结点个数加1
		if(pz->value<=x->value){
			x=x->left;
		}else{
			x=x->right;
		}
	}
	if(y==nil){
		pn=pz;
		pn->rb=0;
	}else if(pz->value<=y->value){
		y->left=pz;		
	}else{
		y->right=pz;
	}
	pz->parent=y;
	rb_tree_insert_fixup(pn,pz);//插入结点后可能会破坏红黑树的性质，
}
void build_binary_search_tree(pRBNode &pn,int n)//建立n个具有父节点的二叉搜索树
{
	//int value;
	pRBNode ptmp;
	//int a[10]={-2,-3,4,-3,-5,5,5,3,-3,0};
	for(int i=0;i<n;++i){
		//value=rand()%101-50;
		ptmp=new rb_node;
		ptmp->left=nil;
		ptmp->right=nil;
		ptmp->parent=nil;
		ptmp->value=/*a[i]*//*value*/i+1;
		ptmp->rb=1;//红结点
		ptmp->size=1;
		//cout<</*value*//*a[i]*/i+1<<"\t";
		binary_tree_insert(pn,ptmp);
	}
	//cout<<endl;
}
void InOrder(pRBNode pn)//中序遍历
{
	if(pn!=nil){
		InOrder(pn->left);
		cout<<pn->value<<"\t";
		InOrder(pn->right);
	}
}

pRBNode binary_tree_search(pRBNode pn,int key)//二叉搜索树查找
{
	pRBNode pp=pn;
	while (pp !=nil && key != pp->value){
		if(key<pp->value){
			pp=pp->left;
		}else{
			pp=pp->right;
		}
	}
	return pp;		
}

pRBNode binary_tree_maximum(pRBNode pn)//最大值
{
	while (pn!=nil && pn->right!=nil){
		pn=pn->right;
	}
	return pn;
}

pRBNode binary_tree_minimux(pRBNode pn)//最小值
{
	while(pn!=nil && pn->left!=nil){
		pn=pn->left;
	}
	return pn;
}

pRBNode binary_tree_successor(pRBNode pz)//后继结点
{
	if(pz->right!=nil){
		return binary_tree_minimux(pz->right);
	}
	pRBNode p=pz->parent;//父亲节点
	while(p!=nil && pz==p->right){
		pz=p;
		p=p->parent;
	}
	return p;
}

pRBNode binary_tree_predecessor(pRBNode pz)
{
	if(pz->left!=nil){
		return binary_tree_maximum(pz->left);
	}
	pRBNode p=pz->parent;
	while(p!=nil && pz==p->left){
		pz=p;
		p=p->parent;
	}
	return p;
}

void rb_transplant(pRBNode &pn,pRBNode u,pRBNode v)//红黑树删除操作辅助程序
{
	if(u->parent==nil){
		pn=v;
	}else if(u==u->parent->left){
		u->parent->left=v;
	}else{
		u->parent->right=v;
	}
	v->parent=u->parent;
}

void rb_delete_fixup(pRBNode &pn,pRBNode px)//红黑树 删除操作修正
{
	while(px!=pn && 0==px->rb){
		pRBNode pw;//px的兄弟结点
		if(px==px->parent->left){//px为左子结点
			pw=px->parent->right;
			if(pw->rb){//兄弟结点为红色,case one
				px->parent->rb=1;
				pw->rb=0;
				binary_tree_left_rotation(pn,px->parent);//左旋转
				pw=px->parent->right;
			}
			if(pw->left->rb==0 && pw->right->rb==0){//case two
				pw->rb=1;
				px=px->parent;
			}
			else{ 
				if(pw->right->rb==0){//case three
					pw->left->rb=0;
					pw->rb=1;				
					binary_tree_right_rotation(pn,pw);
					pw=px->parent->right;
				}
				pw->rb=px->parent->rb;
				px->parent->rb=0;
				pw->right->rb=0;				
				binary_tree_left_rotation(pn,px->parent);
				px=pn;
			}
		}else{//px为右子结点
			pw=px->parent->left;
			if(pw->rb){
				px->parent->rb=1;
				pw->rb=0;
				binary_tree_right_rotation(pn,px->parent);
				pw=px->parent->left;
			}
			if(pw->left->rb==0 && pw->right->rb==0){
				pw->rb=1;
				px=px->parent;
			}else{
				if(pw->left->rb==0){
					pw->right->rb=0;
					pw->rb=1;
					binary_tree_left_rotation(pn,pw);
					pw=px->parent->left; 
				}
				pw->rb=px->parent->rb;
				px->parent->rb=0;
				pw->left->rb=0;
				binary_tree_right_rotation(pn,px->parent);
				px=pn;
			}
		}
	}
	px->rb=0;
}

void rb_delete(pRBNode &pn,pRBNode pz)
{
	pRBNode ptm;//存储调整size的结点
	pRBNode py=pz;//py记录pz或者pz的后继
	bool y_org_color=py->rb;//记录删除结点的颜色
	pRBNode px;//px记录py的右结点
	if(pz->left==nil){
		px=py->right;
		ptm=pz->parent;
		rb_transplant(pn,pz,pz->right);
	}else if(pz->right==nil){
		px=py->left;
		ptm=pz->parent;
		rb_transplant(pn,pz,pz->left);
	}else{
		py=binary_tree_minimux(pz->right);//pz的后继
		ptm=py->parent;
		px=py->right;//py的后继
		y_org_color=py->rb;
		if(py==pz->right){
			px->parent=py;
		}else{
			rb_transplant(pn,py,py->right);
			py->right=pz->right;
			py->right->parent=py;
		}
		rb_transplant(pn,pz,py);
		py->left=pz->left;
		py->left->parent=py;
		py->rb=pz->rb;
		py->size=py->left->size+py->right->size+1;//修改新结点的size值
	}
	while (ptm!=nil){//更新结点的size值
		ptm->size--;
		ptm=ptm->parent;
	}

	delete pz;
	if(0==y_org_color){//被删除或者被调整为的内部结点为黑色
		rb_delete_fixup(pn,px);
	}
}

pRBNode os_select(pRBNode pn,int i)//选择红黑树中的第i个元素
{
	int r=pn->left->size+1;
	if(r==i){
		return pn;
	}else if(i<r){
		return os_select(pn->left,i);
	}else{
		return os_select(pn->right,i-r);
	}
}

int os_rank(pRBNode pn,pRBNode pz)//求红黑树中pz的秩
{
	int r=pz->left->size+1;
	while(pz!=pn){
		if(pz==pz->parent->right){
			r+=pz->parent->left->size+1;
		}
		pz=pz->parent;
	}
	return r;
}

pRBNode os_successor(pRBNode pn,pRBNode pz,int i)//确定pz的第i个后继
{
	int r=os_rank(pn,pz);
	r+=i;
	return os_select(pn,r);
}

void Josephus_permutation(pRBNode &pn,int n,int m)
{
	int j=1;
	pRBNode p;
	for(int k=n;k>0;k--){
		j=(j+m-2)%k+1;
		p=os_select(pn,j);
		cout<<p->value<<"\t";
		rb_delete(pn,p);
	}
	cout<<endl;
}

int main()
{
	srand((unsigned)time(NULL));
	int n=100;

	nil=new rb_node;
	nil->left=nil;
	nil->right=nil;
	nil->rb=0;//黑色
	nil->parent=nil;
	nil->value=numeric_limits<int>::min();
	nil->size=0;//nil结点大小为0
	pRBNode pn=nil;
	int m=20;
	build_binary_search_tree(pn,n);
	cout<<"Josephus permutation : n = "<<n<<" ,m= "<<m<<endl;
	Josephus_permutation(pn,n,m);	
}

shakingWaves
关注
专栏目录
算法导论 红黑树的扩张 动态顺序统计
苦海无涯闯进来
05-16 437
1
Josephus排列
z84616995z的专栏
07-19 2197
约瑟夫排列
红黑树的插入删除-红黑树动态顺序统计
shakingWaves的专栏
02-25 938
#include #include #include using namespace std; typedef struct rb_node{//带父节点的二叉树 int value; rb_node *left,*right,*parent; bool rb;//rb=0表示结点,rb=1表示红结点 int size;//存储左右子树大小和该结点之和 }rb_node,*pRBNo
动态查找---->红黑树（Red-Black Tree）
weixin_34146805的博客
04-06 121
红黑树 （Red-Black Tree）   红黑树是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。它是复杂的，但它的操作有着良好的最坏情况运行时间，并且在实践中是高效的: 它可以在O(logn)时间内做查找，插入和删除，这里的n是树中元素的数目。包含n个内部节点的红黑树的高度是 O(log(n))。 一、性质 红黑树是每个节点都带有颜色属性的二叉查找...
Python链表深度解析：单向与双向链表的实现艺术
!...# 1. 链表的基本概念与特性 ## 1.1 链表的定义与重要性 链表是一种基础且重要的数据结构，在计算机科学...链表可以分为几种不同的类型，主要包括单向链表、双向链表、循环链表和双向循环链表。每种类型的链表都适用于
编程-数据结构篇
楚门的世界
08-19 751
1. 字符串移位问题，判断S是否能被L移位得到解: S可以由L移位得到，那么S一定在LL上，调用strstr函数即可，或者python中的in判断、find操作。2. 电话号码对应单词解：构建号码对应字母的排列树，定义二维数组a[10][10]={””,””,”ABC”,”DEF”…”WXYZ”},for循环，遍历3. 计算字符串相似度递归 三种情况4. 从无头链表中删除节点A->B
数据结构Leetcode（一）
wm_mmmmm的博客
12-14 608
线性结构：线性表 （数组、链表、 栈、队列、 哈希表） 树形结构：二叉树（AVL树、红黑树、B树、堆、Trie、哈夫曼树、并查集） 图形结构：邻接矩阵、邻接表 1.线性表 线性表是具有 n 个相同类型元素的有限序列（ n ≥ 0 ） 1.1.数组 数组是一种顺序存储的线性表，所有元素的内存地址是连续的（new向堆空间申请一段存储空间） int array[]=new int[] {11,22,33} ...
顺序统计树
zhanglei8893的专栏
06-06 6047
      在包含n个元素的无序集合中，寻找第i个顺序统计量的时间复杂度为O(n)。通过建立一种特定的结构，可以使得任意的顺序统计量都可以在O(lgn)的时间内找到。这就是下面会提到的基于红黑树的顺序统计树。      相比于基础的数据结构，顺序统计树增加了一个域size[x]。这个域包含以x为根的子树的节点数(包含x本身)。size域满足等式：                      
Josephus 排列
s_x_q的博客
07-24 583
《算法导论第三版》14-2 P.202 Josephus 排列 n个人排成环，并从1到n编号，给定正整数m，从第一个人开始报数，每次报到m的那个人出列，求人员出列的排列，称为(n,m)-Josephus 排列1、假定m的常数，找出O(n)的算法完成(n,m)-Josephus排列最直观的方法，让这n个人组成环形队列，遍历m个结点才能出一个人，(n,m)-Josephus排列需要m*n次遍历，由于m
红黑树-动态演示生成红黑树
09-30
红黑树算法，随机产生数字，动态生成红黑树，可用于演示。
(001)HashMap之链表转红黑树-treefyBin方法.docx
06-17
详细解读了HashMap中链表转红黑树的treefyBin方法，该方法中涉及到的诸如：replacementTreeNode方法、treeify方法、comparableClassFor方法、compareComparables方法、tieBreakOrder方法、balanceInsertion方法、moveRootToFront 方法、rotateLeft方法、rotateRight方法、checkInvariants 方法均有详细解读
josephus排列问题
12-11
(1)用抽象数据类型表设计一个求(n,m)Josephus排列的算法。 (2)试设计一个算法，对于给定的正整数n和1，2，…，n中的k个数。求正整数m，使 (n,m)Josephus排列的前k个数恰为事先指定的这k个数(顺序必须完全一样)。
C语言单链表实现红黑树
妖言的博客
08-15 279
红黑树是一种自平衡二叉查找树。它是复杂的，但它的操作有着良好的最坏情况运行时间，并且在实践中是高效的：它可以在O(log n)时间内做查找，插入和删除，这里的n 是树中元素的数目。红黑树的查找性能和AVL相对稍弱一点，但是实践表明，红黑树的插入过程中所需要进行的节点旋转次数比AVL树的要小。它的统计性能要好于平衡二叉树（AVL-树），因此红黑树在很多地方都有运用。 红黑树是每个节点都带有颜色属性的...
HashMap之 链表转红黑树
zhang2383906154的博客
11-15 5573
当链表长度大于等于TREEIFY_THRESHOLD（默认8）时，同时链表长度大于等于 MIN_TREEIFY_CAPACITY(默认64)就会触发链表转红黑树的情况，当然，在删除(remove)数据或其它原因调整了大小，当红黑树节点小于或等于6以后，会回复成链表形态。 1、为什么链表要转红黑树 每次遍历链表，平均查询的时间复杂度是O(n),n是链表长度。红黑树和链表的查询性能不一样 由于红黑树自平衡的特点，可以防止不平衡的情况发生，所以红黑树把查询的时间复杂度始...
【动态图文详解，史上最易懂的红黑树讲解】手写红黑树（Red Black Tree）
程序员光剑
10-30 9770
红黑树：一棵自平衡（AVL）+二叉查找树(BST) 什么是红黑树红黑树，Red-Black Tree 「RBT」是一个自平衡(不是绝对的平衡)的二叉查找树(BST)。红黑树是在1972年由Rudolf Bayer发明的，当时被称为平衡二叉B树（symmetric binary B-trees）。后来，在1978年被 Leo J. Guibas 和 Robert Sedgewick 修改为...
动态顺序统计
小梦馆
07-19 1572
在之前的随机选择算法中，我们可以很快的在集合中寻找到第i小的元素，然而，这样的集合并不支持动态的扩充。这一节里，将介绍通过红黑树（具体可参考红黑树1，红黑树2两篇文章）的扩充，使得任意的顺序统计量都可以在短时间内查找到，而这样的数据结构同时也支持数据的更新。 这样的数据结构称为顺序统计树，如下图。树的节点大致上与红黑树的类似，但增加了一个记录子树大小的域size[x]，定义哨兵Nil的子树大小为
算法导论--动态顺序统计与区间树
勿在浮砂筑高台
05-20 4815
本文的基础是红黑树 算法导论–红黑树通过在基础的数据结构中添加一些附加信息，来扩张一种标准的数据结构，然后编写新的操作来支持所需要的应用。下面是介绍在红黑树的基础上扩张的数据结构。1.动态顺序统计动态顺序统计可以在O(lgn)时间内确定任何的顺序统计量(即在n个元素的集合中，能在O(lgn)的时间内确定第i小的元素)，同时也可以在O(lgn)的时间内计算一个元素的秩(即它在中序遍历下的位置顺序)
红黑树——动态+静态图
鱼尾九八
02-06 362
不忘初心，砥砺前行作者 | 陌无崖转载请联系授权目录概念引入折半法二叉查找树AVL红黑树特点维持平衡变化规则变色左旋右旋示例动态旋转概念引入假如我们遇到一个猜数字的题，即给定一个序列...
Josephus环的C语言实现与解析
"约瑟夫环的实现代码是基于C语言的，利用单向循环链表作为数据结构来解决该问题。程序允许用户输入约瑟夫环的参数，包括人数n、起始位置s和报数间隔m，然后输出按照规则出列的顺序。例如，当n=8，s=1，m=4时，输出的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值