C语言:双亲表示法的树转化为孩子兄弟的二叉树,再转化回树

在这里插入图片描述

空间数据结构上机作业

上机要求:

读取文件中用双亲表达的树,打印出来;然后转化成链表的孩子兄弟的二叉树,打印;然后再转化成树

练习文本TreeByParent.txt附上:
0 10
R 0
A 1
B 1
C 1
D 2
E 2
F 4
G 7
H 7
K 7

DS init code 2024/4/27 by 废柴

#include<stdio.h>
#include<stdlib.h>
#include<memory.h>
const char* infilename = "D:\\c practice data\\TreeByParent.txt";
//定义双亲表示的树
typedef struct {
	char ch;
	int  parent;
}PTNode;
//定义孩子兄弟表示法的二叉树
typedef struct BTNode{
	char ch;
	BTNode* fchild;
	BTNode* nsbl;
}BTNode;
//1.从文件中读取文件创建树
PTNode*createPTree(const char* infilename, int* n);
//1.1打印树
void printPTree(PTNode nodes[], int n);
//2.转化为孩子兄弟的二叉树
BTNode* convertToB(PTNode nodes[],int n);
//3.打印二叉树
void printBTree(BTNode* root,int n);
//4.将孩子兄弟二叉树重新变成树
PTNode* recover(BTNode* root, int n);
int main() {
	int n = 0;
	PTNode*nodes= createPTree(infilename, &n);
	BTNode* root = convertToB(nodes, n);
	printf("convert to Binary Tree:\n");
	printBTree(root,n);
	PTNode* tree2 = recover(root, n);
	free(nodes);
	free(root);
	free(tree2);
	return 0;
}
//1.从文件中读取文件创建树
PTNode* createPTree(const char* infilename, int* n) {
	FILE* fp = fopen(infilename, "r");
	if (fp == NULL) {
		printf("file open error\n");
		return NULL;
	}
	char ch = 0;
	fscanf(fp, "%c %d\n", &ch, n);
	PTNode* nodes = (PTNode*)malloc(sizeof(PTNode) * (*n));
	memset(nodes, 0, sizeof(PTNode) * (*n));
	for (int i = 0; i < (*n); i++) {
		char ch;
		int parent;
		fscanf(fp, "%c %d\n", &ch, &parent);
		nodes[i].ch = ch;
		nodes[i].parent = parent-1;
	}
	fclose(fp);
	printPTree(nodes, (*n));
	return nodes;

}
//1.1打印树
void printPTree(PTNode*nodes, int n) {
	for (int i = 0; i < n; i++) {
		printf("%d value:%c parent:%d\n",i, nodes[i].ch, nodes[i].parent);
	}
	return;
}
//2.转化为孩子兄弟的二叉树
BTNode* convertToB(PTNode nodes[], int n) {
	BTNode* tree = (BTNode*)malloc(sizeof(BTNode) * n);
	memset(tree, 0, sizeof(BTNode) * n);
	//创建结点并建立父子关系
	for (int i = 0; i < n; i++) {
		BTNode* temp = &tree[i];
		temp->ch = nodes[i].ch;
		//判断是否是根结点
		if (nodes[i].parent != -1) {
			BTNode* parent = &tree[nodes[i].parent];
			//存储当前结点的parent
			//继续判断是否是fchild
			if (parent->fchild == NULL) {
				parent->fchild = temp;
			}
			else {
				//此时不是第一个孩子,那就要循环找到最后一个哥哥
				BTNode* sibling = parent->fchild;
				while (sibling->nsbl != NULL) {
					sibling = sibling->nsbl;
				}sibling->nsbl = temp;
			}
		}
	}
	//找到根节点返回
	for (int i = 0; i < n; i++) {
		if (nodes[i].parent == -1) {
			return &tree[i];
		}
	}
	return NULL;
}
//3.打印二叉树
void printBTree(BTNode* T ,int n) {
	if (T == NULL) {
		printf("空\n");
		return;
	}
	for (int i = 0; i < n; i++)
	{
		printf("%d value:%c ", i, T[i].ch);
		if (T[i].fchild != NULL) {
			printf("fchild->%c ", T[i].fchild->ch);
		}
		else printf("fchild->NULL ");
		if (T[i].nsbl != NULL) {
			printf("nsbl->%c\n", T[i].nsbl->ch);
		}
		else printf("nsbl->NULL\n");
	}
	return;
}
//4.将孩子兄弟二叉树重新变成树
PTNode* recover(BTNode* root, int n) {
	PTNode* tree2 = (PTNode*)malloc(sizeof(PTNode) * n);
	memset(tree2, 0, sizeof(PTNode) * n);
	for (int i = 0; i < n; i++) {
		tree2[i].ch = root[i].ch;
	}
	tree2[0].parent = -1;
	for (int i = 0; i < n; i++) {
		if (root[i].fchild != NULL){
		    for (int j = i + 1; j < n; j++) {
				if (root[j].ch == root[i].fchild->ch) {
					tree2[j].parent = i;
				}
				if (root[j].nsbl != NULL) {
					for (int q = j + 1; q < n; q++) {
						if (root[j].nsbl->ch == root[q].ch) {
							tree2[q].parent = tree2[j].parent;
						}
					}
				}
		    }    
		}
	}
	printPTree(tree2, n);
	return tree2;
}

调试结果
调试结果

思考:

1.代码并没有实现链表存储形式的二叉树,使用的是顺序存储结构
尝试过的链式存储结构需要依靠同种结构的顺序存储数组来实现,打印也不方便
2.对二叉树重新转化树的方式过于冗长,时间复杂度较高,需要改进

强调:

从树转为二叉树,其逻辑思维是:
(1)是否是根结点
(2)如果不是根结点,那么说明有双亲
(3)找到双亲,双亲是否有fchild
(4)如果没有第一个孩子,当前结点是parent的fchild
(5)如果有第一个孩子,那当前结点是fchild的第几个nsbl
(6)想要找到当前结点的上一个兄弟,必须用while()找到parent已有的最后一个子结点

编程小白,恳请指正(doge)
留个坑:用递归做二叉树转树

下节预告:

哈夫曼编码

  • 2
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
以下是使用双亲-孩子链表表示法实现的各算法,和二叉树的转换算法代码,包括主函数测试: ```c #include <stdio.h> #include <stdlib.h> #define MAX_TREE_SIZE 100 // 的最大结点数 #define MAX_QUEUE_SIZE 100 // 队列的最大容量 // 双亲-孩子链表结点结构体 typedef struct CTNode { int child; // 孩子结点的索引 struct CTNode *next; // 指向下一个孩子结点的指针 } CTNode, *ChildPtr; // 双亲-孩子链表头结点结构体 typedef struct { int data; // 结点数据 int parent; // 双亲结点的索引 ChildPtr firstChild; // 指向第一个孩子结点的指针 } CTBox; // 双亲-孩子链表结构体 typedef struct { CTBox nodes[MAX_TREE_SIZE]; // 结点数组 int r, n; // 根结点的索引和结点数 } CTree; // 初始化双亲-孩子链表 void InitTree(CTree *T) { int i; for (i = 0; i < MAX_TREE_SIZE; i++) { T->nodes[i].parent = -1; T->nodes[i].firstChild = NULL; } T->r = -1; T->n = 0; } // 向双亲-孩子链表中插入结点 void InsertNode(CTree *T, int i, int j) { ChildPtr p = (ChildPtr) malloc(sizeof(CTNode)); p->child = j; p->next = T->nodes[i].firstChild; T->nodes[i].firstChild = p; T->nodes[j].parent = i; T->n++; } // 遍历双亲-孩子链表 void TraverseTree(CTree *T) { int i, j; ChildPtr p; printf("Tree:\n"); for (i = 0; i < T->n; i++) { printf("%d: %d -> ", i, T->nodes[i].data); p = T->nodes[i].firstChild; while (p != NULL) { j = p->child; printf("%d -> ", T->nodes[j].data); p = p->next; } printf("NULL\n"); } } // 双亲-孩子链表转换为二叉树 void CTreeToBiTree(CTree *T, int i, int *j, BiTree *p) { ChildPtr q; int k; q = T->nodes[i].firstChild; if (q == NULL) { *p = NULL; } else { CTreeToBiTree(T, q->child, &k, p); *j = k; while (q->next != NULL) { q = q->next; CTreeToBiTree(T, q->child, &k, &((*p)->rchild)); (*p)->rchild = (k == -1) ? NULL : (BiTree) k; } } } // 二叉树转换为双亲-孩子链表 void BiTreeToCTree(BiTree T, int i, int *j, CTree *p) { if (T == NULL) { *j = -1; } else { p->nodes[i].data = T->data; p->nodes[i].parent = -1; (*j)++; BiTreeToCTree(T->lchild, *j, j, p); if (*j != -1) { InsertNode(p, i, *j); } BiTreeToCTree(T->rchild, *j, j, p); } } // 层序遍历二叉树 void LevelOrderTraverse(BiTree T) { BiTree Q[MAX_QUEUE_SIZE]; int front = 0, rear = 0; if (T != NULL) { Q[++rear] = T; } while (front != rear) { BiTree p = Q[++front]; printf("%d ", p->data); if (p->lchild != NULL) { Q[++rear] = p->lchild; } if (p->rchild != NULL) { Q[++rear] = p->rchild; } } printf("\n"); } int main() { CTree T; BiTree B; int j = -1; InitTree(&T); T.r = 0; T.n = 10; T.nodes[0].data = 0; T.nodes[1].data = 1; T.nodes[2].data = 2; T.nodes[3].data = 3; T.nodes[4].data = 4; T.nodes[5].data = 5; T.nodes[6].data = 6; T.nodes[7].data = 7; T.nodes[8].data = 8; T.nodes[9].data = 9; InsertNode(&T, 0, 1); InsertNode(&T, 0, 2); InsertNode(&T, 1, 3); InsertNode(&T, 1, 4); InsertNode(&T, 2, 5); InsertNode(&T, 3, 6); InsertNode(&T, 3, 7); InsertNode(&T, 5, 8); InsertNode(&T, 5, 9); TraverseTree(&T); CTreeToBiTree(&T, 0, &j, &B); printf("Binary Tree:\n"); LevelOrderTraverse(B); BiTreeToCTree(B, 0, &j, &T); TraverseTree(&T); return 0; } ``` 在该代码中,我们首先定义了双亲-孩子链表结点结构体 CTNode 和双亲-孩子链表头结点结构体 CTBox,然后定义了双亲-孩子链表结构体 CTree。在 InitTree 函数中,我们将中所有结点的双亲结点索引设置为 -1,孩子结点指针设置为 NULL,根结点的索引设置为 -1,结点数设置为 0。在 InsertNode 函数中,我们向中插入一个孩子结点,并建立孩子结点与双亲结点之间的关系。在 TraverseTree 函数中,我们遍历整个,输出每个结点的数据以及它的孩子结点。在 CTreeToBiTree 函数中,我们将双亲-孩子链表转换为二叉树,首先遍历的第一个孩子结点,得到它的索引 k,然后遍历它的兄弟结点,为每一个兄弟结点创建一个右孩子,并递归地将它的子转换为二叉树。在 BiTreeToCTree 函数中,我们将二叉树转换为双亲-孩子链表,首先为每个结点创建一个对应的双亲-孩子链表结点,并递归地将左子和右子插入到它们的双亲结点中。在 LevelOrderTraverse 函数中,我们使用队列实现层序遍历二叉树。最后,在主函数中,我们创建了一个双亲-孩子链表,并向其中插入一些结点,然后遍历该,将它转换为二叉树,输出二叉树,并将二叉树转换为双亲-孩子链表,输出双亲-孩子链表
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值