对于n叉树输入以及存储结构改变

最新推荐文章于 2024-07-22 20:42:52 发布
最新推荐文章于 2024-07-22 20:42:52 发布
阅读量776 收藏 16
点赞数 22
分类专栏： n叉树 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mzrcsdn/article/details/138340638
版权

 

       对于二叉树来说，输入时非常easy的，但对于n叉树，尤其时n\geq 2情况时，就显得略先困难。特别的，对于树的不同存储方式之间的转化就显得不是那么的容易，本文就n阶树孩子兄弟法（链式存储）存储转换为孩子法（邻接表）提供一个可靠的方法。

1.结构体的定义： 

邻接表由两部分组成：表头结点表和边表。

     邻接表中每个单链表的第一个结点存放有关顶点的信息，把这一结点看成链表的表头，其余结点存放有关边的信息

（1）表头结点表：包括数据域和链域，数据域存储顶点（data）的名称，链域（first）用于指向链表中第一个结点（与顶点邻接的第一个顶点）

（2）边表：包括邻接点域（指示与顶点邻接的点在图中的位置，即数组下标）、数据域（存储和边相关的信息，如权值）、链域（指示与顶点邻接的下一条边的结点）。

   在此处建立时，我们可以按层次建立：首先定义边表中节点：

struct ctnode {
    int child;
    struct ctnode* next;
};

 随后建立单层头表和边表：

typedef struct cno2 {
    int js;
    char data;
    struct ctnode* first;
}cbox; 

最后，定义多层即可建立：

typedef struct ccno
{
    cbox node[maxsize];
    int n, t;
}haitree; 

定义部分代码：

typedef struct cno {
	char data;
	struct cno* firstchild, * mbro;
}cnode,*ctree;
struct ctnode {
	int child;
	struct ctnode* next;
};
typedef struct cno2 {
	int js;
	char data;
	struct ctnode* first;
}cbox;
typedef struct ccno
{
	cbox node[maxsize];
	int n, t;
}haitree;

 2.树的变形（变为二叉树）

孩子兄弟表示法，采用的是链式存储结构

其存储的实现思想是：从树的根节点开始，依次用链表存储各个节点的孩子节点和兄弟节点

因此，该链表中的节点应包含以下 3 部分内容：

  1. 节点的值
  2. 指向孩子节点的指针
  3. 指向兄弟节点的指针

依据以上方法，可以将n叉树转化为二叉树。

存储结构：

typedef struct cno {
    char data;
    struct cno* firstchild, * mbro;
}cnode,*ctree;

以下为孩子兄弟法代码实现：

ctree creat()
{
	ctree p;
	char x;
	cin >> x;
	if (x == '#')
		return NULL;
	else
	{
		p = (cnode*)malloc(sizeof(cnode));
		p->data = x;
		p->firstchild = creat();
		p->mbro = creat();
	}
	return p;
}

3.n叉树先根和后根遍历

（1）、先根遍历：若树不为空，则先访问根，然后依次先根遍历各棵子树。

（2）、后根遍历：若树不为空，则先依次后根遍历各棵子树，然后再访问根结点。

 

void middletrave(ctree t)
{
	if (t == NULL)
		return;
	else
	{
        cout << t->data << " ";
		middletrave(t->firstchild);
		middletrave(t->mbro);
	}
}
void middletrave(ctree t)
{
	if (t == NULL)
		return;
	else
	{
		middletrave(t->firstchild);
		cout << t->data << " ";
		middletrave(t->mbro);
	}
}

4.孩子兄弟法转化为孩子法（邻接表）

（1）. 表头节点对应值的填入：

          对于邻接表表头节点，就为树中出现的所有字符，因此，可以在遍历书的时候，依次建立         表头节点。

    （为了偷懒，就直接加入到上面的先序遍历中）

haitree ht;
void firsttrave(ctree t)
{
	if (t == NULL)
		return;
	else
	{
		ht.node[ht.n].data = t->data;
		ht.node[ht.n].js++;
		ht.node[ht.n].first = (ctnode*)malloc(sizeof(ctnode));
		ht.node[ht.n].first->child = -1;
		ht.node[ht.n].first->next = NULL;
		ht.n++;

		cout << t->data << " ";
		firsttrave(t->firstchild);
		firsttrave(t->mbro);
	}
}

其中ht定义为全局变量。

 （2）.生成对应的邻接表数据：

      采用递归的方式扫描一个节点处理一个。

      在将节点值对应到具体的头节点时：

   （a).若左孩子不为NULL的（在原本的树结构中存在子节点）可以采用x1和x2记录该节点和该节点的左节点（第一个孩子），将两个和邻接表头节点对应，得到对应的节点号xh1和xh2，生成    节点后接入头节点。

     (b).若有孩子不为NULL（该点和右子点为兄弟关系），因此该点的父节点和右子点为同一个个，只需找到右子点对应的节点号，生成节点后接入。

void bian(ctree t)
{
	if (t->firstchild == NULL && t->mbro == NULL)
		return;
	char x1,x2,x3;
	int xh1,xh2,xh3;
	if (t->firstchild != NULL)
	{
	
		x1 = t->data;
		x2 = t->firstchild->data;
		for (int i = 0; i < ht.n; i++)
		{
			if (ht.node[i].data == x1)
			{
				xh1 = i;
			}
			if (ht.node[i].data == x2)
			{
				xh2 = i;
			}
		}
		ctnode *p,*q;
		p = (ctnode*)malloc(sizeof(ctnode));
		p->child = xh2;
		p->next = NULL;
		q = ht.node[xh1].first;
		if (q->next== NULL)
		{
			q->next = p;
		
		}
		else
		{
	     while (q ->next!= NULL)
		  {
			q = q->next;
		  }
		q->next = p;
		}
	

	}
	if (t->mbro != NULL)
	{
		x1 = t->data;
		x3= t->mbro->data;
		for (int i = 0; i < ht.n; i++)
		{
			if (ht.node[i].data == x1)
			{
				xh1 = i;
			}
			if (ht.node[i].data == x3)
			{
				xh3 = i;
			}
			
		}
		ctnode* p, * q;
		p = (ctnode*)malloc(sizeof(ctnode));
		p->child = xh3;
		p->next = NULL;
		q = ht.node[xh1].first;
		if (q->next == NULL)
		{
			q->next = p;
		
		}
		else
		{
	while (q->next != NULL)
		{
			q = q->next;
		}
		q->next = p;

		}
	
	}
	if(t->firstchild!=NULL)
	  bian(t->firstchild);
	if(t->mbro!=NULL)
	  bian(t->mbro);
}

5.输出邻接表结构

void ctrave(cbox p)
{
	ctnode *q;
	q = p.first;
	q = q->next;
	while (q != NULL)
	{
		cout << q->child << " ";
		q = q->next;
	}
}

      通过以上的方法，我们可以将孩子兄弟法（链表）轻松的转化为孩子法（邻接表），并将其结构输出。

以下是源代码：

#include<bits/stdc++.h>
using namespace std;
#define maxsize 100
typedef struct cno {
	char data;
	struct cno* firstchild, * mbro;
}cnode,*ctree;
struct ctnode {
	int child;
	struct ctnode* next;
};
typedef struct cno2 {
	int js;
	char data;
	struct ctnode* first;
}cbox;
typedef struct ccno
{
	cbox node[maxsize];
	int n, t;
}haitree;
haitree ht;
ctree creat()
{
	ctree p;
	char x;
	cin >> x;
	if (x == '#')
		return NULL;
	else
	{
		p = (cnode*)malloc(sizeof(cnode));
		p->data = x;
		p->firstchild = creat();
		p->mbro = creat();
	}
	return p;
}
void firsttrave(ctree t)
{
	if (t == NULL)
		return;
	else
	{
		ht.node[ht.n].data = t->data;
		ht.node[ht.n].js++;
		ht.node[ht.n].first = (ctnode*)malloc(sizeof(ctnode));
		ht.node[ht.n].first->child = -1;
		ht.node[ht.n].first->next = NULL;
		ht.n++;

		cout << t->data << " ";
		firsttrave(t->firstchild);
		firsttrave(t->mbro);
	}
}
void middletrave(ctree t)
{
	if (t == NULL)
		return;
	else
	{
		middletrave(t->firstchild);
		cout << t->data << " ";
		middletrave(t->mbro);
	}
}
void bian(ctree t)
{
	if (t->firstchild == NULL && t->mbro == NULL)
		return;
	char x1,x2,x3;
	int xh1,xh2,xh3;
	if (t->firstchild != NULL)
	{
	
		x1 = t->data;
		x2 = t->firstchild->data;
		for (int i = 0; i < ht.n; i++)
		{
			if (ht.node[i].data == x1)
			{
				xh1 = i;
			}
			if (ht.node[i].data == x2)
			{
				xh2 = i;
			}
		}
		ctnode *p,*q;
		p = (ctnode*)malloc(sizeof(ctnode));
		p->child = xh2;
		p->next = NULL;
		q = ht.node[xh1].first;
		if (q->next== NULL)
		{
			q->next = p;
		
		}
		else
		{
	     while (q ->next!= NULL)
		  {
			q = q->next;
		  }
		q->next = p;
		}
	

	}
	if (t->mbro != NULL)
	{
		x1 = t->data;
		x3= t->mbro->data;
		for (int i = 0; i < ht.n; i++)
		{
			if (ht.node[i].data == x1)
			{
				xh1 = i;
			}
			if (ht.node[i].data == x3)
			{
				xh3 = i;
			}
			
		}
		ctnode* p, * q;
		p = (ctnode*)malloc(sizeof(ctnode));
		p->child = xh3;
		p->next = NULL;
		q = ht.node[xh1].first;
		if (q->next == NULL)
		{
			q->next = p;
		
		}
		else
		{
	while (q->next != NULL)
		{
			q = q->next;
		}
		q->next = p;

		}
	
	}
	if(t->firstchild!=NULL)
	  bian(t->firstchild);
	if(t->mbro!=NULL)
	  bian(t->mbro);
}
void ctrave(cbox p)
{
	ctnode *q;
	q = p.first;
	q = q->next;
	while (q != NULL)
	{
		cout << q->child << " ";
		q = q->next;
	}
}
int main()
{
	ctree t;
	ht.node->js = 0;
	ht.n = 0;
	cout << "此方法用于树（n叉树，n>=2)。输入时用树和二叉树关系转化为二叉树" << endl;
	t = creat();
	cout << "先根遍历：";
	firsttrave(t);
	cout << endl;
	cout << "后根遍历:" << endl;
	middletrave(t);
	cout << endl;
	bian(t);
	cout << "孩子兄弟表示法（邻接表）"<<endl;
	for (int i = 0; i < ht.n; i++)
	{
		cout <<i<<" "<< ht.node[i].data << " ";
		ctrave(ht.node[i]);
		cout << endl;
	}
}

mzrcsdn
关注
  • 22
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
满m叉树的算法以及皇后棋盘走法的算法实现
05-07
满m叉树是一种特殊的树形数据结构，每个节点有m个子节点，而皇后棋盘问题则是一个经典的计算机科学中的问题，它涉及到如何在n×n的棋盘上放置n个皇后，使得任意两个皇后都无法在同一行、同一列或同一斜线上攻击到...
计算机系统结构课件：第7章 互连网络.ppt
06-26
4. **拓扑结构**：静态拓扑结构具有固定的连接路径，无法在运行时改变；动态拓扑结构则可以根据需要设置开关，灵活调整连接路径。 互连网络的核心概念之一是**互连函数**，它定义了输入端与输出端之间的对应关系，...
quicksort.zip_数据结构_C/C++_
08-12
最坏的情况发生在输入序列已经排序或几乎排序时，此时时间复杂度会退化为O(n^2)。然而，这种情况在实际应用中很少出现，且可以通过随机化选择基准来避免。 在C++中实现快速排序，可以使用函数递归的方式。`...
计算机组成与结构习题答案
10-16
这不仅涉及硬件的各个组件，如处理器、内存、输入/输出系统，还包括指令集架构、寻址模式以及数据操作等核心概念。本章节我们将通过分析习题来深入探讨这些知识点。 首先，指令集是计算机的基础，它定义了计算机...
计数，桶与基数排序
m0_68142120的博客
07-19 857
要进行 i(最高位的位数) 趟排序 ， 每趟排序需要将元素分派到k个桶，所以每趟排序的时间复杂度为O(n+k) 走i趟时间复杂度就为O(i(n+k)) 但桶的个数通常是固定的，执行的躺数一般又较小，所以基数排序的。如果待排序的元素数量很大，这可能会占用较多的内存空间。再次遍历待排序数组，对于数组中的每个元素，将其值减去最小值（为了使得计数数组的下标从0开始），并将计数数组中对应下标的值加1。如果待排序数组中的元素是负数，或者元素的取值范围较大，计数排序可能不适用，因为它需要额外的空间来存储计数数组。
数组算法--基本查找
2303_78660417的博客
07-20 420
基本查找就是从数组的0索引处开始，依次往后查找，如果找到了对应索引处的值，就会，如果没有找到。因为数组的索引号是没有-1的，当返回-1的时候，就能明白没有找到。
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
铁匠匠匠的博客
07-18 1097
可以参考以下视频。
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 270
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
数据结构---二叉树
weixin_47808575的博客
07-22 172
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
数据结构第35节 性能优化 算法的选择
hummhumm的专栏
07-18 762
算法的选择对于优化程序性能至关重要。不同的算法在时间复杂度、空间复杂度以及适用场景上有着明显的差异。下面我将结合具体的代码示例，来讲解几种常见的算法选择及其优化方法。
数据结构——栈
weixin_45942515的博客
07-19 452
1、栈的英文为stack2、栈是先入后出（FILO-First In Last Out）的有序列表。3、栈stack是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶 (Top)，另一端固定的一端，称为栈底(Bottom)。4、根据栈的定义可知，最先放入栈中的元素在栈底，最后放入栈中的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。
【数据结构】堆的实现以及建堆算法和堆排序
2301_81670477的博客
07-19 1069
哈喽，各位小伙伴大家好！上期给大家讲了树，二叉树以及堆。今天带着大家实现堆这个数据结构，以及堆排序。话不多说，咱们进入正题！向大厂冲锋！
数据结构之细说链表
m0_73634434的博客
07-17 1096
这里while循环的条件判断必须是tail->next->next，因为我们需要释放最后一个节点的地址，所以需要利用它前面一共节点来释放它，然后将tail->next置空，如果我们直接找最后一个地址然后将它释放前面一个节点就会指向被释放的地址变成一个野指针，因为我们已经找不到前面一个节点的位置了。头插就比较简单了，将该节点连接在第一个节点和第二个节点之间就可以了，但是我们需要先连接第二个和新节点，如果先连接第一个节点和新节点就会找不到第二个节点的地址。下面我们给出链表的构成，看看链表是如何解决这些问题的。
24暑假算法刷题 | Day16 | LeetCode 513. 找树左下角的值，112. 路径总合，106. 从中序和后序遍历序列构造二叉树
weixin_54468359的博客
07-18 1137
24暑假刷题day15打卡 二叉树进阶
数据结构（队列）
2401_83968713的博客
07-19 555
这么看好像两者的差别不大，但是我们在单链表结构中可以稍作改造，直接定义两个结点（头结点，尾结点）指向原链表的队头和队尾，那么在队尾入数据时就不用遍历链表，直接让尾结点->next 等于新结点，时间复杂度就变成 O(1)了。概念：只允许在⼀端进⾏插⼊数据操作，在另⼀端进⾏删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)⼊队列操作的时间复杂度为 O(1) ,进行出队列操作的时间复杂度为 O(n);⼊队列：进⾏插⼊操作的⼀端称为队尾。出队列：进⾏删除操作的⼀端称为队头。
数据结构(5.2_3)——二叉树的存储结构
m0_65240792的博客
07-19 312
1%29%5D1。
数据结构~~顺序表
最新发布
TU^的博客
07-22 632
定义：顺序表是用一组连续的存储单元依次存储数据元素的线性结构。特点：1. 逻辑顺序与物理顺序一致：元素顺序存储，相邻元素物理位置相邻。2. 可以快速访问任意元素：通过索引直接访问元素。优点：1. 实现简单。2. 随机访问方便。缺点：1. 插入、删除操作可能需要移动大量元素，效率较低。2. 需要预先确定固定的存储空间，可能造成空间浪费或不足。基本操作：包括初始化、插入、删除、查找、遍历等。
树的存储结构：孩子表示法与二叉树解析
孩子表示法，也称为孩子链表法，是一种用于存储树结构的方法，每个节点包含指向其所有子节点的指针或引用。例如，给定的描述中的图形表示了一棵树，其中每个节点都有编号，根节点编号为0，其他节点按层次排列。这种...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值