数据结构-树

21RGHLY

已于 2022-06-17 17:39:42 修改

阅读量666

点赞数

分类专栏：考研数据结构文章标签：数据结构

于 2022-05-03 20:53:18 首次发布

本文链接：https://blog.csdn.net/RGHLY21/article/details/124561087

版权

考研数据结构专栏收录该内容

5 篇文章 0 订阅

订阅专栏

一、树的定义和性质：

树（Tree）是n（n >= 0）个结点构成的有限集合。当n = 0时，称为空树；对于任何一个非空树（n > 0）,它具备以下性质：

（1）树中有一个成为称为"树根"（Root）的特殊结点，用 r 表示。

（2）其余结点可以划分为m个不相交的子集T1，T2，... ，Tm。任何子集都是一棵树，称为根节点 r 的"子树"（SubTree）。每个子树的根节点都与 r 有一条相连接的边，r 是这些子树根节点的"父结点"。

由上述树的定义可以看出这是一种递归的定义形式。由于子树是不相交的，那么除了根节点外，树中每条边将某个结点与其父结点连起来。因此，除了根节点外，每个结点有且仅有一个父结点。这隐含着一棵树N个结点的树有N - 1条边。

二、森林

m（m >= 0）棵树的集合称为"森林（Forest）"。图4.3（a）是一个具有13个结点的树的逻辑表示形式，根节点A有4个子树，假设命名为TA1、TA2、TA3和TA4（见图4.3中的（b）、（c）、（d）、（e）子图），4个子树的根节点分别是B、C、D和E。B结点又有两个子树，依此类推，树中的每个结点都是其子树的根节点。对于图4.3（a）中根节点A，它的四棵子树TA1、TA2、TA3和TA4就构成了一个森林。因此，任何一棵树都可以看作为一个二元组Tree = （Root，Forest），其中Root是根节点，Forest是这个根节点所有子树构成的森林。

三、树的基本术语：

（1）结点的度（Degree）：一个结点的度是其子树的个数。例如，图4.3（a）中结点D的度为3，节点E的度为0。

（2）树的度：树的所有结点中最大的度数。例如，图4.3（a）中的树中结点A有最大的度数4，所以这棵树的度为4。

（3）叶节点（Leaf）：是度为0的结点。叶节点也可称为端结点，图4.3（a）中E、F、H、J、K、L和M等7个结点是叶结点。

（4）父结点（Parent）：具有子树的结点是其子树的根结点的父结点。例如图4.3（a）中Ｂ是F、G的父结点。

（5）子结点（Child）：与父结点相反，对于某一个结点来讲，其子树的根结点是它的子结点。例如，图4.3（a）中F、G是B的子结点。

（6）兄弟结点（Sibling）：具有同一父结点的各结点彼此是兄弟结点。例如，图4.3（a）中B、C、D、E有共同的父结点A，它们彼此是兄弟结点。

（7）祖先结点（Ancestor）：沿树根到某一结点路径上的所有结点都是这个结点的祖先结点。例如，图4.3（a）中A、B、G是L的祖先。

（8）子孙结点（Descendant）：某一结点的子树中所有结点是这个结点的子孙。例如，图4.3（a）中F、G、L是B的子孙。

（9）结点的层次（Level）：规定根结点在1层，其他任一结点的层数是其父结点的层数+ 1，例如，图4.3（a）中结点G在第3层。

（10）树的深度（Depth）：树中所有结点中的最大层次就是这棵树的深度。例如图4.3（a）中树T的深度为4。树的高度（Height）跟深度是一样的，只不过是自底向上计数。叶结点的高度规定为1，其他任一结点的高度层数是其所有子结点的最大高度层数+ 1。树的高度就是其根节点的高度。

（11）分支：树中两个相邻结点的连边称为一个分支。

（12）路径和路径长度：从结点n1到nk的路径被定义为一个结点序列n1，n2，...，nk。例如，图4.3（a）中结点序列（A，D，I，M）是结点A到结点M的路径，其长度为3。

四、二叉树

1、二叉树的定义及其逻辑表示

一个二叉树是一个有穷的结点集合。这个集合可以为空，若不为空，则它是由根节点和称为其左子树和右子树的两个不相交的二叉树组成。

根据二叉树的定义，一般来说，一颗二叉树可以看作为由一个根结点Root和其左右两颗子树TL和TR组成。具体可有5种基本形态，分别是：（1）空二叉树；（2）只有根结点的二叉树；（3）只有根节点和左子树TL的二叉树；（4）只有根结点和右子树TR的二叉树；（5）具有根节点、左子树TL和右子树TR的二叉树。图4.5即五种二叉树形态。

上述二叉树的定义采用了递归定义法。与树的一般定义不同，除了每个结点至多有两颗子树之外，子结点是有左右顺序之分的。例如，图4.6中的两个树按一般树的定义它们是同一棵树，而对于二叉树来讲，它们是不同的两个数，因为第一个二叉树的右子树为空，而第二个二叉树的左子树为空。

2、二叉树的性质

二叉树的深度小于结点数，可以证明平均深度是O（根号N）。图4.7所示为两个二叉树的特例，图4.7（a）是斜二叉树（Skewed Binary Tree）（也称退化二叉树），图4.7（b）是完美二叉树（Perfect Binary Tree）。斜二叉树结构最差，深度达到最大N，它已退化为线性表。在一颗二叉树中，如果所有分支结点都存在左子树和右子树，并且所有叶结点都在同一层上，这样的一颗二叉树称作完美二叉树（也称满二叉树）。

一个深度为k的有n个结点的二叉树，对树中的结点按从上到下、从左到右的顺序进行编号，如果编号为i（1 <= i <= n）的结点与满二叉树编号为 i 的结点在二叉树中的位置相同，则这颗二叉树称为完全二叉树（Complete Binary Tree）。图4.8给出的是一棵完全二叉树，你可以对照图4.7（b）和图4.8看一下完美（满）二叉树和完全二叉树的对应关系和区别。完全二叉树的特点：叶结点只能出现在最下层和次下层，且最下层的叶结点集中在树的左部。显然，一颗完美二叉树必定是一颗完全二叉树，即完全二叉树是完美二叉树的子集。完全二叉树是最理想的树结构，很容易证明有N个结点的完全二叉树的深度是（logN）。

(1)性质1：在二叉树的第i层上至多有2^(i-1)个结点（i>=1）；

(2)性质2：深度为k的二叉树至多有2^k - 1个结点（k>=1)；

(3)性质3：对于任何一颗二叉树T，如果其叶结点（度为0）数为n0，度为2的结点数为n2，则n0=n2+1;

(4)性质4：具有n个节点的完全二叉树深度为log2x+1（其中x表示不大于n的最大整数）；

(5)性质5：如果对一颗有n个结点的完全二叉树（其深度为[log2n]+1）的结点按层序编号（从第一层到[log2n]+1层，每层从左到右），对任一结点i（1<=i<=n）:
如果i=1，则结点i是二叉树的根，无双亲，如果i>1,则其双亲结点是结点[i/2]
如果2i>n，则结点i无左孩子（结点i为叶子结点）否则左孩子是结点2i。
如果2i+1>n,则结点i无右孩子，否则其右孩子是结点2i+1.

3、二叉树的存储结构

在计算机内存中存储二叉树时，除了存储它的每个结点数据之外，结点之间的逻辑关系（父子关系）也要得到体现。

（1）顺序存储（用于完全二叉树的存储）

双重优点：存储空间利用率高、计算简单

将结点编号，并将编号存入数组：

由图4.9（b）可知，结点C存储单元的下标是4，将其 / 2得到它的父结点B的存储单元下标，而将其 * 2 则是它的左孩子W存储单元的下标，当然将其 * 2 + 1 则是右孩子K的存储单元下标。

概括起来，在

当[i / 2] >= 1时，[i / 2]单元是其父结点；当[i / 2] = 0时，表明该结点是树的根结点，无父结点；

当2 * i <= N时，2 * i单元是其左孩子，否则无左孩子；

当2 * i + 1 <= N ,2 * i + 1单元是其右孩子，否则无右孩子；

还要特别声明的是，这种下标的简单运算确定父子关系所用的数组起始单元下标是1，而不是0。

（2）链式存储

4、二叉树的操作

（1）创建及遍历

（书上的图）

#include<stdio.h>
#include<stdlib.h>
#define ERROR NULL 

typedef char ElementType;
typedef struct TNode *Position;
typedef Position BinTree; /* 二叉树类型 */

struct TNode
{ /* 树结点定义 */
	ElementType Data; /* 结点数据 */
	BinTree Left;     /* 指向左子树 */
	BinTree Right;    /* 指向右子树 */
};

typedef BinTree ElemType;
typedef struct QNode *PtrToQNode;
struct QNode 
{
	ElemType *Data;     /* 存储元素的数组 */
	int Front, Rear;  /* 队列的头、尾指针 */
	int MaxSize;           /* 队列最大容量 */
};
typedef PtrToQNode Queue;


// 依次输入：ABD..FE...CG.H..I..来先序创建二叉树
BinTree CreateBinTree()
{
	BinTree bt;
	char ch;
	ch = getchar();
	if(ch == '.') bt = NULL;
	else
	{
		bt = (BinTree)malloc(sizeof(struct TNode)); // 申请一个树结点的空间
		bt -> Data = ch;
		bt -> Left = CreateBinTree(); // 创建左子树
		bt -> Right = CreateBinTree(); // 创建右子树
	}
	return bt;
}

// 先序遍历
void PreorderTraversal( BinTree BT )
{
	if( BT != NULL) 
	 {
		printf("%c ", BT->Data ); // 访问根结点
		PreorderTraversal( BT->Left ); // 遍历根节点的左子树
		PreorderTraversal( BT->Right ); // 遍历根节点的右子树
	}
}

// 中序遍历
void InorderTraversal(BinTree BT)
{
	if(BT != NULL)
	{
		InorderTraversal(BT->Left); // 中序遍历左子树
		printf("%c ",BT->Data); // 访问根节点
		InorderTraversal(BT->Right); // 中序遍历右子树
	}
}

// 后序遍历
void PostorderTraversal(BinTree BT)
{
	if( BT != NULL ) 
	{
		PostorderTraversal(BT->Left); // 后序遍历左子树
		PostorderTraversal(BT->Right); // 后序遍历右子树
		printf("%c ",BT->Data); // 访问根节点
	}
}

Queue CreateQueue(int MaxSize)
{
	Queue Q = (Queue)malloc(sizeof(struct QNode));
	Q->Data = (ElemType *)malloc(MaxSize * sizeof(ElemType));
	Q->Front = Q->Rear = 0;
	Q->MaxSize = MaxSize;
	return Q;
}

bool IsFull(Queue Q)
{
	return ((Q->Rear + 1) % Q->MaxSize == Q->Front);
}

bool AddQ(Queue Q, ElemType X)
{
	if(IsFull(Q) == true) 
	{
		printf("队列满");
		return false;
	}
	else 
	{
		Q->Rear = (Q->Rear+1) % Q->MaxSize;
		Q->Data[Q->Rear] = X;
		return true;
	}
}

bool IsEmpty(Queue Q)
{
	return (Q->Front == Q->Rear);
}

ElemType DeleteQ(Queue Q)
{
	if (IsEmpty(Q) == true) 
	{ 
		printf("队列空");
		return ERROR;
	}
	else  
	{
		Q->Front = (Q->Front + 1) % Q->MaxSize;
		return  Q -> Data[Q->Front];
	}
} 

void LevelorderTraversal (BinTree BT)
{ 
	Queue Q; 
	BinTree T;
	int max;
	printf("请输入队列的最大容量：");
	scanf("%d",&max);
	if (!BT) return; // 若是空树则直接返回
	
	Q = CreateQueue(max); // 创建空队列Q
	AddQ(Q, BT);
	while (!IsEmpty(Q)) 
	{
		T = DeleteQ(Q);
		printf("%c ",T->Data); /* 访问取出队列的结点 */
		if (T->Left)   AddQ(Q, T->Left);
		if (T->Right)  AddQ(Q, T->Right);
	}
}

int main()
{
	BinTree T;
	printf("请按照先序输入节点，空节点请用‘.’代替\n");
	T = CreateBinTree();
	
	
	printf("\n按先序遍历输出：\n");
	PreorderTraversal(T);
	
	printf("\n按中序遍历输出：\n");
	InorderTraversal(T);
	
	printf("\n按后序遍历输出：\n");
	PostorderTraversal(T);
	
	printf("\n按层序遍历输出：\n");
	LevelorderTraversal(T);
	printf("\n");
	return 0;
}

（2）输出二叉树中所有叶结点

遍历中判断每个结点的左右结点有没有左右孩子，若结点既没有左孩子也没有右孩子，则此结点为叶结点，则输出，so easy，直接上代码：

#include<stdio.h>
#include<stdlib.h>
#define ERROR NULL 

typedef char ElementType;
typedef struct TNode *Position;
typedef Position BinTree; /* 二叉树类型 */

struct TNode
{ /* 树结点定义 */
	ElementType Data; /* 结点数据 */
	BinTree Left;     /* 指向左子树 */
	BinTree Right;    /* 指向右子树 */
};

typedef BinTree ElemType;

// 依次输入：ABD..FE...CG.H..I..来先序创建二叉树
BinTree CreateBinTree()
{
	BinTree bt;
	char ch;
	ch = getchar();
	if(ch == '.') bt = NULL;
	else
	{
		bt = (BinTree)malloc(sizeof(struct TNode)); // 申请一个树结点的空间
		bt -> Data = ch;
		bt -> Left = CreateBinTree(); // 创建左子树
		bt -> Right = CreateBinTree(); // 创建右子树
	}
	return bt;
}

// 先序遍历
void PreorderTraversal( BinTree BT )
{
	if( BT != NULL) 
	{
		printf("%c ", BT->Data ); // 访问根结点
		PreorderTraversal( BT->Left ); // 遍历根节点的左子树
		PreorderTraversal( BT->Right ); // 遍历根节点的右子树
	}
}

// 输出叶结点
void PreorderPrintLeaves(BinTree BT)
{
	if(BT != NULL)
	{
		if(BT->Left == NULL && BT->Right == NULL)  printf("%c ",BT->Data);
		PreorderPrintLeaves(BT->Left);
		PreorderPrintLeaves(BT->Right);
	}
}



int main()
{
	BinTree T;
	printf("请按照先序输入节点，空节点请用‘.’代替\n");
	T = CreateBinTree();
	
	printf("\n按先序遍历输出：\n");
	PreorderTraversal(T);
	
	printf("\n输出先序遍历时访问的叶结点：\n");
	PreorderPrintLeaves(T);
	printf("\n");
	
	return 0;
}

（3）求二叉树的高度

理解：

我们知道一颗二叉树的高度是其根节点的高度，而根节点的高度则是其左子树的高度和右子树的高度的高度两者中的最大值+ 1。因此可采用二叉树的遍历的原理，递归地计算出二叉树的高度。由于要获得根节点的高度，首先要获得其左右子树的高度，所以需要利用后序遍历。（注意：根据定义，叶结点高度为1，所以空树的高度为0）。

代码：

#include<stdio.h>
#include<stdlib.h>
#define ERROR NULL 

typedef char ElementType;
typedef struct TNode *Position;
typedef Position BinTree; /* 二叉树类型 */

struct TNode
{ /* 树结点定义 */
	ElementType Data; /* 结点数据 */
	BinTree Left;     /* 指向左子树 */
	BinTree Right;    /* 指向右子树 */
};

typedef BinTree ElemType;

// 依次输入：ABD..FE...CG.H..I..来先序创建二叉树
BinTree CreateBinTree()
{
	BinTree bt;
	char ch;
	ch = getchar();
	if(ch == '.') bt = NULL;
	else
	{
		bt = (BinTree)malloc(sizeof(struct TNode)); // 申请一个树结点的空间
		bt -> Data = ch;
		bt -> Left = CreateBinTree(); // 创建左子树
		bt -> Right = CreateBinTree(); // 创建右子树
	}
	return bt;
}

// 求二叉树的高度
int GetHeight(BinTree BT)
{
	int HL, HR, MaxH;
	
	if(BT != NULL)
	{
		HL = GetHeight(BT -> Left); // 求左子树的高度
		HR = GetHeight(BT -> Right); // 求右子树的高度
		MaxH = HL > HR ? HL : HR; // 取左右子树较大的高度
		return (MaxH + 1); //返回树的高度
	}
	else  return 0; // 空树高度为0
}

int main()
{
	BinTree T;
	printf("请按照先序输入节点，空节点请用‘.’代替\n");
	T = CreateBinTree();
	
    printf("\n输出二叉树的高度：\n");
    int h = GetHeight(T);
    printf("%d\n",h);
	
	return 0;
}

五、二叉搜索树

1、二叉搜索树的定义

二叉搜索树（Binary Search Tree）也叫二叉排序树或者二叉查找树，它是一种对排序和查找都很有用的特殊二叉树。在下面的介绍中，为了方便起见，规定各键值彼此不同。

一个二叉搜索树是一颗二叉树，它可以为空。如果不为空，它将满足以下性质：

（1）非空左子树的所有键值小于其根结点的键值；

（2）非空右子树的所有键值大于其根结点的键值；

（3）左、右子树都是二叉搜索树。

图4.24给出了两棵二叉树。在图4.24（a）中键值为10的结点有一个键值为5的右孩子，这不满足非空右子树键值要大于根结点的性质，因此，它不是二叉搜索树。而图4.24（b）所示的二叉树是一棵二叉搜索树。由于二叉搜索树具有的左小右大的有序特征，不难看出对它进行中序遍历，将得到一个从小到大的输出序列。

2、二叉搜索树的操作

二叉搜索树是施加了一定约束的特殊二叉树，前面介绍的二叉树的表示和操作都可以直接用于二叉搜索树，比如中序、先序和后序遍历。不同的是，二叉搜索树的查找、插入和删除操作将与其特性有关，但这些主要是算法实现的不同，和函数原型并没有什么变化。事实上，二叉搜索树结点的定义与代码4.3给出的普通二叉树完全是一样的，一般用链表存储。

（1）普通的关键字查找

它是指在二叉搜索树中查找关键字为X的结点，返回其所在结点的地址。由于二叉搜索树的特殊性质，查找可以比较方便地实现。其过程如下：

1、查找从树的根结点开始，如果树为空，返回NULL，表示未找到关键字为X的结点。

2、搜索树非空，则根结点关键字和X进行比较，依据比较结果，需要进行不同的处理：

（1）若X大于根结点，接下来的搜索只需在此根结点的右子树中进行；

（2）若X小于根结点，接下来的搜索需要在此根结点的左子树进行；

（3）若X等于根结点，搜索完成，返回指向此结点的指针。

显然，在二叉排序树上查找，若查找成功，则是从根结点出发走了一条从根到待查结点的路径；若查找不成功，则是从根结点出发走了一条从根到某一叶结点的路径。

代码1：（二叉搜索树的递归查找函数）（递归）

#include<bits/stdc++.h>

using namespace std;

typedef int ElementType;
typedef struct TNode *Position;
typedef struct TNode *BinTree; // 二叉树类型

// 树结点的定义
struct TNode
{
	ElementType Data; // 结点数据
	BinTree Left;     // 指向左子树
	BinTree Right;    // 指向右子树
};

// 创建二叉搜索树
BinTree CreateBinTree() // 输入 18 10 7 -1 -1 5 -1 -1 20 -1 22 -1 -1
{
	BinTree bt;
	int x;
	scanf("%d",&x);
	if(x == -1) bt = NULL;
	else
	{
		bt = (BinTree)malloc(sizeof(struct TNode)); // 申请一个树结点的空间
		bt -> Data = x;
		bt -> Left = CreateBinTree(); // 创建左子树
		bt -> Right = CreateBinTree(); // 创建右子树
	}
	return bt;
}

// 二叉树先序遍历
void PreorderTraversal( BinTree BT )
{
	if( BT != NULL) 
	{
		printf("%d ", BT->Data ); // 访问根结点
		PreorderTraversal( BT->Left ); // 遍历根节点的左子树
		PreorderTraversal( BT->Right ); // 遍历根节点的右子树
	}
}

// 二叉搜索树的查找
Position Find(BinTree BST, ElementType X)
{
	if(!BST)  return NULL; // 查找失败
	
	if(X > BST->Data)  return Find(BST->Right, X); // 在右子树中递归查找
	else if(X < BST->Data) return Find(BST->Left, X); // 在左子树中递归查找
	else return BST;
}

int main()
{
	BinTree T;
	printf("请按照先序输入节点，空节点请用‘.’代替\n");
	T = CreateBinTree();
	
	printf("\n按先序遍历输出：\n");
	PreorderTraversal(T);
	
	printf("\n输入要查找的元素：\n");
	int x;
	scanf("%d",&x);
	Position p;
	p = Find(T,x);
	printf("%p\n",p);
    
	return 0;
}

代码2：（二叉搜索树的递归查找函数）（迭代）

由于非递归函数的执行效率高，一般采用非递归的迭代来实现查找。很容易将递归函数改为迭代函数---在上面的代码中用while循环替代Find递归调用即可。

Position Find(BinTree BST, ElementType X)
{
	while(BST != NULL)
	{
		if(X > BST->Data)  BST = BST->Right;
		else if(X < BST->Data)  BST = BST->Left;
		else  break;
	}
	return BST;
}

（2）查找最大和最小元素

根据二叉搜索树的性质，最小元素一定在树的最左分支的端结点上，最大元素一定在树的最右分支的端结点上。这使得FindMin和FindMax较Find函数更简单，只要从根结点开始，当其不为空时，沿着左分支或右分支逐个判断各结点的指针，直到遇到空指针为止。从左分支逐层推下来查找到的是最小元素；反之，从右分支找到的最大元素。

代码1：（查找最小元素）（递归）

Position FindMin(BinTree BST)
{
	// 最小元素在左端点
	if(BST == NULL)  return NULL; // 空的二叉搜索树，返回NULL
	else if(BST->Left == NULL)  return BST; // 找到左端点并返回
	else return FindMin(BST->Left); // 沿左分支递归查找
}

代码2：（查找最大元素）（非递归）

Position FindMax(BinTree BST)
{
	if(BST != NULL)
	{
		while(BST->Right != NULL)  BST = BST->Right;
	}
	return BST;
}

从上述基于二叉搜索树的动态查找我们可以看到，它实现的基本原理与基于线性表的静态二分查找很相似，都是利用有序性不断地缩小查找空间。而之所以有静态和动态之分主要是为了适应于不同的应用需求，前者适用于数据一旦建立好，一般不大需要改变，也就是说不需要或者很少进行删除和插入操作；而后者适用于频繁的数据变化，插入和删除是其基本的操作。

（3）二叉搜索树的插入

基本思想：

将元素X插入二叉搜索树BST中关键是要找到元素应该插入的位置。位置的确定可以利用与查找函数Find类似的方法，如果在树BST中找到X，说明要插入的元素已存在，可放弃插入操作。如果没找到X，查找终止的位置就是X应插入的位置。

例如要在图4.26（a）中插入元素35，先做查找操作。按照上一节介绍的查找算法，查找将终止在键值为33的叶结点处，将元素35作为此终止结点的右孩子就完成了新元素的插入，图4.26（b）插入完成后的结果。

代码：

BinTree Insert(BinTree BST, ElementType X)
{
	if(!BST) // 若原树为空，生成并返回一个结点的二叉搜索树
	{
		BST = (BinTree)malloc(sizeof(struct TNode));
		BST->Data = X;
		BST->Left = BST->Right = NULL; 
	}
	else // 开始找要插入元素的位置
	{
		if(X < BST->Data)  BST->Left = Insert(BST->Left, X);
		else if(X > BST->Data)  BST->Right = Insert(BST->Right, X);
		// else // X已存在，什么都不做
	}
	return BST;
}