顺序统计量树的检索元素和秩递归和迭代方法完整代码（C语言）

最新推荐文章于 2023-11-24 22:57:12 发布
最新推荐文章于 2023-11-24 22:57:12 发布
阅读量459 收藏 1
点赞数 1
分类专栏： 算法导论（C语言实现）
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/alike_meng/article/details/82429594
版权

递归检索元素os_select


 node* os_select(tree &t, int i)                             //返回第i小的结点,递归
{
	 node *x = t;
	 int r = x->left->size + 1;
	 if (i == r)
		 return x;
	 else if (i < r)
		 return os_select(x->left, i);
	 else
		 return os_select(x->right, i - r);

}

迭代检索元素os_select

node* os_select_(tree &t, int i)                 //diedai
 {
	 node *x = t;
	 int r = x->left->size + 1;
	 while (i != r)
	 {
		 r = x->left->size + 1;
		 if (i < r)
		 {
			 x = x->left;
			
		 }
		 else if(i>r)
		 {
			 x = x->right;
			 i = i - r;
			
		 }

	 }
	 return x;
 }

递归检索秩os_rank

 int os_rank_(node*x,tree &t, int m)                       //digui
 {
	
	 static int r = x->left->size + 1;
	 node *y = x;
	 if (y==t)
		 return r;
     else
	 {
		 if (y == y->parent->right)
			 r = r + y->parent->left->size + 1;
		 return os_rank_(y->parent,t, m);
	 }
	
	 
 }

迭代检索秩os_rank


 int os_rank(tree &t, int m)                            //返回元素值为x的次序
 {
	 node* x=search(t, m);
	 int r = x->left->size + 1;
	 node  *y = x;
	 while (y != nil)
	 {
		 if (y == y->parent->right)
			 r = r + y->parent->left->size + 1;
		 y = y->parent;
	 }
	 return r;

}

完整代码
从红黑树代码修改而来，主要是加入size，以及在insert和delete和left_rotate、right_rotate时去修改size变化


#include "stdafx.h"
#include<stdio.h>
#include<stdlib.h>
typedef int type;
typedef enum Color   //定义红黑树结点颜色颜色类型  
{
	red = 0,
	black = 1
}Color;
typedef struct rbtree     //定义红黑树的结构
{
	Color color;
	type key;
	type size;
	struct rbtree *left;
	struct rbtree *right;
	struct rbtree *parent;

}node, *tree;

node *nil = NULL;                        //创建一个哨兵结点。这里要用哨兵去让空的叶子结点的颜色是black的，参照红黑树的定义

node* create(type key, node *left, node *right, node *parent,type size)                       //创建结点
{
	node *p;
	node *nil;
	nil = (node*)malloc(sizeof(node));
	p = (node*)malloc(sizeof(node));
	nil->parent = NULL;
	nil->left = NULL;
	nil->color = black;
	nil->key = NULL;
	nil->size = 0;
	p->color = black;                                                        //默认颜色为black
	p->left = left;
	p->right = right;
	p->parent = parent;
	p->key = key;
	p->size = size;
	/*  printf("创造结点完毕");*/
	return p;

}

void left_rotate(tree &t, node *x)                                 //左旋，这个看图就能理解具体操作
{
	if (x->right != nil)
	{
		node *y = x->right;
		x->right = y->left;
		if (y->left != nil)
			y->left->parent = x;
		y->parent = x->parent;
		if (x->parent == nil)
			t = y;
		else
		{
			if (x == x->parent->left)
				x->parent->left = y;
			else
				x->parent->right = y;
		}
		y->left = x;
		x->parent = y;
		y->size = x->size;
		x->size = x->left->size + x->right->size + 1;
	}
	else
	{
		printf("%s/n", "can't execute left rotate due to null right child");
	}
}

void right_rotate(tree &t, node *x)                   //右旋
{
	if (x->left != nil)
	{
		node *y = x->left;
		x->left = y->right;
		if (y->right != nil)
			y->right->parent = x;
		y->parent = x->parent;
		if (x->parent == nil)
			t = 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;
		x->size = x->left->size + x->right->size + 1;
	}

	else
		printf("%s/n", "can't execute right rotate due to null left child");
}


node* search(tree &t, type key)                        //查找元素
{
	node *x = t;
	if (x == nil || x->key == key)
	{

		return t;
	}

	if (key < x->key)
	{

		return search(x->left, key);
	}
	else

	{

		return search(x->right, key);

	}


}                                                                  //递归查找


 node* os_select(tree &t, int i)                             //返回第i小的结点,递归
{
	 node *x = t;
	 int r = x->left->size + 1;
	 if (i == r)
		 return x;
	 else if (i < r)
		 return os_select(x->left, i);
	 else
		 return os_select(x->right, i - r);

}


 node* os_select_(tree &t, int i)                 //diedai
 {
	 node *x = t;
	 int r = x->left->size + 1;
	 while (i != r)
	 {
		 r = x->left->size + 1;
		 if (i < r)
		 {
			 x = x->left;
			
		 }
		 else if(i>r)
		 {
			 x = x->right;
			 i = i - r;
			
		 }

	 }
	 return x;
 }



 int os_rank(tree &t, int m)                            //返回元素值为x的次序
 {
	 node* x=search(t, m);
	 int r = x->left->size + 1;
	 node  *y = x;
	 while (y != nil)
	 {
		 if (y == y->parent->right)
			 r = r + y->parent->left->size + 1;
		 y = y->parent;
	 }
	 return r;

}


 int os_rank_(node*x,tree &t, int m)                       //digui
 {
	
	 static int r = x->left->size + 1;
	 node *y = x;
	 if (y==t)
		 return r;
     else
	 {
		 if (y == y->parent->right)
			 r = r + y->parent->left->size + 1;
		 return os_rank_(y->parent,t, m);
	 }
	
	 
 }



void rb_insert_fixup(tree &t, node* z)
{
	node *y;
	while ((z->parent != nil) && (z->parent->color == red))                                //only when z's parent is red there will probably obey the red node has two black nodes
	{
		if (z->parent == z->parent->parent->left)                //z'parent is the left node
		{

			y = z->parent->parent->right;                         //let y be z's uncle node
			if (y->color == red)                                  //parent and uncle and itself are all red
			{
				z->parent->color = black;
				y->color = black;
				z->parent->parent->color = red;
				z = z->parent->parent;                              //let z up to its grandpa
			}
			else
			{
				if (z == z->parent->right)                         // z is a right node
				{
					z = z->parent;
					left_rotate(t, z);

				}
				z->parent->color = black;
				z->parent->parent->color = red;
				right_rotate(t, z->parent->parent);
			}

		}
		else                                                     //z's parent is the right node
		{
			y = z->parent->parent->left;
			if (y->color == red)
			{

				z->parent->color = black;
				y->color = black;
				z->parent->parent->color = red;
				z = z->parent->parent;
			}

			else
			{

				if (z == z->parent->left)                         // z is a left node
				{
					z = z->parent;
					right_rotate(t, z);
				}
				z->parent->color = black;
				z->parent->parent->color = red;
				left_rotate(t, z->parent->parent);
			}
		}

	}

	t->color = black;                                   //始终保持根节点是黑色
}


node* rb_insert(tree &t, node *z)                        //插入操作
{
	if (t == NULL)                                                  //t是空的树
	{
		t = (tree)malloc(sizeof(node));
		nil = (node*)malloc(sizeof(node));                       //初始化哨兵结点
		nil->color = black;
		nil->size = 0;
		t->left = nil;
		t->right = nil;
		t->parent = nil;
		t->key = z->key;
		t->size = 1;
		t->color = black;
	}

	else
	{
		node *y = nil;
		node *x = t;                             //


		while (x != nil)
		{
			y = x;
			x->size++;
			if (z->key < x->key)
				x = x->left;
			else
				x = x->right;

		}
		z->parent = y;
		if (y == nil)
			t = z;
		else
		{
			if (z->key < y->key)
				y->left = z;
			else
				y->right = z;
		}
		z->left = nil;
		z->right = nil;
		z->color = red;
		z->size = 1;
		//始终保持插入的结点是红色，不符合具体性质了再用fixup调整
		rb_insert_fixup(t, z);
	}
	return t;
}
node* rb_insert_(tree &t, type k)
{
	node *z;
	z = create(k, nil, nil, nil,1);
	return  rb_insert(t, z);
}


node* min(tree &m)                     //最小值
{
	node *n = m;

	if (n == nil)
		return nil;

	while (n->left != nil)
	{
		n = n->left;
	}
	return n;
}

node* successor(node *s)           //后继
{
	node *p;
	node *m = s;                     //代替s去移动
	if (m->right != nil)             //结点右子树非空
	{
		return  min(m->right);
	}
	else
	{
		p = m->parent;                //结点是左孩子，后继就是他的父节点
		while (p != nil && p->right == m)
		{                                       //结点是右孩子，向上查找，直到遇到一个有左孩子的父节点，那就是后继
			{
				m = p;
				p = p->parent;
			}
		}
		return p;
	}

}



void rb_delete_fixup(tree &t, node *x)
{
	node *w;
	while (x != t && x->color == black)                      //
	{
		if (x == x->parent->left)
		{
			w = x->parent->right;
			if (w->color == red)
			{
				w->color = black;
				x->parent->color = red;
				left_rotate(t, x->parent);
				w = x->parent->right;
			}
			if (w->left->color == black && w->right->color == black)
			{
				w->color = red;
				x = x->parent;
			}
			else if (w->right->color == black)
			{
				w->left->color = black;
				w->color = red;
				right_rotate(t, w);
				w = x->parent->right;
			}
			w->color = x->parent->color;
			x->parent->color = black;
			w->right->color = black;
			left_rotate(t, x->parent);
			x = t;                                        //

		}
		else
		{
			w = x->parent->left;
			if (w->color = red)
			{
				w->color = black;
				x->parent->color = red;
				right_rotate(t, x->parent);
				w = x->parent->left;
			}
			if (w->left->color == black && w->right->color == black)
			{
				w->color = red;
				x = x->parent;
			}
			else if (w->left->color == black)
			{
				w->right->color = black;
				w->color = red;
				left_rotate(t, w);
				w = x->parent->right;
			}
			w->color = x->parent->color;
			x->parent->color = black;
			w->left->color = black;
			right_rotate(t, x->parent);
			x = t;                                            //

		}
	}
	x->color = black;
}

node* rb_delete(tree &t, node *z)
{
	node *y, *x;
	node *m = nil;
	node* n = z;
	node *xxx = z->parent;
	if (z->left == nil || z->right == nil)
	{
		while (xxx != nil)
		{
			
			xxx->size--;
			xxx=xxx->parent;
		}
		y = z;
	}
	else
	{
		y = successor(n);
		xxx = y->parent;
		while (xxx != nil)
		{
			
			xxx->size--;
			xxx = xxx->parent;
		}
	                                 //这一行使z的右孩子发生变化
	}
	if (y->left != nil)
		x = y->left;
	else
		x = y->right;
	x->parent = y->parent;
	if (y->parent == nil)
		t = x;                            //
	else
	{
		if (y == y->parent->left)
			y->parent->left = x;
		else
			y->parent->right = x;
	}
	if (y != z)
	{
		z->key = (y->key);

	}
	if (y->color == black)
		rb_delete_fixup(t, x);
	return t;
}

node* rb_delete_(tree &t, type k)
{
	node *z;
	z = search(t, k);

	if (z != nil)
	{
		t = rb_delete(t, z);
	}
	else
		printf("无此元素");
	return t;
}


void print_tree(tree &t)                        //中序遍历打印
{
	if (t != nil && t != NULL)
	{

		print_tree(t->left);
		printf("%7d ,   %5d\n, size= %5d\n ", t->key, t->color,t->size);
		print_tree(t->right);
	}
}

int main()
{
	int i;
	tree zz = NULL, mm = NULL, nn = NULL, xx = NULL, yy = NULL;
	type k;
	int a[12] = { 3,12,15,17,19,55,20,18,36,48,31,29 };
	printf("\n原来的数字是：----------------------------------------\n");
	for (i = 0; i<12; i++)
	{
		printf("%d  ", a[i]);
		zz = rb_insert_(zz, a[i]);
	}

	printf("\n中序遍历是：-------------------------------------------\n");
	printf("规定：red=0,black=1\n");
	print_tree(zz);

	printf("要查询第几小的元素：------------------------------------\n");
	scanf_s("%d", &k);
	printf("%d\n",os_select_(zz, k)->key);                                                    
	printf("要查询哪个元素的秩：-----------------------------------\n");
	scanf_s("%d", &k);
	printf("%d\n", os_rank_(search(zz,k),zz, k));                                          //递归

	printf("\n要删除的值是：---------------------------------------");
	scanf_s("%d", &k);
	yy = rb_delete_(zz, k);
	print_tree(yy);
	printf("\n要插入的值是：--------------------------------------");
	scanf_s("%d", &k);
	rb_insert_(zz, k);
	print_tree(zz);
}
Aloha_up
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法导论第十四章顺序统计量树确定一个元素的秩
小博客
08-03 3964
一个元素的秩即为顺序统计量树中按照中序遍历节点x出现的线性顺序。 循环方式确定元素的秩代码如下： int RankoftheNode(BRTreeNode* x) { int r=x->left->size+1; BRTreeNode*p=x; while(p!=root) { if(p==p->parent->right) { r+=p->parent
二叉树
ThetaQing的博客
04-09 789
序 数据结构大致可以分为两种类型：基于数组的实现与基于链表的实现。就其效率而言，二者各有长短。具体来说，前一实现方式允许我们通过下标或秩，在常数时间内找到目标对象；然而，一旦需要对这些结构进行修改，那么无论是插入还是删除，都需要耗费线性的时间。后者允许我们借助引用或位置对象，在常数的时间内插入或删除元素；但是为了找出居于特定次序的元素，我们不得不花费线性的时间，对整个结构进行遍历查找。 能否将这两...
【C语言】函数（四）：函数递归与迭代，二者有什么区别
liuzhehao的博客
11-24 1778
递归、迭代、两者区别，以及使用递归和迭代时应注意什么。
顺序查找(C语言)
weixin_43369883的博客
05-31 2241
#include #include /*线性表结构体*/ typedef struct List { int *data;//元素数组 int length;//可以写入多少元素 int num;//目前元素个数 }List;
C语言【递归与迭代】-- 附案例
weixin_52937076的博客
09-24 2518
对于像我一样接触函数不久的小小程序员来说“递归”简直是梦魇，这篇文章我就来讲讲我对它的看法，希望能解决它！
c语言-阶乘算法(迭代和递归).docx
12-16
C语言-阶乘算法(迭代和递归) C语言-阶乘算法是计算阶乘的经典算法，包括迭代算法和递归算法两种实现方式。阶乘是数学中的一种运算符号，表示一个数字的所有正整数因子的乘积，如n! = n * (n-1) * (n-2) * (n-3) * ....
C语言使用普通循环方法和递归求斐波那契序列示例代码
09-04
总结来说，这个C语言代码示例展示了如何使用循环和递归两种不同的编程技术来实现斐波那契序列的计算。循环方法适合于处理较大的数值，因为它避免了递归带来的额外开销。而递归方法虽然在较大的n值下效率较低，但其...
Java 递归和迭代的方法详解.pdf
07-02
总的来说，Java程序员在设计代码时应权衡递归和迭代的优缺点，根据实际问题选择合适的方法。同时，了解JVM的优化机制和现代编程实践，可以帮助我们编写更高效、更健壮的代码。在性能敏感的场景下，合理的代码结构和...
C语言非递归线索化树算法代码
最新发布
01-15
下面我们将深入探讨C语言实现非递归线索化树算法的相关知识点。 一、线索二叉树的概念 线索二叉树是在二叉链表的基础上增加线索（thread）以支持非递归遍历。线索分为前向线索和后向线索，用于在树的同一层或不同...
Java中的迭代和递归详解
09-01
Java中的迭代和递归是两种不同的编程方法，用于解决问题或执行任务。这两种方法都有各自的优点和缺点，适用于不同的场景。 **一、递归** 递归是一种函数自我调用的技术，通常涉及将大问题分解为相同或相似的子问题...
算法-顺序统计量
04-03
算法 顺序统计量 期望线性 最坏线性
迭代顺序查找、递归顺序查找、二分查找
06-02
迭代顺序查找、递归顺序查找、二分查找之间的对比
《Alogrithms》算法学习笔记——第五章：贪心
hanhan的博客
01-01 311
几种贪心算法的原理与实现
第五章树与二叉树
tansty_zh的博客
04-08 581
树与二叉树 树的基本概念 基本术语 度 一个结点的孩子个数 层次、高度、深度 路径长度 树根到每个节点的路径的总和 性质 结点数 所有结点的度之和加1 1+n1+2n2+3n3+…+nnn · n1代表度为1的结点，以此类推 各个度的结点相加 n0 +n1+n2+n3+… · n1代表度为1的结点，以此类推 二叉树 定义 二叉树<>度为2的树 特殊二叉树 满二叉树 除叶子结点外度都为2 完全二叉树 每个结点都与满二叉树的一一对应
【数据结构】树的定义和树的三种存储结构
哆啦A梦~~
04-22 734
一、树的定义1.树的定义树（Tree）是n（n&gt;=0）个结点的有限集。n=0时称为空树。在任意一颗非空树中：有且仅有一个特定的称为根（root）的结点；当n&gt;1时，其余结点可分为m(m&gt;0)个互补交互的有限集T1、T2...Tm，其中每一个集合本身又是一棵树，并称为根的子树（SubTree）。Tree2.树的特点n&gt;0时，根节点是唯一的，不可能存在多个根节点。数据结构中的树...
【算法学习】数据结构的扩张
memcpy0的博客
05-20 298
参考算法导论第14章 数据结构的扩张 文章目录1. 动态顺序统计1.1 查找具有给定秩的元素1.2 确定一个元素的秩1.3 对子树规模的维护2. 如何扩张数据结构对红黑树的扩张3. 区间树3.1 步骤一：基础数据结构3.2 步骤二：附加信息3.3 步骤三：对信息的维护3.4 步骤四：设计新的操作 一些工程应用需要的只是一些“教科书”中的标准数据结构，比如双向链表、散列表或二叉搜索树等，然而也有许多其他的应用需要对现有数据结构、进行少许地创新和改造，但只在很少情况下、需要创造出一类全新类型的数据结构。更.
c语言：迭代法
ChenYijia_123的博客
12-19 6166
【源程序】 #include <stdio.h> #include <math.h> int main(void) { double x1,x2=1.0,a; printf("请输入一个大于0的数："); scanf("%lf",&a); if(a<0) //负号不能开方；...
算法导论第十四章数据结构的扩张
z84616995z的专栏
07-09 6347
《算法导论》14数据结构的扩张
并查集的优化——路径压缩和按秩排序
一只立志做最大的咸鱼又不想做咸鱼的小弱鸡
04-13 1300
1.路径压缩如果我们合并的树很深，存放父节点的数组已经嵌套了n层，按照传统的做法，我们从最下面的节点去找n节点就要寻找n次，这种做法效率很低。这时候，我们就可以引入路径压缩的概念，路径压缩就是在递归找到根节点的时候，把当前节点到根节点之间所有节点的父节点都设置为根节点。举个例子：经过路径压缩之后，树的形态就变成了下面的样子：我们可以看到经过路径压缩的节点及其子树到根节点的深度减小了很多，所以在以后...
二分查找递归和非递归c语言代码
05-27
递归实现二分查找的C语言代码： ``` int binarySearch(int arr[], int low, int high, int target) { if (low ) { int mid = low + (high - low) / 2; if (arr[mid] == target) { return mid; } else if (arr...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值