严蔚敏-树和二叉树-遍历二叉树-森林

最新推荐文章于 2022-10-15 19:22:28 发布
最新推荐文章于 2022-10-15 19:22:28 发布
阅读量678 收藏 8
点赞数 2
分类专栏： # 数据结构学习笔记 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43488958/article/details/104171941
版权

数据结构学习笔记【第6章 树和二叉树】

文章目录

6.1 树的定义和基本术语

  • 树(Tree)是n(n≥0）个结点的有限集，有且只有一个根结点，其余结点可划分为不同的根的子树
  • 树的结点包含一个数据元素及若干指向其子树的分支
  • 结点拥有的子树数称为结点的度(Degree)
  • 度数为0的结点称为叶子(Leaf)或终端结点
  • 度数不为0的结点称为非终端结点或分支结点
  • 树的度是树内各结点的度的最大值
  • 结点的子树的跟称为该结点的孩子，该结点称为孩子的双亲，同一个双亲的孩子互称兄弟
  • 结点的祖先是从根到该结点所经分支上的所有结点，反之，以某结点为根的子树的任意结点都称为该结点的子孙
  • 结点的层次(Level)从根开始定义起，根为第一层，根的孩子为第二层
  • 其双亲在同一层的结点互称为堂兄弟
  • 树中结点的最大层次称为树的深度
  • 如果树中结点的各子树看成从左到右是有次序的，则称该树为有序树，否则称为无序树
  • 森林(Forest)是m(m≥0)棵互不相交的树的集合

6.2 二叉树

6.2.1 二叉树的定义

  • 二叉树(Binary Tree)是另一种树型结构，它的特点是每个结点至多只有两棵子树（度小于等于2），并且二叉树的子树有左右之分
  • 满二叉树一棵深度为 k k k且有 2 2 2 k k k − 1 -1 −1个结点的二叉树
  • 完全二叉树深度为 k k k的，有n个结点的二叉树，当且仅当其中每一个结点都与深度为 k k k的满二叉树中编号1至n的结点一一对应

6.2.2 二叉树的性质

  • 性质1 在二叉树的第 i i i层上至多有 2 2 2 i − 1 \large i-1 i−1个结点 ( i ≥ 1 ) (i≥1) (i≥1)
  • 性质2 深度为 k k k的二叉树至多有 2 2 2 k k k − 1 -1 −1个结点
  • 性质3 对任何一棵二叉树 T T T，如果其终端结点数为 n n n0，度为2的结点数为 n n n2，则 n n n0 = = = n n n2 + 1 +1 +1
  • 性质4 具有 n n n个结点的完全二叉树的深度为 ⌊ \lfloor ⌊ l o g log log 2 2 2 n n n ⌋ \rfloor ⌋ + 1 +1 +1
    （ ⌊ x ⌋ \lfloor x\rfloor ⌊x⌋表示不大于 x x x的最大整数, ⌈ x ⌉ \lceil x\rceil ⌈x⌉表示不小于 x x x的最小整数）
  • 性质5 如果对一棵有 n n n个结点的完全二叉树（其深度为 ⌊ \lfloor ⌊ l o g log log 2 2 2 n n n ⌋ \rfloor ⌋ + 1 +1 +1）的结点按层序编号（从第1层到第 ⌊ \lfloor ⌊ l o g log log 2 2 2 n n n ⌋ \rfloor ⌋ + 1 +1 +1层，每层从左到右），则对任一结点 i ( 1 ≤ i ≤ n ) i(1\leq i\leq n) i(1≤i≤n)，有
    (1) 如果 i = 1 i=1 i=1，则结点 i i i，是二叉树的根，无双亲；如果 i > 1 i>1 i>1，则其双亲PARENT ( i ) (i) (i)是结点 ⌊ i / 2 ⌋ \lfloor i/2\rfloor ⌊i/2⌋（用于顺序存储时的查询很方便）
    (2) 如果 2 i > n 2i>n 2i>n，则结点 i i i无左孩子（结点 i i i为叶子节点）；否则其左孩子LCHILD ( i ) (i) (i)是结点 2 i 2i 2i
    (3) 如果 2 i + 1 > n 2i+1>n 2i+1>n，则结点 i i i无右孩子；否则其右孩子RCHILD ( i ) (i) (i)是结点 2 i + 1 2i+1 2i+1

6.2.3 二叉树的存储结构

  • 顺序存储结构
    用一组地址连续的存储单元依次自上而下、自左至右存储完全二叉树上的结点元素；对于一般二叉树，则应将其每个结点于完全二叉树上的结点相对照，存储在一维数组的相应分量中
  • 二叉树的顺序存储表示
#define MAX_TREE_SIZE 100
typedef TElemType SqBiTree[MAX_TREE_SIZE];
SqBiTree bt;
  • 链式存储结构
    二叉树的链表中的结点至少包含3个域：数据域和左、右指针域，称之为二叉链表，如若还包含指向双亲结点的指针域则称之为三叉链表
    容易证得，在含有 n n n个结点的二叉链表中有 n + 1 n+1 n+1个空链域
  • 二叉树的二叉链表表示
typedef struct BiTNode {
	TElemType data;
	struct BiTNode* lchild, * rchild;//左右孩子指针
}BiTNode,*BiTree;

6.3 遍历二叉树和线索二叉树

6.3.1 遍历二叉树

  • 遍历二叉树即如何按照某条搜索路径巡访树中每个结点，使得每个结点均被访问一次，而且仅被访问一次
  • 先序遍历二叉树
    若二叉树为空，则空操作；否则
    （1）访问根节点
    （2）先序遍历左子树
    （3）先序遍历右子树
  • 中序遍历二叉树
    若二叉树为空，则空操作；否则
    （1）中序遍历左子树
    （2）访问根节点
    （3）中序遍历右子树
  • 后序遍历二叉树
    若二叉树为空，则空操作；否则
    （1）后序遍历左子树
    （2）后序遍历右子树
    （3）访问根节点
  • 算法6.4 构造二叉链表表示的二叉树T
    按先序次序输入二叉树中结点的值（一个字符），空格字符表示空树
Status CreatBiTree(BiTree& T)
{
	char ch;
	printf("\nPlease input the value of node:");
	scanf_s("%c", &ch);
	getchar();
	if (ch == ' ')T = NULL;
	else {
		if (!(T = (BiTNode*)malloc(sizeof(BiTNode))))exit(OVERFLOW);
		T->data = ch;
		CreatBiTree(T->lchild);
		CreatBiTree(T->rchild);
	}
	return OK;
}
  • 算法6.1 先序遍历二叉树T的递归算法，对每个数据元素调用函数PrintElement
    采用二叉链表存储结构，PrintElement是对数据元素操作的应用函数
Status PreOrderTraverse(BiTree T, Status(*PrintElement)(TElemType e))
{
	if (T) {
		if (PrintElement(T->data))
		{
			if (PreOrderTraverse(T->lchild, PrintElement))
			{
				if (PreOrderTraverse(T->rchild, PrintElement))
				{
					return OK;
				}
			}
		}
		return ERROR;
	}
	else {
		return OK;
	}
}
  • 算法6.2 中序遍历二叉树T的非递归算法，对每个数据元素调用函数PrintElement
    采用二叉链表存储结构，PrintElement是对数据元素操作的应用函数
Status InOrderTraverse(BiTree T, Status(*PrintElement)(TElemType e))
{
	SqStack S;
	InitStack(S);
	Push(S, T);  //根指针进栈
	BiTree p;
	p = (BiTNode*)malloc(sizeof(BiTNode));
	while (!StackEmpty(S)) {
		while (GetTop(S, p) && p)Push(S, p->lchild);
		Pop(S, p);  //空指针退栈
		if (!StackEmpty(S)) {  //访问结点，向右一步
			Pop(S, p);
			if (!(PrintElement(p->data)))return ERROR;
			Push(S, p->rchild);
		}
	}
	return OK;
}
  • 算法6.3 中序遍历二叉树T的非递归算法，对每个数据元素调用函数PrintElement
    采用二叉链表存储结构，PrintElement是对数据元素操作的应用函数
Status InOrderTraverse2(BiTree T, Status(*PrintElement)(TElemType e))
{
	SqStack S;
	InitStack(S);
	BiTree p;
	p = (BiTNode*)malloc(sizeof(BiTNode));
	p = T;
	while (p || !StackEmpty(S)) {
		if (p) {  //根指针进栈，遍历左子树
			Push(S, p);
			p = p->lchild;
		}
		else {  //根指针退栈，访问根结点，遍历右子树
			Pop(S, p);
			if (!(PrintElement(p->data)))return ERROR;
			p = p->rchild;
		}
	}
	return OK;
}
  • 完整代码
#include<stdio.h>
#include<stdlib.h>

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

typedef int Status;
typedef char TElemType;

typedef struct BiTNode {
	TElemType data;
	struct BiTNode* lchild, * rchild;
}BiTNode, * BiTree, * SElemType;

Status CreatBiTree(BiTree& T);
//按先序次序输入二叉树中结点的值（一个字符），空格字符表示空树
//算法6.4 构造二叉链表表示的二叉树T

Status PreOrderTraverse(BiTree T, Status(*PrintElement)(TElemType e));
//采用二叉链表存储结构，PrintElement是对数据元素操作的应用函数
//算法6.1 先序遍历二叉树T的递归算法，对每个数据元素调用函数PrintElement\

Status InOrderTraverse(BiTree T, Status(*PrintElement)(TElemType e));
//采用二叉链表存储结构，PrintElement是对数据元素操作的应用函数
//算法6.2 中序遍历二叉树T的非递归算法，对每个数据元素调用函数PrintElement

Status InOrderTraverse2(BiTree T, Status(*PrintElement)(TElemType e));
//采用二叉链表存储结构，PrintElement是对数据元素操作的应用函数
//算法6.3 中序遍历二叉树T的非递归算法，对每个数据元素调用函数PrintElement

typedef BiTree SElemType;

#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10

Status PrintElement(TElemType e);

typedef struct {
	SElemType* base;
	SElemType* top;
	int stacksize;
}SqStack;

Status InitStack(SqStack& S);
Status StackEmpty(SqStack& S);
Status GetTop(SqStack S, SElemType& e);
Status Push(SqStack& S, SElemType e);
Status Pop(SqStack& S, SElemType& e);

int main()
{
	BiTree T;
	CreatBiTree(T);
	PreOrderTraverse(T, PrintElement);
	printf("\n");
	InOrderTraverse(T, PrintElement);
	printf("\n");
	InOrderTraverse2(T, PrintElement);
	system("pause");
	return 0;
}
Status InitStack(SqStack& S)
{
	S.base = (SElemType*)malloc(STACK_INIT_SIZE * sizeof(SElemType));
	if (!S.base) exit(OVERFLOW);
	S.top = S.base;
	S.stacksize = STACK_INIT_SIZE;
	return OK;
}
Status StackEmpty(SqStack& S)
{
	if (S.top == S.base) return TRUE;
	return FALSE;
}
Status GetTop(SqStack S, SElemType& e)
{
	if (S.top == S.base) return ERROR;
	e = *(S.top - 1);
	return OK;
}
Status Push(SqStack& S, SElemType e)
{
	if (S.top - S.base >= S.stacksize) {
		S.base = (SElemType*)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(SElemType));
		if (!S.base) exit(OVERFLOW);
		S.top = S.base + S.stacksize;
		S.stacksize += STACKINCREMENT;
	}
	*S.top++ = e;
}
Status Pop(SqStack& S, SElemType& e)
{
	if (S.top == S.base) return ERROR;
	e = *--S.top;
	return OK;
}
Status PrintElement(TElemType e)
{
	printf("%c ", e);
	return OK;
}
Status CreatBiTree(BiTree& T)
{
	char ch;
	printf("\nPlease input the value of node:");
	scanf_s("%c", &ch);
	getchar();
	if (ch == ' ')T = NULL;
	else {
		if (!(T = (BiTNode*)malloc(sizeof(BiTNode))))exit(OVERFLOW);
		T->data = ch;
		CreatBiTree(T->lchild);
		CreatBiTree(T->rchild);
	}
	return OK;
}
Status PreOrderTraverse(BiTree T, Status(*PrintElement)(TElemType e))
{
	if (T) {
		if (PrintElement(T->data))
		{
			if (PreOrderTraverse(T->lchild, PrintElement))
			{
				if (PreOrderTraverse(T->rchild, PrintElement))
				{
					return OK;
				}
			}
		}
		return ERROR;
	}
	else {
		return OK;
	}
}
Status InOrderTraverse(BiTree T, Status(*PrintElement)(TElemType e))
{
	SqStack S;
	InitStack(S);
	Push(S, T);  //根指针进栈
	BiTree p;
	p = (BiTNode*)malloc(sizeof(BiTNode));
	while (!StackEmpty(S)) {
		while (GetTop(S, p) && p)Push(S, p->lchild);
		Pop(S, p);  //空指针退栈
		if (!StackEmpty(S)) {  //访问结点，向右一步
			Pop(S, p);
			if (!(PrintElement(p->data)))return ERROR;
			Push(S, p->rchild);
		}
	}
	return OK;
}
Status InOrderTraverse2(BiTree T, Status(*PrintElement)(TElemType e))
{
	SqStack S;
	InitStack(S);
	BiTree p;
	p = (BiTNode*)malloc(sizeof(BiTNode));
	p = T;
	while (p || !StackEmpty(S)) {
		if (p) {  //根指针进栈，遍历左子树
			Push(S, p);
			p = p->lchild;
		}
		else {  //根指针退栈，访问根结点，遍历右子树
			Pop(S, p);
			if (!(PrintElement(p->data)))return ERROR;
			p = p->rchild;
		}
	}
	return OK;
}

6.3.2 线索二叉树

线索二叉树结点结构

  • 以上述结点结构构成的二叉链表作为二叉树的存储结构，叫做线索链表，其中指向结点前驱和后继的指针叫做线索。加上线索的二叉树称之为线索二叉树(Threaded Binary Tree)。对二叉树以某种次序遍历使其变为线索二叉树的过程叫做线索化。
  • 二叉树的二叉线索存储表示
    （error)
#include<stdio.h>
#include<stdlib.h>

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

typedef int Status;
typedef char TElemType;

typedef enum PointerTag{Link,Thread};

typedef struct BiThrNode {
	TElemType data;
	struct BiThrNode* lchild, * rchild;
	PointerTag LTag, RTag;
}BiThrNode,*BiThrTree;

Status PrintElement(TElemType e);

Status CreatBiTree(BiThrTree& T);

Status InOrderTraverse_Thr(BiThrTree T, Status(*PrintElement)(TElemType e));
//T指向头结点，头结点的左链lchild指向根结点，可参见线索化算法
//算法6.5 中序遍历二叉线索树T的非递归算法，对每个数据元素调用函数visit

Status InOrderThreading(BiThrTree& Thrt, BiThrTree T);
//中序遍历二叉树T，并将其中序线索化，Thrt指向头节点
//算法6.5 中序遍历建立中序线索化链表

void InThreading(BiThrTree p);
//算法6.6 中序遍历建立中序线索化链表

int main()
{
	BiThrTree T,Thrt;
	CreatBiTree(T);
	InOrderThreading(Thrt,T);
	InOrderTraverse_Thr(Thrt,PrintElement);
	system("pause");
	return 0;
}
Status PrintElement(TElemType e)
{
	if (e == ' ')return ERROR;
	printf("%c ", e);
	return OK;
}
Status CreatBiTree(BiThrTree& T)
{
	char ch;
	printf("\nPlease input the value of node:");
	scanf_s("%c", &ch);
	getchar();
	if (ch == ' ')T = NULL;
	else {
		if (!(T = (BiThrNode*)malloc(sizeof(BiThrNode))))exit(OVERFLOW);
		T->data = ch;
		CreatBiTree(T->lchild);
		CreatBiTree(T->rchild);
	}
	return OK;
}
Status InOrderTraverse_Thr(BiThrTree T, Status(*PrintElement)(TElemType e))
{
	BiThrNode* p;
	p = T->lchild;
	while (p != T) {
		while (p->LTag == Link)p = p->lchild;
		if (!PrintElement(p->data))return ERROR;
		while (p->RTag == Thread && p->rchild != T) {
			p = p->rchild;
			PrintElement(p->data);
		}
		p = p->rchild;
	}
	return OK;
}
Status InOrderThreading(BiThrTree& Thrt, BiThrTree T)
{
	if (!(Thrt = (BiThrTree)malloc(sizeof(BiThrNode))))exit(OVERFLOW);
	Thrt->LTag = Link; Thrt->RTag = Thread;
	Thrt->rchild = Thrt;
	if (!T)Thrt->lchild = Thrt;
	else {
		Thrt->lchild = T;
		BiThrNode* pre;
		pre = Thrt;
		InThreading(T);
		pre->rchild = Thrt;
		pre->RTag = Thread;
		Thrt->rchild = pre;
	}
	return OK;
}
void InThreading(BiThrTree p)
{
	BiThrNode* pre;
	pre = (BiThrNode*)malloc(sizeof(BiThrNode));
	if (p) {
		InThreading(p->lchild);
		if (!p->lchild) {
			p->LTag = Thread;
			p->lchild = pre;
		}
		else {
			p->LTag = Link;
		}
		if (!pre->rchild) {
			pre->RTag = Thread;
			pre->rchild = p;
			pre = p;
			InThreading(p->rchild);
		}
		else {
			p->RTag = Link;
		}
	}
}

6.4 树和森林

6.4.1 树的存储结构

  1. 双亲表示法
#define MAX_TREE_SIZE 100
typedef struct PTNode {  //结点结构
	TElemType data;
	int parent;  //双亲位置域
}PTNode;

typedef struct {  //树结构
	PTNode nodes[MAX_TREE_SIZE];
	int r, n;  //根的位置和结点数
};

这种存储结构利用了每个结点（除根以外）只有惟一的双亲的性质。这种表示法中，求结点的孩子时需要遍历整个结构。
2. 孩子表示法

#define MAX_TREE_SIZE 100
typedef struct CTNode {  //孩子结点
	int child;
	struct CTNode* next;
}*ChildPtr;
typedef struct {
	TElemType data;
	ChildPtr firstchild;  //孩子链表头指针
}CTBox;
typedef struct {
	CTBox nodes[MAX_TREE_SIZE];
	int n, r;  //结点数和根的位置
}CTree;

把每个结点的孩子排列起来，看成一个线性表，且以单链表作存储结构，则 n n n个结点有 n n n个孩子链表（叶子的孩子链表为空表），而 n n n个头指针又组成一个线性表。孩子表示法便于那些涉及孩子的操作的实现。
3. 孩子兄弟表示法

#define MAX_TREE_SIZE 100
typedef struct CSNode {
	TElemType data;
	struct CSNode* firstchild, * nextsibling;
}CSNode,*CSTree;

链表中结点的两个链域分别指向该结点的第一个孩子结点和下一个兄弟结点。利用这种存储结构便于实现各种树的操作。

6.4.2 森林与二叉树的转换

  • 一张图解释
    森林与二叉树的转换

6.4.3 树和森林的遍历

树的两种遍历方法
  1. 先根（次序）遍历树，即先访问根结点再依次遍历根的每棵子树
  2. 后根（次序）遍历树，即先依次遍历根的每棵子树再访问根结点
森林的两种遍历方法
  1. 先序遍历森林
    若森林非空，则按下述规则遍历之：
    （1）访问森林中第一棵树的根结点；
    （2）先序遍历第一棵树中根结点的子树森林；
    （3）先序遍历除去第一棵树之后剩余的树构成的森林。
  2. 中序遍历森林
    若森林非空，则按下述规则遍历之：
    （1）中序遍历第一棵树中根结点的子树森林；
    （2）访问第一棵树的根结点；
    （3）中序遍历除去第一棵树之后剩余的树构成的森林。

6.5 树与等价问题

  • 未完待续…

6.6 赫夫曼树及其应用

  • 未完待续…

6.7 回溯法与树的遍历

  • 未完待续…

6.8 树的计数

  • 未完待续…
AmarisEx
关注
专栏目录
数据结构--清华严蔚敏版 --二叉树的遍历--案例实现
05-22
二叉树的定义、二叉树的前序、中序与后续的遍历代码实现
严蔚敏数据结构二叉树的先序中序后序遍历(递归方式)
JordanNotes
12-23 1575
难度级别:A  #include #include struct BiTNode{ char data; struct BiTNode *lchild; struct BiTNode *rchild; }; typedef struct BiTNode *BiTree; void CreatBiTree(BiTree *T) { char ch; ch=getchar();
树和二叉树，遍历，深度，c程序，数据机构，严蔚敏
12-31
9、 按先序遍历的扩展序列建立二叉树的存储结构 10、二叉树先序、中序、后序遍历的递归算法 11、二叉树中序遍历的非递归算法 12、二叉树层次遍历的非递归算法 13、求二叉树的深度(后序遍历) 14、建立树的存储结构
数据结构(C语言版)严蔚敏---二叉树遍历、操作二叉树的相关代码
最新发布
坚持不懈的大白的博客
10-15 725
本篇文章主要提供二叉树的遍历、操作二叉树的相关代码，仅供参考！
严蔚敏数据结构 二叉树的建立和遍历
03-03
严蔚敏数据结构一书中 ，通过用户输入中序建立二叉树，以及其遍历，程序用有例子调用
数据结构严蔚敏----二叉树基本操作20个（用二叉链表结构）
qq_41059755的博客
01-04 5625
看之前请注意！博主小菜鸡一个，所以有许多瑕疵，请做好心理准备！ 编程语言：C 编译环境：Dev-C++ 编程实现书P121 ADT BinaryTree 基本操作20个，用二叉链表结构实现 基本概念： 二叉树是一种应用广泛的树型结构，它的特点是每个结点至多只有两棵子树 并且二叉树的子树有左右之分，其次序不能任意颠倒 1.Status InitBiTree(BiTree *T) 构造空二叉树 2....
数据结构-树和二叉树总结
yoro的博客
02-23 540
数据结构中树的一些代码进行总结，想着为PAT打一下基础，树的代码敲有点太少了，不太熟，看了紫书后敲的，avl树的内容紫书不在树这章，所以后补算了 文章目录（一）树的基本概念（二）二叉树1.二叉树的存储结构3.二叉树的遍历前序遍历中序遍历后序遍历构建二叉树层次遍历完整代码3.序列转换前序中序转后序中序后序转前序中序后序转层序中序后序转之字形完整代码4.线索二叉树线索二叉树的结构线索二叉树的构造线...
【数据结构】树：非二叉树（普通树）与森林的遍历
自律带来自由
07-19 4988
#笔记整理 树的定义参照前文： 二叉树、遍历二叉树与线索二叉树等树的定义与解析、二叉树遍历实现 非二叉树与森林的遍历 树的遍历（两种） 1） 先根遍历 若树非空，则遍历方法为： ①访问根结点。 ②从左到右， 依次先根遍历根结点的每一棵子树。 等同于转换的二叉树进行先序遍历 2）后根遍历 若树非空， 则遍历方法为： ①从左到右， 依次后根遍历根结点的每一棵子树。 ②访问根结点。 等同于转换的二叉...
[数据结构] 严蔚敏版 线索二叉树C语言----惊为天人的按线索遍历算法
as12cs的博客
07-22 575
自己完全写不来，只能品一品其中的韵味。 源码来自这里！http://www.cnblogs.com/kangjianwei101/p/5237880.html #ifndef THREADBINARYTREE_H #define THREADBINARYTREE_H #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &l...
4.树和森林——数据结构（严蔚敏 C语言版）
一个人的博客
07-29 341
2.10树和森林 2.10.1树的存储 1.双亲表示法 节点形式： 数据域:存放结点本身信息。 双亲域:指示本结点的双亲结点在数组中的位置。 2.孩子表示法，双亲孩子表示法 3.孩子兄弟表示法 节点形式： 具体形式： 2.11树，森林，二叉树的转换 2.11.1树转二叉树 步骤： 所有的相邻兄弟结点间加一条连线； 保留每个节点与第一个孩子间的连线，删去其他线； 将所生成的二叉树顺时针旋转45°； 转换后的根节点的右孩子必为空。 2.11.2森林转二叉树 步骤： 把森林中的树全部转换
【数据结构 严蔚敏版】 二叉树 基本操作
Friday
12-22 1万+
计算机科学中，二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 一棵深度为k，且有2^k-1个节点的二叉树，称为满二叉树。这种树的特点是每一层上的节点数都是最大节点数。而在一棵二叉树中，除最后一层外，若其余层都是满的，并且最后一层或者是满的，或者是在右边缺少连续若干节点，则...
数据结构实验(严蔚敏版)二叉树的建立与遍历
hqu_fritz的专栏
11-18 2127
#include using namespace std; typedef char TElemType; typedef int Status; typedef struct BitNode { TElemType data; struct BitNode *lchild,*rchild; }BitNode,*BitTree; Status CreatBitTree(BitTree &T)
严蔚敏 数据结构 二叉树链式存储结构 遍历等操作
Shyazhut
10-24 3907
课本 《数据结构（C语言版）（第2版）》 严蔚敏版 树结构的学习。 编译环境：DEV C++ 文件格式为 cpp（c++文件类型），前者的引用函数，在 C 的情况下没完成。 实现： 二叉树的先序遍历创建，三种遍历方法，叶子节点的查询等。 参考 code：  #include #include #define Shyazhut 0//条件启用求叶子节点的函数：0 不使用 c
C：二叉树先序中序后序(递归，非递归)层序遍历算法严蔚敏版[新手向]⑦
qq_44886566的博客
01-26 1440
C：二叉树先序中序后序(递归，非递归)严蔚敏版[新手向]⑦ 近段时间本人在复习数据结构，重新敲一次代码，有什么不足的地方望大佬多多指教，严蔚敏版教程配套算法代码 #include<stdio.h> #include<stdlib.h> #define MAX_TREE_SIZE 100//二叉树的最大结点 #define STACK_INIT_SIZE 100//栈的初...
二叉树的遍历 （C++实现）
热门推荐
zhhp1001的博客
03-06 3万+
本文涉及三种常见的遍历方式 ： 先序遍历、中序遍历、后序遍历，以及用C++实现的非递归版本代码。 首先我们定义一下二叉树结点类 struct BinaryTreeNode { int val; BinaryTreeNode* leftchild; BinaryTreeNode* rightchild; BinaryTreeNode(int const&amp; _val, Bina...
[树] 判断完全二叉树、满二叉树 - C语言（严蔚敏《数据结构》6.49 ）
geodoer
12-24 4515
题目来源：严蔚敏《数据结构》C语言版本习题册 6.49 // 6.49 编写算法判别给定二叉树是否为完全二叉树 Status BiTreeIsComplete(BiTree T) { // 思路：完全二叉树的层次遍历应该是没有NULL的 // 实现：把所有的结点都入队列，包括空指针 BiTNode *queue[maxSize], *p; int front,rear; int fl...
数据结构(C语言版 严蔚敏著)——树
Super_Sloppy的博客
10-11 1480
· 树（tree）是n（n&gt;=0）个结点的有限集。当n=0时成为空树，在任意一颗非空树中： //这里只需掌握定义，重点在二叉树      -有且仅有一个特定的称为根（Root）的结点；     -当n&gt;1时，其余结点可分为m(m&gt;0)个互不相交的有限集T1、T2、...、Tm,      其中集合本身又是一棵树，并且称为根的子树(SubTree)。     - n&gt...
严蔚敏-数据结构-树的遍历
Belle_Chou的博客
10-20 1395
前序非递归遍历 PreOrderTraverse(BiTree T) { InitStack(S); p=T; while (p||!StackEmpty) { if(p) { print(p); if(p-&amp;gt;rchild) { Push(S,p-&amp;gt;rchild); } p=p-&amp;gt;lchild; } else ...
严蔚敏《数据结构》解析：树与二叉树
"清华严蔚敏《数据结构》教学笔记，涵盖了树和二叉树的相关概念，包括数据对象、数据关系、树的基本操作、有向树、有序与无序树的对比，以及结点的度、树的度、叶子结点、分支结点等基本术语。同时介绍了二叉树的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值