二叉树的三叉链表存储表示 （第六章 P126）

最新推荐文章于 2023-11-14 17:54:28 发布
最新推荐文章于 2023-11-14 17:54:28 发布
阅读量3.9k 收藏 24
点赞数 6
分类专栏： 数据结构 文章标签： c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42185999/article/details/105524587
版权

 

二叉树的三叉链表存储结构比二叉链表多一个指向双亲结点的指针，因此，求双亲和左右兄弟都很容易。但在构造二叉树时要另给双亲指针赋值，从而增加了复杂度。由于三叉链表和二叉链表在结构上的相似性，它们有些相应的基本操作也很类似。

 

二叉树的三叉链表存储结构：
 

 

右图为左图的三叉链表存储结构：

 
      

 

 

typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */

#include<malloc.h> /* malloc()等 */
#include<stdio.h> /* EOF(=^Z或F6),NULL */
#include<process.h> /* exit() */

/* 函数结果状态代码 */
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2 


#define CHAR /* 字符型 */
/*#define INT /* 整型（二者选一） */

#ifdef CHAR
typedef char TElemType;
TElemType Nil = ' '; /* 字符型以空格符为空 */
#endif
#ifdef INT
typedef int TElemType;
TElemType Nil = 0; /* 整型以0为空 */
#endif

/* ---------------------------------  二叉树的三叉链表存储表示    --------------------------------*/

typedef struct BiTPNode
{
	TElemType data;
	struct BiTPNode *parent, *lchild, *rchild; /* 双亲、左右孩子指针 */
}BiTPNode, *BiPTree;

/* ---------------------------------------------------------------------------------------------*/


/* --------------------------------  二叉树的三叉链表存储的基本操作(21个)  -------------------------------*/


Status InitBiTree(BiPTree *T)
{ /* 操作结果: 构造空二叉树T */
	*T = NULL;
	return OK;
}

void DestroyBiTree(BiPTree *T)
{ /* 初始条件: 二叉树T存在。操作结果: 销毁二叉树T */
	if (*T) /* 非空树 */
	{
		if ((*T)->lchild) /* 有左孩子 */
			DestroyBiTree(&(*T)->lchild); /* 销毁左孩子子树 */
		if ((*T)->rchild) /* 有右孩子 */
			DestroyBiTree(&(*T)->rchild); /* 销毁右孩子子树 */
		free(*T); /* 释放根结点 */
		*T = NULL; /* 空指针赋0 */
	}
}

void Create(BiPTree *T) /* CreateBiTree()调用 */
{ /* 按先序次序输入二叉树中结点的值（可为字符型或整型，在主程中定义）， */
  /* 构造仅缺双亲指针的三叉链表表示的二叉树T。变量Nil表示空（子）树 */
	TElemType ch;
#ifdef CHAR
	scanf("%c", &ch);
#endif
#ifdef INT
	scanf("%d", &ch);
#endif
	if (ch == Nil) /* 空 */
		*T = NULL;
	else
	{
		*T = (BiPTree)malloc(sizeof(BiTPNode));
		if (!*T)
			exit(OVERFLOW);
		(*T)->data = ch; /* 生成根结点 */
		Create(&(*T)->lchild); /* 构造左子树 */
		Create(&(*T)->rchild); /* 构造右子树 */
	}
}

typedef BiPTree QElemType; /* 设队列元素为二叉树的指针类型 */

/* ------------------单链队列－队列的链式存储结构    -----------------------*/

typedef struct QNode
{
	QElemType data;
	struct QNode *next;
}QNode, *QueuePtr;

typedef struct
{
	QueuePtr front, rear; /* 队头、队尾指针 */
}LinkQueue;

/* ------------------------------------------------------------------------*/

/* -------------------   需要用到的链队列的基本操作  ----------------------*/

Status InitQueue(LinkQueue *Q)
{ /* 构造一个空队列Q */
	(*Q).front = (*Q).rear = (QueuePtr)malloc(sizeof(QNode));
	if (!(*Q).front)
		exit(OVERFLOW);
	(*Q).front->next = NULL;
	return OK;
}

Status QueueEmpty(LinkQueue Q)
{ /* 若Q为空队列,则返回TRUE,否则返回FALSE */
	if (Q.front == Q.rear)
		return TRUE;
	else
		return FALSE;
}

Status EnQueue(LinkQueue *Q, QElemType e)
{ /* 插入元素e为Q的新的队尾元素 */
	QueuePtr p = (QueuePtr)malloc(sizeof(QNode));
	if (!p) /* 存储分配失败 */
		exit(OVERFLOW);
	p->data = e;
	p->next = NULL;
	(*Q).rear->next = p;
	(*Q).rear = p;
	return OK;
}

Status DeQueue(LinkQueue *Q, QElemType *e)
{ /* 若队列不空,删除Q的队头元素,用e返回其值,并返回OK,否则返回ERROR */
	QueuePtr p;
	if ((*Q).front == (*Q).rear)
		return ERROR;
	p = (*Q).front->next;
	*e = p->data;
	(*Q).front->next = p->next;
	if ((*Q).rear == p)
		(*Q).rear = (*Q).front;
	free(p);
	return OK;
}

/* -----------------------------------------------------------------------*/



Status CreateBiTree(BiPTree *T)
{ /* 按先序次序输入二叉树中结点的值（可为字符型或整型，在主程中定义）， */
  /* 构造三叉链表表示的二叉树T */
	LinkQueue q;
	QElemType a;
	Create(T); /* 构造二叉树(缺双亲指针) */
	if (*T) /* 非空树 */
	{
		(*T)->parent = NULL; /* 根结点的双亲为＂空＂ */
		InitQueue(&q); /* 初始化队列 */
		EnQueue(&q, *T); /* 根指针入队 */
		while (!QueueEmpty(q)) /* 队不空 */
		{
			DeQueue(&q, &a); /* 出队,队列元素赋给a */
			if (a->lchild) /* 有左孩子 */
			{
				a->lchild->parent = a; /* 给左孩子的双亲指针赋值 */
				EnQueue(&q, a->lchild); /* 左孩子入队 */
			}
			if (a->rchild) /* 有右孩子 */
			{
				a->rchild->parent = a; /* 给右孩子的双亲指针赋值 */
				EnQueue(&q, a->rchild); /* 右孩子入队 */
			}
		}
	}
	return OK;
}

#define ClearBiTree DestroyBiTree

Status BiTreeEmpty(BiPTree T)
{ /* 初始条件: 二叉树T存在。操作结果: 若T为空二叉树,则返回TRUE,否则FALSE */
	if (T)
		return FALSE;
	else
		return TRUE;
}

int BiTreeDepth(BiPTree T)
{ /* 初始条件: 二叉树T存在。操作结果: 返回T的深度 */
	int i, j;
	if (!T)
		return 0;
	if (T->lchild)
		i = BiTreeDepth(T->lchild);
	else
		i = 0;
	if (T->rchild)
		j = BiTreeDepth(T->rchild);
	else
		j = 0;
	return i > j ? i + 1 : j + 1;
}

TElemType Root(BiPTree T)
{ /* 初始条件: 二叉树T存在。操作结果: 返回T的根 */
	if (T)
		return T->data;
	else
		return Nil;
}

TElemType Value(BiPTree p)
{ /* 初始条件: 二叉树T存在，p指向T中某个结点 */
  /* 操作结果: 返回p所指结点的值 */
	return p->data;
}

void Assign(BiPTree p, TElemType value)
{ /* 给p所指结点赋值为value */
	p->data = value;
}

BiPTree Point(BiPTree T, TElemType e)
{ /* 返回二叉树T中指向元素值为e的结点的指针。加 */
	LinkQueue q;
	QElemType a;
	if (T) /* 非空树 */
	{
		InitQueue(&q); /* 初始化队列 */
		EnQueue(&q, T); /* 根结点入队 */
		while (!QueueEmpty(q)) /* 队不空 */
		{
			DeQueue(&q, &a); /* 出队,队列元素赋给a */
			if (a->data == e)
				return a;
			if (a->lchild) /* 有左孩子 */
				EnQueue(&q, a->lchild); /* 入队左孩子 */
			if (a->rchild) /* 有右孩子 */
				EnQueue(&q, a->rchild); /* 入队右孩子 */
		}
	}
	return NULL;
}

TElemType Parent(BiPTree T, TElemType e)
{ /* 初始条件: 二叉树T存在,e是T中某个结点 */
  /* 操作结果: 若e是T的非根结点,则返回它的双亲,否则返回＂空＂ */
	BiPTree a;
	if (T) /* 非空树 */
	{
		a = Point(T, e); /* a是结点e的指针 */
		if (a&&a != T) /* T中存在结点e且e是非根结点 */
			return a->parent->data; /* 返回e的双亲的值 */
	}
	return Nil; /* 其余情况返回空 */
}

TElemType LeftChild(BiPTree T, TElemType e)
{ /* 初始条件: 二叉树T存在,e是T中某个结点 */
  /* 操作结果: 返回e的左孩子。若e无左孩子,则返回＂空＂ */
	BiPTree a;
	if (T) /* 非空树 */
	{
		a = Point(T, e); /* a是结点e的指针 */
		if (a&&a->lchild) /* T中存在结点e且e存在左孩子 */
			return a->lchild->data; /* 返回e的左孩子的值 */
	}
	return Nil; /* 其余情况返回空 */
}

TElemType RightChild(BiPTree T, TElemType e)
{ /* 初始条件: 二叉树T存在,e是T中某个结点 */
  /* 操作结果: 返回e的右孩子。若e无右孩子,则返回＂空＂ */
	BiPTree a;
	if (T) /* 非空树 */
	{
		a = Point(T, e); /* a是结点e的指针 */
		if (a&&a->rchild) /* T中存在结点e且e存在右孩子 */
			return a->rchild->data; /* 返回e的右孩子的值 */
	}
	return Nil; /* 其余情况返回空 */
}

TElemType LeftSibling(BiPTree T, TElemType e)
{ /* 初始条件: 二叉树T存在,e是T中某个结点 */
  /* 操作结果: 返回e的左兄弟。若e是T的左孩子或无左兄弟,则返回＂空＂ */
	BiPTree a;
	if (T) /* 非空树 */
	{
		a = Point(T, e); /* a是结点e的指针 */
		if (a&&a != T && a->parent->lchild&&a->parent->lchild != a) /* T中存在结点e且e存在左兄弟 */
			return a->parent->lchild->data; /* 返回e的左兄弟的值 */
	}
	return Nil; /* 其余情况返回空 */
}

TElemType RightSibling(BiPTree T, TElemType e)
{ /* 初始条件: 二叉树T存在,e是T中某个结点 */
  /* 操作结果: 返回e的右兄弟。若e是T的右孩子或无右兄弟,则返回＂空＂ */
	BiPTree a;
	if (T) /* 非空树 */
	{
		a = Point(T, e); /* a是结点e的指针 */
		if (a&&a != T && a->parent->rchild&&a->parent->rchild != a) /* T中存在结点e且e存在右兄弟 */
			return a->parent->rchild->data; /* 返回e的右兄弟的值 */
	}
	return Nil; /* 其余情况返回空 */
}

Status InsertChild(BiPTree p, int LR, BiPTree c) /* 形参T无用 */
{ /* 初始条件: 二叉树T存在,p指向T中某个结点,LR为0或1,非空二叉树c与T */
  /*           不相交且右子树为空 */
  /* 操作结果: 根据LR为0或1,插入c为T中p所指结点的左或右子树。p所指结点 */
  /*           的原有左或右子树则成为c的右子树。 */
	if (p) /* p不空 */
	{
		if (LR == 0)
		{
			c->rchild = p->lchild;
			if (c->rchild) /* c有右孩子(p原有左孩子) */
				c->rchild->parent = c;
			p->lchild = c;
			c->parent = p;
		}
		else /* LR==1 */
		{
			c->rchild = p->rchild;
			if (c->rchild) /* c有右孩子(p原有右孩子) */
				c->rchild->parent = c;
			p->rchild = c;
			c->parent = p;
		}
		return OK;
	}
	return ERROR; /* p空 */
}

Status DeleteChild(BiPTree p, int LR) /* 形参T无用 */
{ /* 初始条件: 二叉树T存在,p指向T中某个结点,LR为0或1 */
  /* 操作结果: 根据LR为0或1,删除T中p所指结点的左或右子树 */
	if (p) /* p不空 */
	{
		if (LR == 0) /* 删除左子树 */
			ClearBiTree(&p->lchild);
		else /* 删除右子树 */
			ClearBiTree(&p->rchild);
		return OK;
	}
	return ERROR; /* p空 */
}

void PreOrderTraverse(BiPTree T, Status(*Visit)(BiPTree))
{ /* 先序递归遍历二叉树T */
	if (T)
	{
		Visit(T); /* 先访问根结点 */
		PreOrderTraverse(T->lchild, Visit); /* 再先序遍历左子树 */
		PreOrderTraverse(T->rchild, Visit); /* 最后先序遍历右子树 */
	}
}

void InOrderTraverse(BiPTree T, Status(*Visit)(BiPTree))
{ /* 中序递归遍历二叉树T */
	if (T)
	{
		InOrderTraverse(T->lchild, Visit); /* 中序遍历左子树 */
		Visit(T); /* 再访问根结点 */
		InOrderTraverse(T->rchild, Visit); /* 最后中序遍历右子树 */
	}
}

void PostOrderTraverse(BiPTree T, Status(*Visit)(BiPTree))
{ /* 后序递归遍历二叉树T */
	if (T)
	{
		PostOrderTraverse(T->lchild, Visit); /* 后序遍历左子树 */
		PostOrderTraverse(T->rchild, Visit); /* 后序遍历右子树 */
		Visit(T); /* 最后访问根结点 */
	}
}

void LevelOrderTraverse(BiPTree T, Status(*Visit)(BiPTree))
{ /* 层序遍历二叉树T(利用队列) */
	LinkQueue q;
	QElemType a;
	if (T)
	{
		InitQueue(&q);
		EnQueue(&q, T);
		while (!QueueEmpty(q))
		{
			DeQueue(&q, &a);
			Visit(a);
			if (a->lchild != NULL)
				EnQueue(&q, a->lchild);
			if (a->rchild != NULL)
				EnQueue(&q, a->rchild);
		}
	}
}


/* --------------------------------------------------------------------------------------------------*/



Status visitT(BiPTree T)
{
	if (T) /* T非空 */
#ifdef CHAR
		printf("%c是", T->data);
	if (T->parent) /* T有双亲 */
	{
		printf("%c", T->parent->data);
#endif
#ifdef INT
		printf("%d是", T->data);
		if (T->parent) /* T有双亲 */
		{
			printf("%d", T->parent->data);
#endif
			if (T->parent->lchild == T)
				printf("的左孩子\n");
			else
				printf("的右孩子\n");
		}
		else
			printf("根结点\n");
		return OK;
	}

	void main()
	{
		int i;
		BiPTree T, c, q;
		TElemType e1, e2;
		InitBiTree(&T);
		printf("构造空二叉树后,树空否？%d(1:是 0:否) 树的深度=%d\n", BiTreeEmpty(T), BiTreeDepth(T));
		e1 = Root(T);
		if (e1 != Nil)
#ifdef CHAR
			printf("二叉树的根为: %c\n", e1);
#endif
#ifdef INT
		printf("二叉树的根为: %d\n", e1);
#endif
		else
			printf("树空，无根\n");
#ifdef CHAR
		printf("请按先序输入二叉树(如:ab三个空格表示a为根结点,b为左子树的二叉树)\n");
#endif
#ifdef INT
		printf("请按先序输入二叉树(如:1 2 0 0 0表示1为根结点,2为左子树的二叉树)\n");
#endif
		CreateBiTree(&T);
		printf("建立二叉树后,树空否？%d(1:是 0:否) 树的深度=%d\n", BiTreeEmpty(T), BiTreeDepth(T));
		e1 = Root(T);
		if (e1 != Nil)
#ifdef CHAR
			printf("二叉树的根为: %c\n", e1);
#endif
#ifdef INT
		printf("二叉树的根为: %d\n", e1);
#endif
		else
			printf("树空，无根\n");
		printf("中序递归遍历二叉树:\n");
		InOrderTraverse(T, visitT);
		printf("后序递归遍历二叉树:\n");
		PostOrderTraverse(T, visitT);
		scanf("%*c"); /* 吃掉回车符 */
		printf("按回车键继续:");
		getchar(); /* 暂停输出 */
		printf("层序遍历二叉树:\n");
		LevelOrderTraverse(T, visitT);
		printf("请输入一个结点的值: ");
#ifdef CHAR
		scanf("%c", &e1);
#endif
#ifdef INT
		scanf("%d", &e1);
#endif
		c = Point(T, e1); /* c为e1的指针 */
#ifdef CHAR
		printf("结点的值为%c\n", Value(c));
#endif
#ifdef INT
		printf("结点的值为%d\n", Value(c));
#endif
		printf("欲改变此结点的值，请输入新值: ");
#ifdef CHAR
		scanf("%*c%c%*c", &e2);
#endif
#ifdef INT
		scanf("%d", &e2);
#endif
		Assign(c, e2);
		printf("层序遍历二叉树:\n");
		LevelOrderTraverse(T, visitT);
		e1 = Parent(T, e2);
		if (e1 != Nil)
#ifdef CHAR
			printf("%c的双亲是%c\n", e2, e1);
#endif
#ifdef INT
		printf("%d的双亲是%d\n", e2, e1);
#endif
		else
#ifdef CHAR
			printf("%c没有双亲\n", e2);
#endif
#ifdef INT
		printf("%d没有双亲\n", e2);
#endif
		e1 = LeftChild(T, e2);
		if (e1 != Nil)
#ifdef CHAR
			printf("%c的左孩子是%c\n", e2, e1);
#endif
#ifdef INT
		printf("%d的左孩子是%d\n", e2, e1);
#endif
		else
#ifdef CHAR
			printf("%c没有左孩子\n", e2);
#endif
#ifdef INT
		printf("%d没有左孩子\n", e2);
#endif
		e1 = RightChild(T, e2);
		if (e1 != Nil)
#ifdef CHAR
			printf("%c的右孩子是%c\n", e2, e1);
#endif
#ifdef INT
		printf("%d的右孩子是%d\n", e2, e1);
#endif
		else
#ifdef CHAR
			printf("%c没有右孩子\n", e2);
#endif
#ifdef INT
		printf("%d没有右孩子\n", e2);
#endif
		e1 = LeftSibling(T, e2);
		if (e1 != Nil)
#ifdef CHAR
			printf("%c的左兄弟是%c\n", e2, e1);
#endif
#ifdef INT
		printf("%d的左兄弟是%d\n", e2, e1);
#endif
		else
#ifdef CHAR
			printf("%c没有左兄弟\n", e2);
#endif
#ifdef INT
		printf("%d没有左兄弟\n", e2);
#endif
		e1 = RightSibling(T, e2);
		if (e1 != Nil)
#ifdef CHAR
			printf("%c的右兄弟是%c\n", e2, e1);
#endif
#ifdef INT
		printf("%d的右兄弟是%d\n", e2, e1);
#endif
		else
#ifdef CHAR
			printf("%c没有右兄弟\n", e2);
#endif
#ifdef INT
		printf("%d没有右兄弟\n", e2);
#endif 
		InitBiTree(&c);
		printf("构造一个右子树为空的二叉树c:\n");
#ifdef CHAR
		printf("请先序输入二叉树(如:ab三个空格表示a为根结点,b为左子树的二叉树)\n");
#endif
#ifdef INT
		printf("请先序输入二叉树(如:1 2 0 0 0表示1为根结点,2为左子树的二叉树)\n");
#endif
		CreateBiTree(&c);
		printf("先序递归遍历二叉树c:\n");
		PreOrderTraverse(c, visitT);
		printf("树c插到树T中,请输入树T中树c的双亲结点 c为左(0)或右(1)子树: ");
#ifdef CHAR
		scanf("%*c%c%d", &e1, &i);
#endif
#ifdef INT
		scanf("%d%d", &e1, &i);
#endif
		q = Point(T, e1);
		InsertChild(q, i, c);
		printf("先序递归遍历二叉树:\n");
		PreOrderTraverse(T, visitT);
		printf("删除子树,请输入待删除子树的双亲结点  左(0)或右(1)子树: ");
#ifdef CHAR
		scanf("%*c%c%d", &e1, &i);
#endif
#ifdef INT
		scanf("%d%d", &e1, &i);
#endif
		q = Point(T, e1);
		DeleteChild(q, i);
		printf("先序递归遍历二叉树:\n");
		PreOrderTraverse(T, visitT);
		DestroyBiTree(&T);
	}

运行结果：

数据结构三叉链表与线索二叉树的思路与实现详解
微凉秋意的博客
04-16 1374
我们知道最常见的链式存储二叉树的结构体中有数据域、左孩子指针以及右孩子指针，通过递归来创建二叉树。显而易见的是，想找到二叉树中任意一个结点的前驱或后继也要通过根结点不断递归，加以辅助变量来完成。这种方法的效率必然不高，因此我们可以采用三叉链表（增加一个父结点）或者增加线索来优化二叉树结构。
Java创建二叉树的3种方式
12-05
Java实现二叉树的3种方式，顺序二叉树的实现，二叉树的三叉链表存储，二叉树的二叉链表实现
【考研复习】二叉树的特殊存储｜三叉链表存储二叉树、一维数组存储二叉树、线索二叉树
最新发布
m0_52427832的博客
11-14 3741
使用中序遍历的顺序进行线索化。代码中有一个难以理解的点，为什么不用p直接找后继，而是使用了前驱结点找后继。实际上，不是不用p找后继，而是从p找不到后继，所以只能间接地找前驱的后继，这样的方式找后继，明白了这点，代码就不难懂了。另外设计一个填充函数，函数功能是将所有结点的parent结点填充正确。
数据结构考点
weixin_41683726的博客
08-26 2099
中级软件设计师考试---数据结构
数据结构基础概念篇
热门推荐
小草莓的博客
11-14 31万+
数据结构一些概念 数据结构就是研究数据的逻辑结构和物理结构以及它们之间相互关系，并对这种结构定义相应的运算，而且确保经过这些运算后所得到的新结构仍然是原来的结构类型。数据：所有能被输入到计算机中，且能被计算机处理的符号的集合。是计算机操作的对象的总称。 数据元素：数据（集合）中的一个“个体”，数据及结构中讨论的基本单位 数据项：数据的不可分割的最小单位。一个数据元素可由若干个数据项组成。 数据类
三叉链表及树的遍历
流痕的博客
10-04 4214
文章目录树的三叉链表双亲链表二叉树遍历 树的三叉链表 元素：lchild data rchild parent typedef struct TriTNode { int data; //左右孩子指针 struct TriTNode *lchild, *rchild; struct TriTnode *parent; }TriTNode,*TriTree; 双亲链表 两个结构表示一个树 typedef struct BPTNode { int data;
数据结构C语言版二叉树的三叉链表存储表示.doc
07-13
二叉树的三叉链表存储表示 二叉树是一种基本的数据结构，它在计算机科学中广泛应用。二叉树的三叉链表存储表示是指用链表来存储二叉树的结点，其中每个结点包括数据域、双亲指针、左孩子指针和右孩子指针。这种存储...
数据结构C语言版-二叉树的三叉链表存储表示.doc
09-30
数据结构C语言版-二叉树的三叉链表存储表示.doc
二叉树的三叉链表存储表示
11-18
二叉树的三叉链表存储表示.
数据结构5.9二叉树的链式存储-三叉链表
11-19
### 数据结构5.9二叉树的链式存储-三叉链表 #### 一、基础知识概述 在学习三叉链表之前，我们先来回顾一下什么是二叉树以及链式存储的基本概念。 **二叉树**是一种常见的非线性数据结构，其中每个节点最多有两个...
5.4 数据结构——二叉树的存储结构
weixin_45523296的博客
10-17 325
二叉树的顺序存储结构和链式存储结构（二叉链表、三叉链表）。
Java基础 - 二叉树的三叉链表存储
ApatheCrazyFan的博客
11-09 1265
三叉链表存储的思想是让每个节点不仅“记住”它的左、右两个子节点，还要“记住”它的父节点，因此需要为每个节点增加left、right和parent 三个指针，分别引用该节点的左、右两个子节点和父节点。
【数据结构笔记11】数据结构之二叉树的存储结构（顺序存储、二叉链表、三叉链表）
✅ Java 开发工程师，从事 Web 应用程序的研发，擅长 Spring、SpringBoot 等技术。 ✅ 热爱编程，业余时间学习新知识，通过 CSDN 记录学习心得和笔记内容。
12-10 1115
二叉树的顺序存储，是利用数组这种结构依次保存二叉树中的每一个结点，我们就拿满二叉树来举例子，满二叉树中除了最后一层结点之外，其余结点都是具有左右孩子结点的，那么一颗高度等于h的满二叉树，它就一定具有【2^h - 1】个结点，也就是需要一个长度等于【2^h - 1】的一维数组来保存。
《数据结构》-二叉树(三叉链表实现)
tyustli
07-21 7245
main.c /* * Change Logs: * Date Author Notes * 2021-07-21 tyustli first version */ #include "tree.h" void visitT(TElemType e) { printf("%d ", e); } int main(int argc, char *argv[]) { printf("this bitree\r\n"); in
三叉链表
No Pain, No Gain .
11-11 4165
在二叉链表的基础上增加了一个指向双亲的指针域。 data、lchild和rchild三个域的含义同二叉链表的结点结构； parent域为指向该结点的双亲结点的指针。 结点数据类型声明： template<class T> struct Node { T data; Node<T> * lchild, *rchild,*parent; }; template &l...
数据结构与算法·第6章【树】
qq_61786525的博客
06-07 750
我们使用变量 pre 来保存当前遍历过的最后一个节点，在循环中不断更新，直到遍历到最后一个节点。最后，我们将最后一个节点的右子树指针指向头结点，并将头结点的右指针指向最后一个节点。需要注意的是，在整个过程中，我们只需要通过修改线索来实现中序遍历，无需创建新的节点或者修改原有节点的结构。这就是中序线索二叉树的优点，它可以大大提高中序遍历的效率，减少程序的内存占用。
写出二叉树的二叉链表和三叉链表的存储结构_考研数据结构知识框架
weixin_39608301的博客
10-21 509
数据结构之后有可能会有上机考试，基本考点不会超出课本范围，整理一拨儿方便日后复习~~数据结构类型：逻辑结构，存储结构，对数据的运算一.线性表核心知识点：线性表逻辑结构特性：数据元素之间存在线性关系，计算机中表示此结构的存储结构是顺序存储结构（顺序表）和链式存储结构（链表）顺序表：元素存储先后位置反映出其逻辑上的线性关系，借助数组来表示。链表：依靠指针反应线性逻辑关系（与随机存储结构对比）；单链，循...
【图解数据结构】树和二叉树全面总结（上）
知心宝贝的博客
01-01 4820
一、前言 学习目标： 重点： 难点： 二、树的概念和定义 定义：n(n>=0)个结点的有限集合，n=0，空树 结点：表示树中的元素 根结点：第一个元素 叶结点：度为0，即没有子树 双亲结点：结点的直接前驱 孩子结点：结点的直接后继 兄弟结点：同一双亲结点的孩子 结点的度：结点的子树个数 结点的层次：根节点层次为1，依次向下加一 树的度：树中所有结点度的最大值 树的高度：树中所有结点层次的最大值 森林:m(m>=0)棵互不相交树的集合 例题： 求出..
三叉链表存储二叉树
chichuowei5964的博客
08-03 2850
二叉树的三叉链式存储 三叉链式存储的思想是让每个节点不仅“记住”它的左，右两个节点，还要“记住”它的父节点，因此每个节点需要left，right，parent三个指针。 三叉链表存储方式是对二叉链表的一种改进，通过为树节点添加一个parent引用，可以让每个节点都能非常方便...
二叉树三叉链表实现与操作详解
"这篇资源是关于数据结构中的二叉树实现，特别地，它使用了三叉链表来表示二叉树。代码是用C语言编写的，包含了创建、操作和遍历二叉树的各种函数。" 二叉树是一种常用的数据结构，它由节点构成，每个节点最多有两...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值