树的存储结构（双亲表示法，孩子双亲表示法，孩子兄弟表示法）——C语言描述

已于 2022-10-06 18:01:24 修改
阅读量1.2k 收藏 5
点赞数
分类专栏： 数据结构 文章标签： c语言 开发语言
于 2022-10-05 17:33:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59469991/article/details/127174783
版权

树的存储结构（双亲表示法，孩子双亲表示法，孩子兄弟表示法）——C语言描述

文章目录

0 测试用例框架

https://blog.csdn.net/m0_59469991/article/details/127137119?csdn_share_tail=%7B%22type%22%3A%22blog%22%2C%22rType%22%3A%22article%22%2C%22rId%22%3A%22127137119%22%2C%22source%22%3A%22m0_59469991%22%7D

1 树的基本概念

度：结点的子树个数

2 树的存储结构

双亲表示法，孩子表示法，孩子兄弟表示法

3 树的双亲表示法

3.1 存储结构代码

#define PT_TREE_MAXSIZE			100
typedef struct {
	int Data;
	int Parent;
}PTNode;

typedef struct {
	PTNode Node[PT_TREE_MAXSIZE];
	int Root;
	int Num;
}PTree;

3.2 构建树

OP_STATUS BuildPTree(PTree *PTree01, const unsigned int PTNodeNum, const int *PTNodeData, const int *PTNodeParent)

(1)条件

PTNodeNum表示结点个数，PTNodeData表示结点的数据，PTNodeParent表示结点双亲位置

(2)代码

OP_STATUS BuildPTree(PTree *PTree01, const unsigned int PTNodeNum, const int *PTNodeData, const int *PTNodeParent) {
	OP_STATUS Status = SUCCESS;
	PTree *TraPTree01 = PTree01;
	int *TraPTNodeData = PTNodeData;
	int *TraPTNodeParent = PTNodeParent;

	unsigned int Index = 0;

	printf("BuildPTree start\n");

	if (TraPTree01 == NULL || TraPTNodeData == NULL || TraPTNodeParent == NULL) {
		return ERROR;
	}

	TraPTree01->Num = PTNodeNum;
	TraPTree01->Root = 0;

	for (Index = 0; Index < PTNodeNum; ++Index) {
		//printf("TraPTNodeData[%d] = %d, TraPTNodeParent[%d] = %d\n", Index, TraPTNodeData[Index], Index, TraPTNodeParent[Index]);
		TraPTree01->Node[Index].Data = TraPTNodeData[Index];
		TraPTree01->Node[Index].Parent = TraPTNodeParent[Index];
	}	

	printf("BuildPTree end\n");
	return SUCCESS;
}

(3)测试用例

代码：

①打印树

void PrintPTree(const PTree *PTree01, const int PTNodeNum) {
	PTree *TraPTree01 = PTree01;
	unsigned int Index = 0;
	
	printf("TraPTree01->Root = %d, TraPTree01->Num = %d\n", TraPTree01->Root, TraPTree01->Num);

	for (Index = 0; Index < PTNodeNum; ++Index) {
		printf("TraPTree01->Node[%d].Data = %d, TraPTree01->Node[%d].Parent = %d\n", Index, TraPTree01->Node[Index].Data, Index, TraPTree01->Node[Index].Parent);
	}
}

②比较树

OP_STATUS PTreeCmpTest(const PTree *PT01, const PTree *PT02, const unsigned int PTNodeNum01) {
	PTree *TraPT01 = PT01;
	PTree *TraPT02 = PT02;
	unsigned int Index = 0;

	TestNum++;
	
	if (TraPT01->Num != TraPT02->Num || TraPT01->Root != TraPT02->Root) {
		FaildNum++;
		return ERROR;
	}

	for (Index = 0; Index < PTNodeNum01; ++Index) {
		if (TraPT01->Node[Index].Data != TraPT02->Node[Index].Data || TraPT01->Node[Index].Parent != TraPT02->Node[Index].Parent) {
			FaildNum++;
			return ERROR;
		}
	}

	PassNum++;
	return SUCCESS;
}

void TestBuildPTree(void) {
	PTree PTree01;
	unsigned int PTNodeNum01 = 7;
	int PTNodeData01[7] = { 0, 10, 20, 30, 40, 50, 60 };
	int PTNodeParent[7] = {-1, 0, 0, 1, 1, 2, 2};

	PTree CmpPTree = { {{0, -1}, {10, 0}, {20, 0}, {30, 1}, {40, 1}, {50, 2}, {60, 2}}, 0, 7 };

	BuildPTree(&PTree01, PTNodeNum01, PTNodeData01, PTNodeParent);
	
	printf("-------Test start----------\n");
	InitNum();
	/*Test01*/
	printf("-------Test 01----------\n");
	PTreeCmpTest(&CmpPTree, &PTree01, PTNodeNum01);
	PrintPTree(&PTree01, PTNodeNum01);

	/*Test Result*/
	printf("\n-------Test result----------\n");
	TestResult();
}

(4)结果

BuildPTree start

BuildPTree end

-------Test start----------

-------Test 01----------

TraPTree01->Root = 0, TraPTree01->Num = 7

TraPTree01->Node[0].Data = 0, TraPTree01->Node[0].Parent = -1

TraPTree01->Node[1].Data = 10, TraPTree01->Node[1].Parent = 0

TraPTree01->Node[2].Data = 20, TraPTree01->Node[2].Parent = 0

TraPTree01->Node[3].Data = 30, TraPTree01->Node[3].Parent = 1

TraPTree01->Node[4].Data = 40, TraPTree01->Node[4].Parent = 1

TraPTree01->Node[5].Data = 50, TraPTree01->Node[5].Parent = 2

TraPTree01->Node[6].Data = 60, TraPTree01->Node[6].Parent = 2

-------Test result----------

Print test result;

TestNum = 1, PassNum = 1, FaildNum = 0

unsigned int FindStrIndex(char *Str, const char *FindStr, const unsigned int FindStrPos)

1.1需求：在Str串的Pos位置之后，找第一个FinStr,找到返回Str的下标，找不到返回0。

1.2 条件

​ FindStr与FindStr非空，0 < FindStrPos<= FindStrLen - FindStrLen

1.3 方法：

  1. 使用SubString函数截取字串，长度为FinStr的长度

  2. 使用截取的字串与FinStr进行比较

代码：

unsigned int FindStrIndex(char *Str, const char *FindStr, const unsigned int FindStrPos) {
	unsigned int StrLenth = StringLen(Str);
	unsigned int FindStrLenth = StringLen(FindStr);
	char *Sub = NULL;
	unsigned int Index = 0;
	unsigned int FindStrIndex = 0;

	OP_STATUS  Status = SUCCESS;

	printf("FindStrIndex start\n");
	if (Str == NULL || FindStr == NULL || FindStrPos == 0 || FindStrPos > StrLenth - FindStrLenth + 1) {
		printf("Invaild parameter!\n");
		FindStrIndex = 0;
		goto EXIT;
	}

	Sub = (char *)malloc(StringLen(Str) + 1);
	if (Sub == NULL) {
		FindStrIndex = 0;
		goto EXIT;
	}	

	for (Index = FindStrPos - 1; Index <= StrLenth - FindStrLenth + 1; ++Index) {
		Status = SubString(Sub, Str, Index, FindStrLenth);
		if (Status == SUCCESS) {
			if (StrCopmare(FindStr, Sub) == 0) {
				FindStrIndex = Index;
				goto EXIT;
			}
		}
	}

EXIT:	
	if (Sub != NULL) {
		free(Sub);
		Sub = NULL;
	}
	
	printf("FindStrIndex = %d\n", FindStrIndex);
	printf("FindStrIndex end\n");
	return FindStrIndex;
}

测试用例代码：

void TestFindStrIndex(void) {
	/*Test01*/
	char Str01[] = "abcdef";
	char FindStr01[] = "bc";
	unsigned int FindStrPos01 = 1;
	unsigned int FindRes01;
	unsigned int ComPos01 = 2;

	/*Test02*/
	char Str02[] = "abcdef";
	char FindStr02[] = "ef";
	unsigned int FindStrPos02 = 2;
	unsigned int FindRes02;
	unsigned int ComPos02 = 5;

	/*Test03*/
	char Str03[] = "abcdef";
	char FindStr03[] = "ee";
	unsigned int FindStrPos03 = 1;
	unsigned int FindRes03;
	unsigned int ComPos03 = 0;

	printf("-------Test start----------\n");
	InitNum();
	/*Test01*/
	printf("-------Test 01----------\n");
	FindRes01 = FindStrIndex(Str01, FindStr01, FindStrPos01);
	ValueTest(ComPos01, FindRes01);

	/*Test02*/
	printf("\n-------Test 02----------\n");
	FindRes02 = FindStrIndex(Str02, FindStr02, FindStrPos02);
	ValueTest(ComPos02, FindRes02);

	/*Test03*/
	printf("\n-------Test 03----------\n");
	FindRes03 = FindStrIndex(Str03, FindStr03, FindStrPos03);
	ValueTest(ComPos03, FindRes03);

	/*Test Result*/
	printf("\n-------Test result----------\n");
	TestResult();
}

结果：

-------Test start----------

-------Test 01----------

FindStrIndex start

SubString start

SubString start

SubString end

StrCopmare start

Str1 = bc

Str2 = ab

ret = 1

StrCopmare end

SubString start

SubString end

StrCopmare start

Str1 = bc

Str2 = bc

ret = 0

StrCopmare end

FindStrIndex = 2

FindStrIndex end

ValueTest test succeed!

-------Test 02----------

FindStrIndex start

SubString start

SubString end

StrCopmare start

Str1 = ef

Str2 = ab

ret = 1

StrCopmare end

SubString start

SubString end

StrCopmare start

Str1 = ef

Str2 = bc

ret = 1

StrCopmare end

SubString start

SubString end

StrCopmare start

Str1 = ef

Str2 = cd

ret = 1

StrCopmare end

SubString start

SubString end

StrCopmare start

Str1 = ef

Str2 = de

ret = 1

StrCopmare end

SubString start

SubString end

StrCopmare start

Str1 = ef

Str2 = ef

ret = 0

StrCopmare end

FindStrIndex = 5

FindStrIndex end

ValueTest test succeed!

-------Test 03----------

FindStrIndex start

SubString start

SubString start

SubString end

StrCopmare start

Str1 = ee

Str2 = ab

ret = 1

StrCopmare end

SubString start

SubString end

StrCopmare start

Str1 = ee

Str2 = bc

ret = 1

StrCopmare end

SubString start

SubString end

StrCopmare start

Str1 = ee

Str2 = cd

ret = 1

StrCopmare end

SubString start

SubString end

StrCopmare start

Str1 = ee

Str2 = de

ret = 1

StrCopmare end

SubString start

SubString end

StrCopmare start

Str1 = ee

Str2 = ef

ret = -1

StrCopmare end

FindStrIndex = 0

FindStrIndex end

ValueTest test succeed!

-------Test result----------

Print test result;

TestNum = 3, PassNum = 3, FaildNum = 0

4 树的孩子双亲表示法

4.1 存储结构代码

采用多重链表方法。结点及它的数据和双亲采用数组方法，结点的孩子采用单链表的方法。

代码：

/*ChildParentTree*/
#define CHILDE_PARENT_TREE_MAXSIZE			100
#define CHILD_TREE_CHILE_INDEX_SIZE			10

/*CTree*/
typedef struct _CHILD_NODE{
	int ChildIndex;
	struct _CHILD_NODE *Next;
}CHILD_NODE;

typedef struct {
	int Data;
	int Parent;
	CHILD_NODE *FirstChildIndex;
}CT_BOX;

typedef struct {
	CT_BOX Node[CHILDE_PARENT_TREE_MAXSIZE];
	int Root;
	int NodeNum;
}CHILD_PARTENT_TREE;

typedef struct {
	int Data;
	int Parent;
	int ChildNum;
	int ChildIndex[CHILD_TREE_CHILE_INDEX_SIZE];
}CHILD_PARENT_TREE_NODE_DATA;

typedef struct {
	int Root;
	int NodeNum;	
}CHILD_PARENT_TREE_ROOT_NODENUM_DATA;

4.2 构建树

OP_STATUS BuildChildParentTree(CHILD_PARTENT_TREE *CPTree, const CHILD_PARENT_TREE_ROOT_NODENUM_DATA *CPTreeRootNodeNum, const CHILD_PARENT_TREE_NODE_DATA *CPTreeData)

CPTree表示树，CPTreeRootNodeNum表示根的位置和结点数量，CPTreeData表示结点的数据。

（1）构建树代码

/*ChildParentTree*/
OP_STATUS BuildChildParentTree(CHILD_PARTENT_TREE *CPTree, const CHILD_PARENT_TREE_ROOT_NODENUM_DATA *CPTreeRootNodeNum, const CHILD_PARENT_TREE_NODE_DATA *CPTreeData) {
	OP_STATUS Status = SUCCESS;
	CHILD_PARTENT_TREE *TraCPTree = CPTree;
	CHILD_PARENT_TREE_ROOT_NODENUM_DATA *TraCPTreeRootNodeNum = CPTreeRootNodeNum;
	CHILD_PARENT_TREE_NODE_DATA *TraCPTreeData = CPTreeData;

	unsigned int Index = 0;
	unsigned int NodeNum = TraCPTreeRootNodeNum->NodeNum;
	unsigned int ChildNumIndex = 0;

	CHILD_NODE	*ChildHeadNode = NULL;
	CHILD_NODE	*TraChildHeadNode = NULL;
	CHILD_NODE	*AddChildNode = NULL;
	//CHILD_NODE  *TraPrintChildNode = NULL;

	printf("BuildChildTree start\n");
	
	if (TraCPTree == NULL || TraCPTreeData == NULL) {
		Status = ERROR;
		goto EXIT;
	}

	TraCPTree->Root = TraCPTreeRootNodeNum->Root;
	TraCPTree->NodeNum = TraCPTreeRootNodeNum->NodeNum;

	for (Index = 0; Index < NodeNum; ++Index) {
		TraCPTree->Node[Index].Data = TraCPTreeData[Index].Data;
		TraCPTree->Node[Index].Parent = TraCPTreeData[Index].Parent;

		ChildHeadNode = (CHILD_NODE *)malloc(sizeof(CHILD_NODE));
		if (ChildHeadNode == NULL) {
			Status = ERROR;
			goto EXIT;
		}
		ChildHeadNode->Next = NULL;

		TraChildHeadNode = ChildHeadNode;

		/*Create CHILD_NODE Link*/
		//printf("\nTraCPTreeData[%d].ChildNum = %d\n", Index, TraCPTreeData[Index].ChildNum);
		for (ChildNumIndex = 0; ChildNumIndex < TraCPTreeData[Index].ChildNum; ++ChildNumIndex) {
			AddChildNode = (CHILD_NODE *)malloc(sizeof(CHILD_NODE));
			if (AddChildNode == NULL) {
				Status = ERROR;
				goto EXIT;
			}

			//printf("TraCPTreeData[%d].ChildIndex[%d] = %d\n", Index, ChildNumIndex, TraCPTreeData[Index].ChildIndex[ChildNumIndex]);
			AddChildNode->ChildIndex = TraCPTreeData[Index].ChildIndex[ChildNumIndex];
			AddChildNode->Next = TraChildHeadNode->Next;
			TraChildHeadNode->Next = AddChildNode;
			
			TraChildHeadNode = TraChildHeadNode->Next;
		}

		TraCPTree->Node[Index].FirstChildIndex = ChildHeadNode->Next;

		/*Print Link*/
		/*printf("\nPrint Link start\n");
		TraPrintChildNode = ChildHeadNode->Next;

		while (TraPrintChildNode != NULL) {
			printf("TraPrintChildNode->ChildIndex = %d\n", TraPrintChildNode->ChildIndex);
			TraPrintChildNode = TraPrintChildNode->Next;
		}
		printf("Print Link end\n");*/
	}

EXIT:
	printf("BuildChildTree end\n\n");
	return Status;
}

（2）打印树代码

void PrintChildParentTree(const CHILD_PARTENT_TREE *CPTree) {
	CHILD_PARTENT_TREE *TraCPTree = CPTree;
	unsigned int Index = 0;
	unsigned int ChildNumIndex = 0;

	CHILD_NODE *TraChildNode = NULL;

	printf("PrintChildParentTree start\n");
	printf("TraCPTree->Root = %d, TraCPTree->NodeNum = %d\n", TraCPTree->Root, TraCPTree->NodeNum);
	for (Index = 0; Index < TraCPTree->NodeNum; ++Index) {
		printf("TraCPTree->Node[%d].Data = %d, TraCPTree->Node[%d].Parent = %d\n", Index, TraCPTree->Node[Index].Data, Index, TraCPTree->Node[Index].Parent);

		TraChildNode = TraCPTree->Node[Index].FirstChildIndex;

		while (TraChildNode != NULL) {
			printf("TraChildNode->ChildIndex = %d\n", TraChildNode->ChildIndex);
			TraChildNode = TraChildNode->Next;
		}			
	}
	
	printf("PrintChildParentTree end\n");
}

(3)测试用例代码

void TestBuildChildParentTree(void) {
	/*Test01*/
	CHILD_PARTENT_TREE CPTree01;
	CHILD_PARENT_TREE_ROOT_NODENUM_DATA CPTreeRootNodeNumData01 = { 0, 7 };
	CHILD_PARENT_TREE_NODE_DATA CPTreeNodeData01[7] = { {0, -1, 2, {1, 2}},
														{10, 0, 2, {3, 4}}, {20, 0, 2, {5, 6}},
														{30, 1, 0}, {40, 1, 0}, {50, 2, 0},{60, 2, 0} };

	PARENT_TREE CmpPTree01 = { {{0, -1},
								{10, 0}, {20, 0},
								{30, 1}, {40, 1}, {50, 2}, {60, 2}}, 0, 7 };
	
	/*Test02*/
	CHILD_PARTENT_TREE CPTree02;
	CHILD_PARENT_TREE_ROOT_NODENUM_DATA CPTreeRootNodeNumData02 = {0, 10};
	CHILD_PARENT_TREE_NODE_DATA CPTreeNodeData02[10] = { {0, -1, 2, {1, 2}},
														{10, 0, 1, {3}}, {20, 0, 2, {4, 5}}, 
														{30, 1, 3, {6, 7, 8}}, {40, 2, 1, {9}}, {50, 2, 0}, 
														{60, 3, 0}, {70, 3, 0}, {80, 3, 0}, {90, 4, 0} };

	PARENT_TREE CmpPTree02 = { {{0, -1},
							{10, 0}, {20, 0},
							{30, 1}, {40, 2}, {50, 2},
							{60, 3}, {70, 3}, {80, 3}, {90, 4}}, 0, 10 };	

	printf("-------Test start----------\n");
	InitNum();
	/*Test01*/
	printf("-------Test 01----------\n");
	BuildChildParentTree(&CPTree01, &CPTreeRootNodeNumData01, CPTreeNodeData01);
	PrintChildParentTree(&CPTree01);
	CPTreeCmpTest(&CmpPTree01, &CPTree01, CPTreeRootNodeNumData01.NodeNum);

	/*Test02*/
	printf("-------Test 02----------\n");
	BuildChildParentTree(&CPTree02, &CPTreeRootNodeNumData02, CPTreeNodeData02);
	PrintChildParentTree(&CPTree02);
	CPTreeCmpTest(&CmpPTree02, &CPTree02, CPTreeRootNodeNumData02.NodeNum);
	
	/*Test Result*/
	printf("\n-------Test result----------\n");
	TestResult();
}

（4）结果：

-------Test start----------
-------Test 01----------
BuildChildTree start
BuildChildTree end
PrintChildParentTree start
TraCPTree->Root = 0, TraCPTree->NodeNum = 7
TraCPTree->Node[0].Data = 0, TraCPTree->Node[0].Parent = -1
TraChildNode->ChildIndex = 1
TraChildNode->ChildIndex = 2
TraCPTree->Node[1].Data = 10, TraCPTree->Node[1].Parent = 0
TraChildNode->ChildIndex = 3
TraChildNode->ChildIndex = 4
TraCPTree->Node[2].Data = 20, TraCPTree->Node[2].Parent = 0
TraChildNode->ChildIndex = 5
TraChildNode->ChildIndex = 6
TraCPTree->Node[3].Data = 30, TraCPTree->Node[3].Parent = 1
TraCPTree->Node[4].Data = 40, TraCPTree->Node[4].Parent = 1
TraCPTree->Node[5].Data = 50, TraCPTree->Node[5].Parent = 2
TraCPTree->Node[6].Data = 60, TraCPTree->Node[6].Parent = 2
PrintChildParentTree end

-------Test 02----------
BuildChildTree start
BuildChildTree end
PrintChildParentTree start
TraCPTree->Root = 0, TraCPTree->NodeNum = 10
TraCPTree->Node[0].Data = 0, TraCPTree->Node[0].Parent = -1
TraChildNode->ChildIndex = 1
TraChildNode->ChildIndex = 2
TraCPTree->Node[1].Data = 10, TraCPTree->Node[1].Parent = 0
TraChildNode->ChildIndex = 3
TraCPTree->Node[2].Data = 20, TraCPTree->Node[2].Parent = 0
TraChildNode->ChildIndex = 4
TraChildNode->ChildIndex = 5
TraCPTree->Node[3].Data = 30, TraCPTree->Node[3].Parent = 1
TraChildNode->ChildIndex = 6
TraChildNode->ChildIndex = 7
TraChildNode->ChildIndex = 8
TraCPTree->Node[4].Data = 40, TraCPTree->Node[4].Parent = 2
TraChildNode->ChildIndex = 9
TraCPTree->Node[5].Data = 50, TraCPTree->Node[5].Parent = 2
TraCPTree->Node[6].Data = 60, TraCPTree->Node[6].Parent = 3
TraCPTree->Node[7].Data = 70, TraCPTree->Node[7].Parent = 3
TraCPTree->Node[8].Data = 80, TraCPTree->Node[8].Parent = 3
TraCPTree->Node[9].Data = 90, TraCPTree->Node[9].Parent = 4
PrintChildParentTree end

-------Test result----------
Print test result;
TestNum = 2, PassNum = 2, FaildNum = 0

Meditatorss
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言数据结构树的双亲表示法实例详解
08-30
树的双亲表示法是一种常用的树存储结构，用于存储树结构的节点信息。这种结构的特点是每个节点都含有一个指向其双亲节点的指针，通过这种方式可以快速地找到某个节点的双亲节点。 基本操作 在C语言中，使用结构体...
树的常见的三种链表存储结构
perry0528的博客
09-08 7828
1.双亲表示法： // - - - - - 树的双亲表存储表示 - - - - - #define MAX_TREE_SIZE 100 typedef struct PTNode { //结点结构 ElemType data; int parent; //双亲位置域 }PTNode; typedef struct { //树结构 PTNode nodes[MAX_TR...
数据结构-难点突破（C++实现树的双亲表示法，孩子表示法，孩子兄弟表示法（树转化为二叉树））
dodamce的博客
11-22 3139
其存储过程是：从树的根节点开始，使用顺序表依次存储树中各个节点。需要注意，与双亲表示法不同的是，孩子表示法会给各个节点配备一个链表，用于存储各节点的孩子节点位于顺序表中的位置。通过孩子兄弟表示法，任意一棵普通树都可以相应转化为一棵二叉树，它们是一一对应的。具体实现方案是：从树的根节点开始，依次存储各个结点的孩子结点和兄弟结点。孩子表示法存储普通树采用的是 “顺序表+链表” 的组合结构。如果节点没有孩子节点（叶子节点），则该节点的链表为空链表。所谓孩子兄弟表示法，指的是用将整棵树用二叉链表存储起来.
输入广义表建立双亲表示的树and给定双亲表示的树输出广义表表示的树
qq_40691051的博客
10-29 275
注释写的很详细了，就直接上代码吧。 #include<iostream> #include<string> #include<stack> #include<vector> using namespace std; struct Node { char data; //数据 int parent; //双亲指针 }; void ...
数据结构与算法（6-1）树的存储（树的双亲表示、树的孩子表示及树的双亲孩子表示）
great_yzl的博客
08-02 1308
一、树的双亲表示 存储结构 采用结构体数组的形式存储数据。 （根结点parent=1：它没有双亲结点了） //树的双亲表示 typedef struct { char data; //结点数据 int parent; //双亲在数组中的位置 }Tree; Tree tree[MAXSIZE]; 总代码 //树的双亲表示法（双亲树） //getchar()：吸收换行符 #include<stdio.h> #define MAXSIZE 20 int cou...
树存储结构的几种表示方法
12-31
（1）、双亲表示法。这种存储方式采用一组连续的空间来存储每个结点，同时在每个结点中增设一个伪指针， 指示其双亲在结点中的位置。这种方式比较容易找到双亲，但是不容易找到孩子。 （2）、孩子表示法。这种...
数据结构C语言树形结构PPT学习教案.pptx
10-05
文氏图表示法使用集合以及集合的包含关系描述树结构。凹入表示法使用线段的伸缩描述树结构。括号表示法将树的根结点写在括号的左边，除根结点之外的其余结点写在括号中并用逗号间隔来描述树结构。 7.1.3 树的基本...
数据结构C语言树和二叉树PPT课件.pptx
10-08
数据结构C语言树和二叉树PPT课件.pptx 本PPT课件主要介绍了树和二叉树的基本概念、定义、特点、基本术语、性质和特殊形式。下面是从PPT课件中提取的相关知识点： 一、树的定义和基本概念 * 树的定义：树是一类...
树的存储结构：双亲表示法、孩子表示法、孩子兄弟法
wmy0217_的博客
02-05 8504
文章目录双亲表示法孩子表示法孩子兄弟法 双亲表示法 实现：定义结构数组存放树的结点，每个结点包含两个域： 数据域：存放结点本身信息 双亲域：指示本结点的双亲结点在数组中的位置 结点结构： 结点类型定义： typedef struct PTNode {//结点类型定义 TElemType data; int parent; //双亲位置域 }PTNode; 另外，用 r 存储根结点的下...
树的孩子表示法，树的兄弟表示法，树的存储结构详解,数据结构-树的学习（2）
YEDITABA的博客
06-04 1万+
树的存储结构： 孩子表示法：把每个结点的孩子结点排列起来，以单链表作存储结构，则n个结点有n个孩子链表，如果是叶子结点则此单链表为空。然后n个头指针又组成一个线性表，采用顺序存储结构，存放进一个一维数组中。 为此，设计两种结点结构，一个是孩子链表的孩子结点    ||child | next|| 另一个是表头数组的表头节点 ||data | firstchild|| #define MAXS
hai子兄弟表示法（C语言实现）——树的存储结构
Mr_John
11-02 1170
// 孩子兄弟表示法实际就是创建一棵二叉树 #include<stdio.h> #include<stdlib.h> #include<stdbool.h> typedef char DataType; typedef struct TNode { DataType data; // 数据域 struct TNode * fchild; // 第一个孩子指针域 struct TNode * rsibling; // 右兄弟指针域 }*Tr..
Week 4 Problem 3
不停
11-13 1129
题目：已知树结点为互不相等且不等于0的整数。请编写程序找出非空树中两个结点的最近公共祖先。 输入格式： 输入为2行，第1行为一组用空格间隔的整数，个数不超过100个，表示加入空指针信息的二叉树先序序列。其中空指针信息用0表示。第2行为空格间隔的两个互不相等的整数A和B，表示给定的两个结点值，保证A和B肯定在输入的树中。 注：我们已知二叉树与其自然对应的树相比，二叉树中结点的左孩子对应树中结点的左孩...
树的存储_ 双亲表示法 及 双亲孩子表示法
热门推荐
惊鸿一博
05-23 2万+
1.概念 树状图是一种数据结构，它是由n（n>=1）个有限节点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：每个节点有零个或多个子节点；没有父节点的节点称为根节点；每一个非根节点有且只有一个父节点；除了根节点外，每个子节点可以分为多个不相交的子树。 节点的度(degree)：一个节点含有的子树的个数称为该...
（数据结构）树的Child表示法
weixin_51927215的博客
03-31 2774
树的孩子表示法 此前介绍过用双亲表示法存储普通树，本篇文章将讲解另一种存储普通树的方法... 另一种方法是孩子表示法！！！ 孩子表示法存储普通树采用的是：顺序表和链表的组合结构 其存储过程是：从树的根节点开始，使用顺序表依次存储树中各个节点，需要注意的是，与双亲表示法不同，孩子表示法会给各个节点配备一个链表，用于存储各节点的孩子节点位于顺序表中的位置（而双亲表示法会配置一个整型变量，用来保存双亲的位置） 如果节点没有孩子节点（叶子节点），则该节点的链表为空链表 例如，使用孩子表示法存储下图左侧的
c语言孩子兄弟法存储一棵树,树的孩子兄弟表示法
weixin_31191387的博客
05-18 4757
前面讲解了存储普通树的双亲表示法和孩子表示法，本节来讲解最后一种常用方法——孩子兄弟表示法。图 1 普通树示意图树结构中，位于同一层的节点之间互为兄弟节点。例如，图 1 的普通树中，节点 A、B 和 C 互为兄弟节点，而节点 D、E 和 F 也互为兄弟节点。孩子兄弟表示法，采用的是链式存储结构，其存储树的实现思想是：从树的根节点开始，依次用链表存储各个节点的孩子节点和兄弟节点。因此，该链表中的节...
设一棵二叉树各结点的值互不相同，其先序遍历序列和中序遍历序列分别存于两个一维数组A[1...n]和B[1...n]中，试编写算法建立该二叉树的二叉链表
qq_43661234的博客
09-27 4680
#include <stdio.h> #include <malloc.h> typedef int elemtype; typedef struct BTNode { elemtype data; struct BTNode *left, *right; }BTNode, *BiTree; BiTree creat(elemtype A[], ele...
用二叉链表存树（孩子兄弟表示法）
17的博客
10-30 8274
用二叉链表的左子树指向该节点最左边的孩子，右子树指向该节点的兄弟，以达到存树的目的
数据结构学习笔记——树的存储结构以及树、森林与二叉树之间的转换
小宇y的博客
08-02 3094
树的存储结构中反映的是一棵树中各结点之间的关系，在存储中，不仅存储树中每个结点的值，还存储各结点之间的关系，主要有三种存储结构，分别是双亲表示法、孩子链表示法和孩子兄弟表示法。双亲表示法是通过采用一维数组来存储树中的结点，其中每个结点被赋予一个结构体类型，包含data域和parent域，分别和。 例如，下图该树，通过双亲表示法进行存储，规定从数组下标为0开始存储，根结点下标为0，同时设根结点的parent域为-1： 将所有结点存放在一个中，每个数据元素有两个域，分别是该结点的数据域和存放该结点的第一个孩子
6.2使用双亲-孩子链表表示法实现树的各算法，和树与二叉树的转换算法，写主函数测试。用C语言
最新发布
06-08
以下是使用双亲-孩子链表表示法实现树的各算法，和树与二叉树的转换算法的代码，包括主函数测试： ```c #include #include #define MAX_TREE_SIZE 100 // 树的最大结点数 #define MAX_QUEUE_SIZE 100 // 队列的...

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值