数据结构之树与二叉树（二）

最新推荐文章于 2025-03-10 08:00:00 发布
原创 最新推荐文章于 2025-03-10 08:00:00 发布 · 1k 阅读 · 12 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
数据结构

当前文章被收录于：

数据结构
14 篇文章 0 人学习
订阅专栏 查看详情
本文详细介绍了二叉树的概念，包括二叉树的定义、特殊类型如满二叉树和完全二叉树的特性，以及二叉树的顺序存储结构和链式存储结构。在顺序存储结构中，给出了初始化、判断空树、求深度、创建、遍历等操作的代码实现。而在链式存储结构中，文章描述了结点结构和相应的操作，如创建、遍历和销毁二叉树。

tips：本文只涉及二叉树的顺序存储和链式存储！！！

目录

二叉树

1. 二叉树的相关概念

1.1 二叉树的定义

  1. 二叉树是另一种树形结构，其特点是每个结点至多只有两颗子树（即二叉树中不存在大于2的结点），并且二叉树的子树有左右之分，其次序不能任意颠倒。
  2. 与树相似，二叉树也以递归的形式定义。二叉树是n(n >= 0) 个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两颗互不相交的、分别称为根结点的左子树和右子树的二叉树组成。
  3. 二叉树具有以下五种基本形态：
    空二叉树、只有一个根结点、根结点只有左子树、根结点只有右子树、根结点即有左子树又有右子树。

1.2 二叉树和树的区别

  1. 度为2 的树至少有3个结点，而二叉树可以为空。
  2. 度为2的有序树的孩子的左右次序是相对于另一个孩子而言的，若某个结点只有一个孩子，则这个孩子就无须区分其左右次序，而二叉树无论其孩子数是否为2，均需确定其左右次序，即二叉树的结点次序不是相对于另一个结点而言的，而是确定的。
    3.$

1.3 特殊的二叉树

1.3.1 满二叉树
  1. 一颗高度为h，且含有2h-1个结点的二叉树称为满二叉树，即树中每层都含有最多的结。满二叉树的叶子结点都集中在二叉树的最下一层，并且除叶子结点之外的每个结点度数均为2。
  2. 可以对满二叉树按层编号：约定编号从根结点起，自下而上，自左向右。每个结点对应一个编号，对于编号为 i 的结点，若有双亲，则其双亲为 ⌊ i / 2 ⌋ \lfloor i / 2 \rfloor ⌊i/2⌋ （ ⌊ x ⌋ 表示不大于 x 的最大整数） （\lfloor x \rfloor 表示不大于x的最大整数） （⌊x⌋表示不大于x的最大整数） ，若有左孩子则左孩子为 2i；若有右孩子，则有孩子为 2i+1 .
    满二叉树
1.3.2 完全二叉树

高度为 h、有n个结点的二叉树，当且仅当其每个结点都与高度为h的满二叉树中编号i ~ n的结点意义对应时，称为完全二叉树。
完全二叉树

其特点如下：

  1. 若 i ≤ ⌊ n / 2 ⌋ i \leq \lfloor n /2 \rfloor i≤⌊n/2⌋,则结点i 为分支结点，否则为叶子结点。
  2. 叶子结点只可能在层次最大的两层上出现。对于最大层次中的叶子结点，都依次排序在该层的最左边的位置上。
  3. 若有度为1的结点，则只可能出现一个，且该结点只有左孩子而无右孩子。
  4. 按层序编号后，一旦出现某结点(n=i）为叶子结点或只有左孩子，则编号大于i的结点均为叶子结点。
  5. 若n为奇数，则每个分支结点都有左孩子和右孩子；若n为偶数，则编号最大的分支结点（编号为n/2）只有左孩子，没有右孩子，其余分支结点都有左孩子和右孩子。

1.4 二叉树的性质

  1. 非空二叉树上的叶子结点数等于度为2的结点数加1，即 n 0 = n 2 + 1 n_0=n_2+1 n0​=n2​+1.
  2. 非空二叉树上第k层上至多有2k-1个结点（ k ≥ 1 k\geq1 k≥1）.
  3. 高度为h的二叉树至多有2h-1个结点（ h ≥ 1 h\geq1 h≥1）.
  4. 对于完全二叉树按从上到下，从左到右的顺序依次编号1、2、…、n,则有以下关系：
    1）当 i > 1 i>1 i>1时，结点i的双亲的编号为 ⌊ i / 2 ⌋ \lfloor i/2 \rfloor ⌊i/2⌋，即当i为偶数时，其双亲的编号为 i / 2 i/2 i/2 ，它是双亲的左孩子；当i为奇数时，其双亲的编号为 ( i − 1 ) / 2 (i-1)/2 (i−1)/2，它是双亲的右孩子。
    2）当 2 i ≤ n 2i \leq n 2i≤n时，结点 i i i 的左孩子编号为 2 i 2i 2i ,否则无左孩子。
    3）当 2 i + 1 ≤ n 2i+1 \leq n 2i+1≤n时，结点 i i i 的右孩子编号为 2 i + 1 2i+1 2i+1，否则没有右孩子。
    4)结点 i i i所在层次（深度）为 ⌊ l o g 2 i ⌋ + 1 \lfloor log_{2}i\rfloor+1 ⌊log2​i⌋+1
  5. 具有n个（n>0）结点的完全二叉树的高度为 ⌊ l o g 2 n ⌋ + 1 \lfloor log_{2}n\rfloor+1 ⌊log2​n⌋+1 或 ⌈ l o g 2 n + 1 ⌉ \lceil log_{2}n+1\rceil ⌈log2​n+1⌉ ( ⌈ x ⌉ 表示不小于 x 的最小整数 \lceil x\rceil 表示不小于x的最小整数 ⌈x⌉表示不小于x的最小整数)

3. 二叉树的存储结构

3.1 顺序存储结构

3.1.1 定义

二叉树的顺序存储结构是指用一组地址连续的存储单元依次自上而下、自左向右存储完全二叉树上的结点元素，即将完全二叉树上编号为 i i i的结点元素存储在一维数组下标为 i − 1 i-1 i−1的分量中。
依据二叉树的性质，完全二叉树和满二叉树采用顺序存储比较合适，树中结点的序号可以唯一的反映结点之间的逻辑关系，这样既能最大可能的节省存储空间，又能利用数组元素的下标值确定结点在二叉树中的位置，以及结点之间的关系。
但对于一般的二叉树，为了让数组下标能反映二叉树中结点之间的逻辑关系，只能添加并不存在的空结点，让其每个结点与完全二叉树上的结点对照，在存储到一维数组的相应分量中。然而，在最坏情况下，一个高度h且只有h个结点的单支树却需要占据近2h-1个存储单元。
注意：建议从数组下标1开始存储树中的结点。

3.1.2 基本操作
//初始化（构造空二叉树）
//判空
//求树的深度
//按层序创建二叉树
//层序遍历二叉树
//求根结点的值
//返回位置e的值
//给位置e赋新值
//求结点的双亲
//求结点的左孩子
//求结点的右孩子
//求结点的左兄弟
//求结点的右兄弟
//前序遍历
//中序遍历
//后序遍历
//按层输出
3.1.3 代码实现
#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 100  //数组的初始空间分配大小
#define MAX_TREE_SIZE 99   //二叉树的最大结点数

typedef int TElemType;
typedef int Status;
typedef TElemType SqBiTree[MAX_TREE_SIZE];   //1号单元存储根结点

typedef struct
{
	int level;  //结点的层
	int order;  //本层序号（按满二叉树计算）
}Position;

TElemType Nil = 0; //设整型以0为空
1.初始化（构造空二叉树）
//构造空二叉树T。
Status InitBiTree(SqBiTree T)
{
	int i;
	for (i = 1; i < MAX_TREE_SIZE; i++)
	{
		T[i] = Nil;  //初始值为空  将数组中的所有元素置为0
	}
	return 0;
}
2.判空
//判空
Status BiTreeEmpty(SqBiTree T)
{
	if (T[1] == Nil) //根结点为空，则树为空
	{
		return TRUE;  //空
	}
	else
	{
		return FALSE;  //不为空
	}
}
3.求树的深度
//求二叉树的深度
int BiTreeDepth(SqBiTree T)
{
	int i = 0;
	int j = 0;
	for (i = MAX_TREE_SIZE - 1; i >= 1; i--)
	{
		if (T[i] != Nil)
		{
			break;
		}
	}
	i++;
	do
	{
		j++;
	} while (i >= powl(2, j));  //计算2的j次幂

	return j;
}
4.按层序创建二叉树

//按层序构造顺序存储的二叉树T
Status CreateBiTree(SqBiTree T)
{
	int i = 1;
	printf("结点数≤%d:\n", MAX_TREE_SIZE-1); //最多只能有98个结点
	while (i <= 10) //结点数为10
	{
		T[i] = i;

		if (i != 1 && T[i / 2] == Nil && T[i] != Nil) /* 此结点(不空)无双亲且不是根 */
		{
			printf("出现无双亲的非根结点%d\n", T[i]);
			exit(ERROR);
		}
		i++;
	}
	while (i < MAX_TREE_SIZE)
	{
		T[i] = Nil; /* 将空赋值给T的后面的结点 */
		i++;
	}

	return OK;
}
5.层序遍历二叉树
/* 层序遍历二叉树 */
Status visit(TElemType c)
{
	printf("%d ", c);
	return OK;
}

void LevelOrderTraverse(SqBiTree T)
{
	int i = MAX_TREE_SIZE - 1, j;

	while (T[i] == Nil)
	{
		i--; /* 找到最后一个非空结点的序号 */
	}	

	for (j = 1; j <= i; j++)  /* 从根结点起,按层序遍历二叉树 */
	{
		if (T[j] != Nil)
		{
			visit(T[j]); /* 只遍历非空的结点 */
		}	
	}
		
	printf("\n");
}

在这里插入图片描述

6.求根结点的值
//求根结点的值
Status Root(SqBiTree T, TElemType* e)
{
	if (BiTreeEmpty(T))  //空
	{
		return ERROR;
	}
	else
	{
		*e = T[1]; //用e返回根结点的值
		return OK;
	}
}

在这里插入图片描述

7.返回位置e的值

//返回处于位置e(第level层的第order个结点)的值
TElemType Value(SqBiTree T, Position e)
{
	return T[(int)powl(2, e.level - 1) + e.order - 1];
	//第i层有至多有2^{k-1}个结点，+e.order-1之后可以得到本层第order个结点的值
}

在这里插入图片描述

8.给位置e赋新值
//给处于位置e(第level层第order个结点)赋新值value
Status Assign(SqBiTree T, Position e, TElemType value)
{
	int i = (int)powl(2, e.level - 1) + e.order - 1;
	if (value != Nil && T[i/2] == Nil) 
	{   /* 给叶子赋非空值但双亲为空 */
		return ERROR;
	}
	else if (value == Nil && (T[i * 2] != Nil || T[i * 2 + 1] != Nil))
	{   /*  给双亲赋空值但有叶子（不空） */
		return ERROR;
	}

	T[i] = value;

	return OK;
}

在这里插入图片描述

9.求结点的双亲
//求结点的双亲
TElemType Parent(SqBiTree T, TElemType e)
{
	int i;
	if (T[1] == Nil)  //空树
	{
		return Nil;
	}
	for (i = 2; i <= MAX_TREE_SIZE - 1; i++) //根结点T[1]无双亲，从2开始
	{
		if (T[i] == e)   //找到e
		{
			return T[i / 2]; //双亲结点在数组中的位置
		}
	}

	return Nil;  //没找到e

}

在这里插入图片描述

10.求结点的左孩子
//求结点的左孩子
TElemType LeftChild(SqBiTree T, TElemType e)
{
	int i = 0;
	if (T[1] == Nil)
	{
		return ERROR; //空树
	}

	for (i = 1; i <= MAX_TREE_SIZE - 1; i++)
	{
		if (T[i] == e)
		{
			return T[i * 2];
		}
	}
	return Nil;  //没找到
}

在这里插入图片描述

11.求结点的右孩子
//求结点的右孩子
TElemType RightChild(SqBiTree T, TElemType e)
{
	int i = 0;
	if (T[1] == Nil)
	{
		return ERROR; //空树
	}

	for (i = 0; i <= MAX_TREE_SIZE - 1; i++)
	{
		if (T[i] == e)
		{
			return T[i * 2 + 1];
		}
	}

	return Nil;
}

在这里插入图片描述

12.求结点的左兄弟
//求结点的左兄弟
TElemType LeftSibling(SqBiTree T, TElemType e)
{
	int i = 0;
	if (T[1] == Nil)
	{
		return ERROR;
	}
	for (i = 2; i <= MAX_TREE_SIZE - 1; i++)  //根结点T[1]没有左兄弟，i从2开始
	{
		if (T[i] == e && i % 2 == 1)
		{
			return T[i - 1];
		}
	}
	return Nil;  //没找到e结点
}

在这里插入图片描述

13.求结点的右兄弟
//求结点的右兄弟
TElemType RightSibling(SqBiTree T, TElemType e)
{
	int i = 0;
	if (T[1] == Nil)
	{
		return ERROR; //空树
	}
	for (i = 2; i <= MAX_TREE_SIZE - 1; i++)
	{
		if (T[i] == e && i % 2 == 0)
		{
			return T[i + 1];
		}
	}
	return Nil;
}

在这里插入图片描述

14.前序遍历

//前序遍历二叉树
void PreTraverse(SqBiTree T, int e)
{
	visit(T[e]);  //打印输出结点的值

	if (T[2 * e] != Nil) /* 左子树不空 */
	{
		PreTraverse(T, 2 * e);
	}
		
	if (T[2 * e + 1] != Nil) /* 右子树不空 */
	{
		PreTraverse(T, 2 * e + 1);
	}
		
}

Status PreOrderTraverse(SqBiTree T)
{
	if (!BiTreeEmpty(T)) /* 树不空 */
	{
		PreTraverse(T, 1);
	}	
	printf("\n");

	return OK;
}

在这里插入图片描述

15.中序遍历
//中序遍历二叉树
void InTraverse(SqBiTree T, int e)
{
	if (T[2 * e] != Nil)  //左子树不为空
	{
		InTraverse(T, 2 * e);
	}
	visit(T[e]);   //打印
	if (T[2 * e + 1] != Nil)   //右子树不为空
	{
		InTraverse(T, 2 * e + 1);
	}
}

Status InOrderTraverse(SqBiTree T)
{
	if (!BiTreeEmpty(T))
	{
		InTraverse(T, 1);
	}
	printf("\n");

	return OK;
}

在这里插入图片描述

16.后序遍历
//后序遍历二叉树
void PostTraverse(SqBiTree T, int e)
{
	if (T[2 * e] != Nil)
	{
		PostTraverse(T, 2 * e);
	}
	if (T[2 * e + 1] != Nil)
	{
		PostTraverse(T, 2 * e + 1);
	}
	visit(T[e]);
}

Status PostOrderTraverse(SqBiTree T)
{
	if (!BiTreeEmpty(T))
	{
		PostTraverse(T, 1);
	}
	printf("\n");

	return OK;
}

在这里插入图片描述

17.按层输出
//逐层、按本层序号输出二叉树
void Print(SqBiTree T)
{
	int j = 0;
	int k = 0;
	Position p;
	TElemType e = 0;
	for (j = 1; j <= BiTreeDepth(T); j++)
	{
		printf("第%d层：", j);
		for (k = 1; k <= powl(2, j - 1); k++)
		{
			p.level = j;
			p.order = k;
			e = Value(T, p);
			if (e != Nil)
			{
				printf("第%d个:%d ", k, e);
			}
		}
		printf("\n");
	}

}

在这里插入图片描述

18.清空
#define ClearBiTree InitBiTree /* 在顺序存储结构中，两函数完全一样 */

在这里插入图片描述

3.1.4 完整代码
#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 100  //数组的初始空间分配大小
#define MAX_TREE_SIZE 99   //二叉树的最大结点数

typedef int TElemType;
typedef int Status;
typedef TElemType SqBiTree[MAX_TREE_SIZE];   //1号单元存储根结点

typedef struct
{
	int level;  //结点的层
	int order;  //本层序号（按满二叉树计算）
}Position;

TElemType Nil = 0; //设整型以0为空

//构造空二叉树T。
Status InitBiTree(SqBiTree T)
{
	int i;
	for (i = 1; i < MAX_TREE_SIZE; i++)
	{
		T[i] = Nil;  //初始值为空  将数组中的所有元素置为0
	}
	return 0;
}


//判空
Status BiTreeEmpty(SqBiTree T)
{
	if (T[1] == Nil) //根结点为空，则树为空
	{
		return TRUE;  //空
	}
	else
	{
		return FALSE;  //不为空
	}
}

//求二叉树的深度
int BiTreeDepth(SqBiTree T)
{
	int i = 0;
	int j = 0;
	for (i = MAX_TREE_SIZE - 1; i >= 1; i--)
	{
		if (T[i] != Nil)
		{
			break;
		}
	}
	i++;
	do
	{
		j++;
	} while (i >= powl(2, j));  //计算2的j次幂

	return j;
}


//按层序构造顺序存储的二叉树T
Status CreateBiTree(SqBiTree T)
{
	int i = 1;
	printf("结点数≤%d:\n", MAX_TREE_SIZE-1); //最多只能有98个结点
	while (i <= 10) //结点数为10
	{
		T[i] = i;

		if (i != 1 && T[i / 2] == Nil && T[i] != Nil) /* 此结点(不空)无双亲且不是根 */
		{
			printf("出现无双亲的非根结点%d\n", T[i]);
			exit(ERROR);
		}
		i++;
	}
	while (i < MAX_TREE_SIZE)
	{
		T[i] = Nil; /* 将空赋值给T的后面的结点 */
		i++;
	}

	return OK;
}


/* 层序遍历二叉树 */
Status visit(TElemType c)
{
	printf("%d ", c);
	return OK;
}

void LevelOrderTraverse(SqBiTree T)
{
	int i = MAX_TREE_SIZE - 1, j;

	while (T[i] == Nil)
	{
		i--; /* 找到最后一个非空结点的序号 */
	}	

	for (j = 1; j <= i; j++)  /* 从根结点起,按层序遍历二叉树 */
	{
		if (T[j] != Nil)
		{
			visit(T[j]); /* 只遍历非空的结点 */
		}	
	}
		
	printf("\n");
} 

//求根结点的值
Status Root(SqBiTree T, TElemType* e)
{
	if (BiTreeEmpty(T))  //空
	{
		return ERROR;
	}
	else
	{
		*e = T[1]; //用e返回根结点的值
		return OK;
	}
}

//返回处于位置e(第level层的第order个结点)的值
TElemType Value(SqBiTree T, Position e)
{
	return T[(int)powl(2, e.level - 1) + e.order - 1];
	//第i层有至多有2^{k-1}个结点，+e.order-1之后可以得到本层第order个结点的值
}


//给处于位置e(第level层第order个结点)赋新值value
Status Assign(SqBiTree T, Position e, TElemType value)
{
	int i = (int)powl(2, e.level - 1) + e.order - 1;
	if (value != Nil && T[i/2] == Nil) 
	{   /* 给叶子赋非空值但双亲为空 */
		return ERROR;
	}
	else if (value == Nil && (T[i * 2] != Nil || T[i * 2 + 1] != Nil))
	{   /*  给双亲赋空值但有叶子（不空） */
		return ERROR;
	}

	T[i] = value;

	return OK;
}

//求结点的双亲
TElemType Parent(SqBiTree T, TElemType e)
{
	int i;
	if (T[1] == Nil)  //空树
	{
		return Nil;
	}
	for (i = 2; i <= MAX_TREE_SIZE - 1; i++) //根结点T[1]无双亲，从2开始
	{
		if (T[i] == e)   //找到e
		{
			return T[i / 2]; //双亲结点在数组中的位置
		}
	}

	return Nil;  //没找到e

}

//求结点的左孩子
TElemType LeftChild(SqBiTree T, TElemType e)
{
	int i = 0;
	if (T[1] == Nil)
	{
		return ERROR; //空树
	}

	for (i = 1; i <= MAX_TREE_SIZE - 1; i++)
	{
		if (T[i] == e)
		{
			return T[i * 2];
		}
	}
	return Nil;  //没找到
}

//求结点的右孩子
TElemType RightChild(SqBiTree T, TElemType e)
{
	int i = 0;
	if (T[1] == Nil)
	{
		return ERROR; //空树
	}

	for (i = 0; i <= MAX_TREE_SIZE - 1; i++)
	{
		if (T[i] == e)
		{
			return T[i * 2 + 1];
		}
	}

	return Nil;
}

//求结点的左兄弟
TElemType LeftSibling(SqBiTree T, TElemType e)
{
	int i = 0;
	if (T[1] == Nil)
	{
		return ERROR;
	}
	for (i = 2; i <= MAX_TREE_SIZE - 1; i++)  //根结点T[1]没有左兄弟，i从2开始
	{
		if (T[i] == e && i % 2 == 1)
		{
			return T[i - 1];
		}
	}
	return Nil;  //没找到e结点
}

//求结点的右兄弟
TElemType RightSibling(SqBiTree T, TElemType e)
{
	int i = 0;
	if (T[1] == Nil)
	{
		return ERROR; //空树
	}
	for (i = 2; i <= MAX_TREE_SIZE - 1; i++)
	{
		if (T[i] == e && i % 2 == 0)
		{
			return T[i + 1];
		}
	}
	return Nil;
}


//前序遍历二叉树
void PreTraverse(SqBiTree T, int e)
{
	visit(T[e]);  //打印输出结点的值

	if (T[2 * e] != Nil) /* 左子树不空 */
	{
		PreTraverse(T, 2 * e);
	}
		
	if (T[2 * e + 1] != Nil) /* 右子树不空 */
	{
		PreTraverse(T, 2 * e + 1);
	}
		
}

Status PreOrderTraverse(SqBiTree T)
{
	if (!BiTreeEmpty(T)) /* 树不空 */
	{
		PreTraverse(T, 1);
	}	
	printf("\n");

	return OK;
}

//中序遍历二叉树
void InTraverse(SqBiTree T, int e)
{
	if (T[2 * e] != Nil)  //左子树不为空
	{
		InTraverse(T, 2 * e);
	}
	visit(T[e]);   //打印
	if (T[2 * e + 1] != Nil)   //右子树不为空
	{
		InTraverse(T, 2 * e + 1);
	}
}

Status InOrderTraverse(SqBiTree T)
{
	if (!BiTreeEmpty(T))
	{
		InTraverse(T, 1);
	}
	printf("\n");

	return OK;
}

//后序遍历二叉树
void PostTraverse(SqBiTree T, int e)
{
	if (T[2 * e] != Nil)
	{
		PostTraverse(T, 2 * e);
	}
	if (T[2 * e + 1] != Nil)
	{
		PostTraverse(T, 2 * e + 1);
	}
	visit(T[e]);
}

Status PostOrderTraverse(SqBiTree T)
{
	if (!BiTreeEmpty(T))
	{
		PostTraverse(T, 1);
	}
	printf("\n");

	return OK;
}

//逐层、按本层序号输出二叉树
void Print(SqBiTree T)
{
	int j = 0;
	int k = 0;
	Position p;
	TElemType e = 0;
	for (j = 1; j <= BiTreeDepth(T); j++)
	{
		printf("第%d层：", j);
		for (k = 1; k <= powl(2, j - 1); k++)
		{
			p.level = j;
			p.order = k;
			e = Value(T, p);
			if (e != Nil)
			{
				printf("第%d个:%d ", k, e);
			}
		}
		printf("\n");
	}

}

#define ClearBiTree InitBiTree /* 在顺序存储结构中，两函数完全一样 */


void test01()
{
	//1.初始化二叉树
	SqBiTree T;
	InitBiTree(T);

	//2.创建结点数为10的二叉树
	CreateBiTree(T);//请按层序输入结点的值(整型)，0表示空结点，输999结束。结点数≤98:
	//3.层序遍历二叉树
	LevelOrderTraverse(T);   //1 2 3 4 5 6 7 8 9 10
	//4.判空
	Status i_empty = BiTreeEmpty(T);
	printf("该二叉树是否为空（1为是/0为否）：%d\n", i_empty); //该二叉树是否为空（1为是/0为否）：0
	//5.求二叉树的深度
	int i_depth = BiTreeDepth(T);
	printf("该二叉树的深度为：%d\n", i_depth); //该二叉树的深度为：4

	printf("---------------------------------------\n");

	//6.求二叉树的根结点
	TElemType e_root = Root(T, &e_root);
	printf("二叉树的根结点为:%d\n", e_root);   //二叉树的根结点为:1

	printf("---------------------------------------\n");

	//7.求第level层的第order个结点的值
	Position p = {4,3};
	TElemType e_value = Value(T, p);
	printf("在满二叉树第%d层的第%d个结点的值为：%d\n", p.level, p.order, e_value);
	//在满二叉树第4层的第3个结点的值为：10

	printf("---------------------------------------\n");

	//8.给位置e的结点重新赋值
	Position p1 = { 2,2 }; //第二层的第二个结点
	TElemType e = 20;
	Assign(T, p1, e);
	//层序遍历二叉树
	LevelOrderTraverse(T);   //1 2 20 4 5 6 7 8 9 10

	printf("---------------------------------------\n");

	//9.求结点的双亲
	e = 20;
	TElemType i_parent = Parent(T, e);
	printf("结点%d的双亲是%d\n", e, i_parent);  //结点20的双亲是1

	//10.求结点的左孩子
	e = 20;
	TElemType i_leftchild = LeftChild(T, e);
	printf("结点%d的左孩子是%d\n", e, i_leftchild);   //结点20的左孩子是6

	//11.求结点的右孩子
	e = 20;
	TElemType i_rightchild = RightChild(T, e);
	printf("结点%d的右孩子是%d\n", e, i_rightchild);   //结点20的右孩子是7

	//12.求结点的左兄弟
	e = 20;
	TElemType i_leftsibling = LeftSibling(T, e);
	printf("结点%d的左兄弟是%d\n", e, i_leftsibling);  //结点20的左兄弟是2

	//13.求结点的右兄弟
	e = 6;
	TElemType i_rightsibling = RightSibling(T, e);
	printf("结点%d的右兄弟是%d\n", e, i_rightsibling);  //结点6的右兄弟是7

	printf("---------------------------------------\n");

	//14.层序遍历二叉树
	LevelOrderTraverse(T);   //1 2 20 4 5 6 7 8 9 10

	//15.前序遍历二叉树
	PreOrderTraverse(T);  //1 2 4 8 9 5 10 20 6 7

	//16.中序遍历二叉树
	InOrderTraverse(T);  //8 4 9 2 10 5 1 6 20 7

	//17.后序遍历二叉树
	PostOrderTraverse(T);   //8 9 4 10 5 2 6 7 20 1

	//18.逐层、按本层序号输出二叉树
	Print(T);
	//第1层：第1个:1
	//第2层：第1个 : 2 第2个 : 20
	//第3层：第1个 : 4 第2个 : 5 第3个 : 6 第4个 : 7
	//第4层：第1个 : 8 第2个 : 9 第3个 : 10


	printf("---------------------------------------\n");
	//19.清空
	ClearBiTree(T);
	//层序遍历二叉树
	LevelOrderTraverse(T);   //
	//判空
	i_empty = BiTreeEmpty(T);
	printf("该二叉树是否为空（1为是/0为否）：%d\n", i_empty); //该二叉树是否为空（1为是/0为否）：1
	//求二叉树的深度
	i_depth = BiTreeDepth(T);
	printf("该二叉树的深度为：%d\n", i_depth); //该二叉树的深度为：1
}

int main()
{
	test01();

	return 0;
}

3.2 链式存储结构

3.2.1 定义

由于顺序存储空间利用效率较低，因此二叉树一般采用链式存储结构存储，用链表结点来存储二叉树中的每个结点。
在二叉树中，结点结构通常包含若干数据域和若干指针域，二叉链表中至少包含3个域：数据域data、左指针域lchild、右指针域rchild.

3.2.2 基本操作
//初始化树
//创建树
//判空
//求树的深度
//求根结点
//前序遍历
//中序遍历
//后序遍历
//清空
//销毁
3.2.3 代码实现
#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#include<math.h>
#include<time.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 100  //存储空间初始分配量

typedef int Status;

//用于构造二叉树的准备————————————————————————
int treeIndex = 1;
typedef char String[24];   //0号单元存放串的长度
String str;

Status StrAssign(String T, char* chars)
{
	int i = 0;
	if (strlen(chars) > MAXSIZE)
	{
		return ERROR;
	}
	else
	{
		T[0] = strlen(chars);
		for (i = 1; i <= T[0]; i++)
		{
			T[i] = *(chars + i - 1);
		}
		return OK;
	}
}
//_______________________________________


typedef char TElemType;
TElemType Nil = ' ';  //字符型以空格符为空

typedef struct BiTNode   //结点结构
{
	TElemType data;
	struct BiTNode* lchild;
	struct BiTNode* rchild;
}BiTNode,*BiTree;
1.初始化树
//构造空二叉树
Status InitBiTree(BiTree* T)
{
	*T = NULL;//头指针指向空
	return OK;
}

在这里插入图片描述

2.创建树
//按前序输入二叉树中结点的值（一个字符）
void CreateBiTree(BiTree* T)
{
	TElemType ch;

	//scanf("%c",&ch);
	ch = str[treeIndex++];

	if (ch == '#')
	{
		*T = NULL;  //#表示空树
	}
	else 
	{
		*T = (BiTree)malloc(sizeof(BiTNode));

		if (!*T)
		{
			exit(OVERFLOW);
		}
		(*T)->data = ch;
		CreateBiTree(&(*T)->lchild);  //构造左子树
		CreateBiTree(&(*T)->rchild);   //构造右子树
	}
}
3.判空
//判空
Status BiTreeEmpty(BiTree T)
{
	if (T)
	{
		return FALSE;  //不为空
	}
	else
	{
		return TRUE;  //为空
	}

}
4.求树的深度
//求二叉树的深度
int BiTreeDepth(BiTree T)
{
	int i;
	int 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;
}

在这里插入图片描述

5.求根结点
//返回树的根结点
TElemType Root(BiTree T)
{
	if (BiTreeEmpty(T))
	{
		return Nil;
	}
	else
	{
		return T->data;  //返回头指针指向的结点的值
	}
}

在这里插入图片描述

6.前序遍历
/* 初始条件: 二叉树T存在 */
/* 操作结果: 前序递归遍历T */
void PreOrderTraverse(BiTree T)
{
	if (T == NULL)
	{
		return;
	}
	printf("%c", T->data);/* 显示结点数据，可以更改为其它对结点操作 */
	PreOrderTraverse(T->lchild); /* 再先序遍历左子树 */
	PreOrderTraverse(T->rchild); /* 最后先序遍历右子树 */
}

在这里插入图片描述

7.中序遍历
/* 初始条件: 二叉树T存在 */
/* 操作结果: 中序递归遍历T */
void InOrderTraverse(BiTree T)
{
	if (T == NULL)
	{
		return;
	}
	InOrderTraverse(T->lchild); /* 中序遍历左子树 */
	printf("%c", T->data);/* 显示结点数据，可以更改为其它对结点操作 */
	InOrderTraverse(T->rchild); /* 最后中序遍历右子树 */
}

在这里插入图片描述

8.后序遍历

/* 初始条件: 二叉树T存在 */
/* 操作结果: 后序递归遍历T */
void PostOrderTraverse(BiTree T)
{
	if (T == NULL)
	{
		return;
	}
	PostOrderTraverse(T->lchild); /* 先后序遍历左子树  */
	PostOrderTraverse(T->rchild); /* 再后序遍历右子树  */
	printf("%c", T->data);/* 显示结点数据，可以更改为其它对结点操作 */
}

在这里插入图片描述

9.清空
#define ClearBiTree DestroyBiTree

在这里插入图片描述

10.销毁
/* 初始条件: 二叉树T存在。操作结果: 销毁二叉树T */
void DestroyBiTree(BiTree* T)
{
	if (*T)
	{
		if ((*T)->lchild) /* 有左孩子 */
		{
			DestroyBiTree(&(*T)->lchild); /* 销毁左孩子子树 */
		}
			
		if ((*T)->rchild) /* 有右孩子 */
		{
			DestroyBiTree(&(*T)->rchild); /* 销毁右孩子子树 */
		}
		free(*T); /* 释放根结点 */
		*T = NULL; /* 空指针赋0 */
	}
}
3.2.4 完整代码
#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#include<math.h>
#include<time.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 100  //存储空间初始分配量

typedef int Status;

//用于构造二叉树的准备————————————————————————
int treeIndex = 1;
typedef char String[24];   //0号单元存放串的长度
String str;

Status StrAssign(String T, char* chars)
{
	int i = 0;
	if (strlen(chars) > MAXSIZE)
	{
		return ERROR;
	}
	else
	{
		T[0] = strlen(chars);
		for (i = 1; i <= T[0]; i++)
		{
			T[i] = *(chars + i - 1);
		}
		return OK;
	}
}
//_______________________________________


typedef char TElemType;
TElemType Nil = ' ';  //字符型以空格符为空

typedef struct BiTNode   //结点结构
{
	TElemType data;
	struct BiTNode* lchild;
	struct BiTNode* rchild;
}BiTNode,*BiTree;

//构造空二叉树
Status InitBiTree(BiTree* T)
{
	*T = NULL;//头指针指向空
	return OK;
}

//按前序输入二叉树中结点的值（一个字符）
void CreateBiTree(BiTree* T)
{
	TElemType ch;

	//scanf("%c",&ch);
	ch = str[treeIndex++];

	if (ch == '#')
	{
		*T = NULL;  //#表示空树
	}
	else 
	{
		*T = (BiTree)malloc(sizeof(BiTNode));

		if (!*T)
		{
			exit(OVERFLOW);
		}
		(*T)->data = ch;
		CreateBiTree(&(*T)->lchild);  //构造左子树
		CreateBiTree(&(*T)->rchild);   //构造右子树
	}
}

//判空
Status BiTreeEmpty(BiTree T)
{
	if (T)
	{
		return FALSE;  //不为空
	}
	else
	{
		return TRUE;  //为空
	}

}

//求二叉树的深度
int BiTreeDepth(BiTree T)
{
	int i;
	int 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(BiTree T)
{
	if (BiTreeEmpty(T))
	{
		return Nil;
	}
	else
	{
		return T->data;  //返回头指针指向的结点的值
	}
}

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


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


/* 初始条件: 二叉树T存在 */
/* 操作结果: 前序递归遍历T */
void PreOrderTraverse(BiTree T)
{
	if (T == NULL)
	{
		return;
	}
	printf("%c", T->data);/* 显示结点数据，可以更改为其它对结点操作 */
	PreOrderTraverse(T->lchild); /* 再先序遍历左子树 */
	PreOrderTraverse(T->rchild); /* 最后先序遍历右子树 */
}

/* 初始条件: 二叉树T存在 */
/* 操作结果: 中序递归遍历T */
void InOrderTraverse(BiTree T)
{
	if (T == NULL)
	{
		return;
	}
	InOrderTraverse(T->lchild); /* 中序遍历左子树 */
	printf("%c", T->data);/* 显示结点数据，可以更改为其它对结点操作 */
	InOrderTraverse(T->rchild); /* 最后中序遍历右子树 */
}
 

/* 初始条件: 二叉树T存在 */
/* 操作结果: 后序递归遍历T */
void PostOrderTraverse(BiTree T)
{
	if (T == NULL)
	{
		return;
	}
	PostOrderTraverse(T->lchild); /* 先后序遍历左子树  */
	PostOrderTraverse(T->rchild); /* 再后序遍历右子树  */
	printf("%c", T->data);/* 显示结点数据，可以更改为其它对结点操作 */
}


#define ClearBiTree DestroyBiTree


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



void test01()
{
	//初始化
	BiTree T;
	InitBiTree(&T);
	StrAssign(str, "ABDH#K###E##CFI###G#J##");
	//判空
	Status i_empty = BiTreeEmpty(T);
	printf("二叉树是否为空（1为是/0为否）：%d\n", i_empty); //二叉树是否为空（1为是/0为否）：1
	//求二叉树的深度
	int i_length = BiTreeDepth(T);
	printf("二叉树的深度为：%d\n", i_length);  //二叉树的深度为：0

	printf("--------------------------\n");

	//创建链树
	CreateBiTree(&T);
	//判空
	i_empty = BiTreeEmpty(T);
	printf("二叉树是否为空（1为是/0为否）：%d\n", i_empty);  //二叉树是否为空（1为是/0为否）：0
	i_length = BiTreeDepth(T);
	printf("二叉树的深度为：%d\n", i_length);   //二叉树的深度为：5

	printf("--------------------------\n");

	//求根结点
	TElemType e_root = Root(T);
	printf("二叉树的根结点为：%c\n",e_root);  //二叉树的根结点为：A


	//前序遍历
	PreOrderTraverse(T);   //ABDHKECFIGJ
	printf("\n____________\n");  

	//中序遍历
	InOrderTraverse(T);   //HKDBEAIFCGJ
	printf("\n____________\n");


	//后序遍历
	PostOrderTraverse(T);    //KHDEBIFJGCA
	printf("\n____________\n");  


	//清空
	ClearBiTree(&T);
	//判空
	i_empty = BiTreeEmpty(T);
	printf("二叉树是否为空（1为是/0为否）：%d\n", i_empty);  //二叉树是否为空（1为是/0为否）：1
	i_length = BiTreeDepth(T);
	printf("二叉树的深度为：%d\n", i_length);   //二叉树的深度为：0
}

int main()
{

	test01();

	return 0;
}

END

标签
#数据结构
【C语言】打印二叉树树形（制表符实现，清晰+高拓展）（2022-10-22 更新—偏移量说明）
Ice__Clean的博客
11-01 1万+
—— 目录 ——0. 前言1. 效果展示2. 核心代码及解读3. 辅助代码 0. 前言 上 CSDN 找了很多份树形代码，一个共通的感觉就是拓展性不够强 比如说树大了节点之间被撑开无法兼容性不好 没有使用树枝连接的画显示稍显混乱，使用斜线当树枝又不好拓展 还有一部分就是代码太冗长看不懂 基于此，我打算用回制表符，力求清晰显示出树形 肝了几个小时的代码，过程中一点一点调出来树形 代码部分也在不断优化，思路在不断的调试中也不断改变 最后总结出一种以绝对偏移量画树形的方法，下边将一一对代码进行解释 1. 效果展
计算二叉树的深度（递归）
qq_43186174的博客
11-30 8233
二叉树的深度（递归） 思想： 1.如果为空树，返回0； 2.如果不是空树 （1）递归计算左子树的深度，记为m （2）递归计算右子树的深度，记为n 若m>n, 返回m+1 否则返回n+1 int depth(BiTree T) { if(T == NULL) return 0; else { m = depth(T -> lchild); n = depth(T -> rchild); if(m
二叉树的初始化·数据结构
S_JYYDS的博客
04-26 1万+
二叉树是什么？ 二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树特点是每个节点最多只能有两棵子树，且有左右之分 思路： 首先，需要创建一个BTNode的结点，结点包含了数据，两个指针——lchild和rchild，再一个BTNode的构造函数，来初始化结点 接着，创建二叉树的类，类包含了头结点，以及各函数的实现操作。（初始化函数、创建树函
【数据结构第五章】- 二叉树（万字详解）
melonyzzZ的博客
04-02 779
详解数据结构第五章-二叉树
二叉树的学习
m0_63783532的博客
11-11 1610
2.n = n1 + 2n2 + 1（树的结点数 = 总度数 + 1，其中度为0的结点数有n0个，度数和为0×n0；1.n = n0 + n1 + n2（树的结点数 = 度为0的结点数 + 度为1的结点数 + 度为2的结点数）分析：第一层有1个结点；总共有1+2+2^2......+2^(h-1)=(1-2^h)/(1-2)=2^h-1。又推出若完全二叉树有2k个（偶数）个结点，则必有n1=1，n0=k，n2=k-1。若完全二叉树有2k-1个（奇数）个结点，则必有n1=0，n0=k，n2=k-1。
数据结构（二）——树与二叉树
LongXinKou的博客
04-11 926
文章目录1. 树的基本概念1.1 定义1.2 性质2. 二叉树2.1 几种特殊的二叉树2.2 二叉树的性质 复习重点 树与二叉树的性质。 满二叉树、完全二叉树、二叉排序树、平衡二叉树、哈夫曼树的定义和性质。 遍历操作、转换、存储结构。 1. 树的基本概念 问题：树和图的区别 树的任何非根节点只有一个前驱节点。 非空树有一个根节点。 1.1 定义 度：节点的子树棵树。 宽度：树中节点最大的度。 深度：根节点为第一层，根节点的子节点为第二层，一次类推。 问题： 度为m的树和m叉树的区别？ 度为m的
数据结构-5树和二叉树（二）
最新发布
qq_55433334的博客
03-10 1710
根节点的父节点为 -1，表示它没有父节点。节点和的父节点是，索引为 0。节点和的父节点是，索引为 1，以此类推。“双亲表示法”是一种树形结构的存储方式。它的基本思想是将树中的每个节点与其父节点的信息存储在数组中。
浅谈【数据结构】树与二叉树二
weixin_67526434的博客
08-25 1406
浅谈【数据结构】树与二叉树二
【算法与数据结构笔记】二.树与二叉树
计算机科研杂货铺
02-09 1338
树是由n(n≥0)个结点组成的有穷集合（不妨用符号D来表示这个集合）与在D上关系的集合R构成的结构，记为T。当n=0时，成为空树。二叉树是n(n≥0)个结点的有穷集合D与D上的关系集合R构成的结构。注：二叉树是有序树，在二叉树中严格区分结点的左右孩子，次序不能随意颠倒，否则就变成另一棵二叉树，如下图所示，这是两棵不同的树。
数据结构_C语言_实验二_树 ——还原二叉树
Erostrate9
11-06 2186
文章目录实验二 树1. 实验目的2. 实验内容3. 实验要求4. 实验过程(1) 问题描述(2) 数据结构与算法设计(3) 程序实现(4) 实验结果(5) 实验总结 实验二 树 ——还原二叉树 1. 实验目的 熟练掌握二叉树存储结构、遍历及应用。 2. 实验内容 给定一棵二叉树的先序遍历序列和中序遍历序列，要求计算该二叉树的高度。 3. 实验要求 (1) 输入格式说明： 输入首先给出正整数N（<=50），为树中结点总数。下面2行先后给出先序和中序遍历序列，均是长度为N的不包含重复英文字母（区别大小写）
数据结构 第六章 树与二叉树（二）
2401_84080967的博客
04-23 1699
①：满二叉树就是除去二叉树最后一层的所有节点都有两个孩子，即节点的度都为2。按着定义说就是对于高度为h的二叉树，若其节点数为2h−12^h-12h−1个节点的二叉树称为满二叉树。就如下图所示，其就为满二叉树；叶子节点只出现在最后一层不存在度为1的节点按层序从1开始编号，节点i的左孩子的序号是2i，右孩子是2i+1；节点i的父节点是向下取整的⌊i2⌋⌊i/2⌋。②：完全二叉树。
数据结构 找到二叉树中的最大搜索二叉子树
OY_palada
08-23 2327
程序员代码面试指南（左程云）读书笔记 第三章     找到二叉树中的最大搜索二叉子树 题目：给定一棵二叉树的头节点head, 已知其中所有节点的值都不一样，找到含有节点最多的搜索二叉子树，并返回这颗子树的头节点。  例如：如图二叉树           这颗二叉树的最大搜索二叉子树如图所示 要求：          如果节点数为N，
【C++】超详细！数据结构——树（二、树与二叉树Ⅱ）
hacker_code的博客
07-29 649
二叉树静态实现以及树的存储和遍历
数据结构：树与二叉树（二） 二叉树
Viadimir的博客
05-05 600
这篇文章讲一下二叉树ADT。 1.二叉树数据结构 （1）二叉树（Binary Tree）是一个有限元素的集合（可以空），它或者是空（空二叉树），或者由一个称为根的元素以及分别称为左子树和右子树的两个互不相交的集合组成，这个两个集合又都是二叉树。 上面这个定义太绕口了，我读了好几遍才明白，二叉树，说白了就是每个结点最多只有两个孩子结点（即孩子结点数量<=2）。 （2）二叉树有五种形态，...
数据结构--》解锁数据结构中树与二叉树的奥秘（二）
ztK63LrD的博客
10-10 624
堆是一种特殊的完全二叉树，它具有以下两个特性：1）堆中任意节点的值都必须满足堆的性质：对于大根堆（或最大堆），每个节点的值都大于等于其子节点的值；对于小根堆（或最小堆），每个节点的值都小于等于其子节点的值。2）堆中的二叉树总是完全填满的，即除了最后一层，其他层都是满的，且最后一层从左到右连续。
数据结构(8) 树[二]（ 二叉树以及性质）
热门推荐
cowbin2012的专栏
05-08 1万+
二叉树定义 二叉树：是n（n>=0）个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树的二叉树组成。 如下图就是一个二叉树： 二叉树特点 二叉树的特点有： 每个结点最多两个子树，所以二叉树中不存在度大于2的结点。注意不是只有两棵子树，而是最多有。没有子树或者有一棵子树都是可以的。 左子树和右子树是有顺序的，次序不能任意颠倒...
六、数据结构笔记：树[二]（ 二叉树以及性质）
张伯毅的专栏
01-23 5550
二叉树定义 二叉树：是n（n&gt;=0）个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树的二叉树组成。 如下图就是一个二叉树：   二叉树特点 二叉树的特点有： 每个结点最多两个子树，所以二叉树中不存在度大于2的结点。注意不是只有两棵子树，而是最多有。没有子树或者有一棵子树都是可以的。 左子树和右子...
【数据结构】树（二）—— 二叉树（C语言版）
haoweixl的博客
05-10 4038
二叉树二叉树的定义二叉树的特点特点五种基本形态特殊二叉树斜树满二叉树完全二叉树二叉树的性质二叉树的存储结构二叉树顺序存储结构二叉链表(链式存储结构)遍历二叉树前序遍历递归版非递归版中序遍历非递归版后序遍历递归版非递归版层序遍历推导遍历结果二叉树的建立 二叉树的定义 二叉树(Binary Tree)是n(n≥0)个结点的有限集合， 该集合或者为空集(称为空二叉树)，或者由一个根节点和两棵互不相交的、分别称为根节点的左子树和右子树的二叉树组成。 二叉树的特点 特点 每个结点最多有两棵子树，故不存在度大于2的结点
数据结构——树与二叉树（二）
weixin_44157233的博客
08-07 476
二叉树的基本操作和实现 顺序存储结构 顺序存储结构利用了满二叉树和完全二叉树的基本概念。 1.首先把要要存储的树补充为完全二叉树，然后对补充过的树中的每个结点按层次进行编号， 2.然后以各结点的编号作为该存储相应结点的数组下标，将各结点的值存储到一维数组中。 顺序存储的方式比较适合存储完全二叉树。经典例子：堆排序。 链式存储结构 二叉树的链式存储，通常分为两种： 1、二叉链...
数据结构之树和二叉树(二)
weixin_34208185的博客
11-15 95
一、二叉树的定义(二叉树是树的特殊一族) 二叉树（Binary Tree）是n（n>=0）个结点的有限集合，该集合或者为空集（空二叉树），或者由一个根结点 和两棵互不相交的、分别称为根结点的左子树和右子树的二叉树组成。 总结：二叉树的定义有点复杂，看起来定义有点混乱。这没事，主要是利用二叉树的特点办事。(*^...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值