数据结构-树

uuuri

于 2023-03-10 14:19:21 发布

阅读量221

点赞数

分类专栏：算法文章标签：数据结构算法

本文链接：https://blog.csdn.net/franny13/article/details/128591717

版权

算法专栏收录该内容

12 篇文章 0 订阅

订阅专栏

树

1. 树的基本概念

树: n（n>=0）个结点的有限集。当n = 0时，称为空树。在任意一棵非空树中应满足：

有且仅有一个特定的称为根的结点。
当 $n > 1$ 时，其余节点可分为 $m （ m > 0 ）$ 个互不相交的有限集 $T_1,T_2,…,T_m$ ，其中每个集合本身又是一棵树，并且称为根的子树

显然，树的定义是递归的，即在树的定义中又用到了自身，树是一种递归的数据结构。
树作为一种逻辑结构，同时也是一种分层结构，具有以下两个特点：

树的根结点没有前驱，除根结点外的所有结点有且只有一个前驱。
树中所有结点可以有零个或多个后继

因此 $n$ 个结点的树中有 $n - 1$ 条边。

1.1 基本术语

在这里插入图片描述

考虑结点 K。根 A 到结点 K 的唯一路径上的任意结点,称为结点 K 的祖先。如结点 B 是结点 K 的祖先,而结点 K 是结点 B 的子孙。路径上最接近结点 K 的结点 E 称为 K 的双亲,而 K 为结点 E 的孩子。根 A 是树中唯一没有双亲的结点。有相同双亲的结点称为兄弟,如结点 K 和结点 L 有相同的双亲 E,即 K 和 L为兄弟。
树中一个结点的孩子个数称为该结点的度,树中结点的最大度数称为树的度。如结点 B 的度为 2,结点 D 的度为 3,树的度为 3。
度大于 0 的结点称为分支结点(又称非终端结点);度为 0(没有子女结点)的结点称为叶子结点(又称终端结点)。在分支结点中,每个结点的分支数就是该结点的度。
结点的深度、高度和层次。
- 结点的层次从树根开始定义,根结点为第 1 层,它的子结点为第 2 层,以此类推。双亲在同一层的结点互为堂兄弟,图中结点 G 与 E,F,H,I,J 互为堂兄弟。
- 结点的深度是从根结点开始自顶向下逐层累加的。
- 结点的高度是从叶结点开始自底向上逐层累加的。
- 树的高度(或深度) 是树中结点的最大层数。图中树的高度为4。
**有序树和无序树。**树中结点的各子树从左到右是有次序的,不能互换,称该树为有序树,否则称为无序树。假设图为有序树,若将子结点位置互换,则变成一棵不同的树。
路径和路径长度。树中两个结点之间的路径是由这两个结点之间所经过的结点序列构成的,而路径长度是路径上所经过的边的个数。
注意:由于树中的分支是有向的,即从双亲指向孩子,所以树中的路径是从上向下的,同一双亲的两个孩子之间不存在路径。
森林。 森林是 $m (m \geq 0)$ 棵互不相交的树的集合。森林的概念与树的概念十分相近，因为只要把树的根结点删去就成了森林。反之，只要给 $m$ 棵独立的树加上一个结点，并把这 $m$ 棵树作为该结点的子树，则森林就变成了树。

1.3 树的性质

树具有如下最基本的性质：

树中的结点数等于所有结点的度数加 1.
度为 $m$ 的树中第 $i$ 层上至多有 $m^{i-1}$ 个结点（ $i >= 1$ ）
高度为 $h$ 的 $m$ 叉树至多有 $m^h-1)/(m-1)$ 个结点。
具有 $n$ 个结点的 $m$ 叉树的最小高度为 $log_m(n(m-1)+1)]$ 。

2. 树的储存结构

在介绍以下三种存储结构的过程中，我们都以下面这个树为例子。
在这里插入图片描述

2.1 双亲表示法

我们假设以一组连续空间存储树的结点，同时在每个结点中，附设一个指示器指示其双亲结点到链表中的位置。也就是说，每个结点除了知道自已是谁以外，还知道它的双亲在哪里。
在这里插入图片描述其中data是数据域，存储结点的数据信息。而parent是指针域，存储该结点的双亲在数组中的下标。
以下是我们的双亲表示法的结点结构定义代码。

class TreeNode:
    def __init__(self,x,parent=None):
       self.val=x
       self.parent=parent

这样的存储结构，我们可以根据结点的 parent 指针很容易找到它的双亲结点，所用的时间复杂度为 $O (1)$ ，直到 parent 为 -1 时，表示找到了树结点的根。可如果我们要知道结点的孩子是什么，要遍历整个结构才行。

2.2 孩子表示法

具体办法是，把每个结点的孩子结点排列起来，以单链表作存储结构，则 n 个结点有 n 个孩子链表，如果是叶子结点则此单链表为空。然后 n 个头指针又组成一个线性表，采用顺序存储结构，存放进一个一维数组中，如图所示。
在这里插入图片描述
为此，设计两种结点结构，一个是孩子链表的孩子结点。

其中child是数据域，用来存储某个结点在表头数组中的下标。next 是指针域，用来存储指向某结点的下一个孩子结点的指针。

另一个是表头数组的表头结点。
在这里插入图片描述
其中data是数据域，存储某结点的数据信息。firstchild 是头指针域，存储该结点的孩子链表的头指针。

以下是我们的孩子表示法的结构定义代码。

这样的结构对于我们要查找某个结点的某个孩子，或者找某个结点的兄弟，只需要查找这个结点的孩子单链表即可。对于遍历整棵树也是很方便的，对头结点的数组循环即可。
但是，这也存在着问题，我如何知道某个结点的双亲是谁呢?比较麻烦，需要整棵树遍历才行

2.3 孩子兄弟表示法

刚才我们分别从双亲的角度和从孩子的角度研究树的存储结构，如果我们从树结点的兄弟的角度又会如何呢?当然，对于树这样的层级结构来说，只研究结点的兄弟是不行的，我们观察后发现，任意一棵树，它的结点的第一个孩子如果存在就是唯一的，它的右兄弟如果存在也是唯一的。因此，我们设置两个指针，分别指向该结点的第一个孩子和此结点的右兄弟。
结点的结构如下：
在这里插入图片描述
这种表示法，给查找某个结点的某个孩子带来了方便。
结构定义代码如下。

class TreeNode:
    def __init__(self,x,left=None,right=None):
        self.val=x
        self.left=left
        self.right=right

于是通过这种结构，我们就把原来的树变成了这个样子：
在这里插入图片描述

3. 二叉树

3.1 二叉树的定义

二叉树是另一种树形结构，其特点是每个结点至多只有两棵子树( 即二叉树中不存在度大于2的结点)，并且二叉树的子树有左右之分，其次序不能任意颠倒。
与树相似，二叉树也以递归的形式定义。二叉树是 $n (n \geq 0)$ 个结点的有限集合:

或者为空二叉树，即 $n = 0$ 。
或者由一个根结点和两个互不相交的被称为根的左子树和右子树组成。左子树和右子树又分别是一棵二叉树。

二叉树是有序树，若将其左、右子树颠倒，则成为另一棵不同的二叉树。即使树中结点只有一棵子树，也要区分它是左子树还是右子树。二叉树的5种基本形态如图所示。
在这里插入图片描述

3.2 几个特殊的二叉树

3.2.1. 斜树

所有的结点都只有左子树的二叉树叫左斜树。所有结点都是只有右子树的二叉树叫右斜树。这两者统称为斜树。

3.2.2. 满二叉树

一棵高度为 $h$ ，且含有 $2^h-1$ 个结点的二叉树称为满二叉树，即树中的每层都含有最多的结点。满二叉树的叶子结点都集中在二叉树的最下一层，并且除叶子结点之外的每个结点度数均为 2。
可以对满二叉树按层序编号:约定编号从根结点(根结点编号为 1 )起，自上而下，自左向右。这样，每个结点对应一个编号,对于编号为 $i$ 的结点，若有双亲，则其双亲为 $i /2$ ,若有左孩子，则左孩子为 $2 i$ ;若有右孩子，则右孩子为 $2 i + 1$
在这里插入图片描述

3.2.3. 完全二叉树

高度为 $h$ 、有 $n$ 个结点的二叉树，当且仅当其每个结点都与高度为 $h$ 的满二叉树中编号为 $1 n$ 的结点一一对应时，称为完全二叉树，如图所示。其特点如下:
在这里插入图片描述

若 $i \leq n /2$ , 则结点 $i$ 为分支结点，否则为叶子结点。
叶子结点只可能在层次最大的两层上出现。对于最大层次中的叶子结点，都依次排列在该层最左边的位置上。
若有度为 1 的结点，则只可能有一个，且该结点只有左孩子而无右孩子(重要特征)。
按层序编号后，一旦出现某结点(编号为 $i$ )为叶子结点或只有左孩子，则编号大于 $i$ 的结点均为叶子结点。
若 $n$ 为奇数，则每个分支结点都有左孩子和右孩子;若 $n$ 为偶数，则编号最大的分支结点(编号为 $n /2$ )只有左孩子，没有右孩子，其余分支结点左、右孩子都有。

3.2.4. 二叉排序树

左子树上所有结点的关键字均小于根结点的关键字;
右子树上的所有结点的关键字均大于根结点的关键字;
左子树和右子树又各是一棵二叉排序树。

3.2.5. 平衡二叉树

树上任一结点的左子树和右子树的深度之差不超过1。

3.3 二叉树的性质

任意一棵树，若结点数量为 $n$ ,则边的数量为 $n - 1$ 。
非空二叉树上的叶子结点数等于度为 2 的结点数加 1，即 $n_o=n_2+ 1$ 。
非空二叉树上第 $k$ 层上至多有 $2^{k-1}$ 个结点 $(k \geq 1)$ 。
高度为 $h$ 的二叉树至多有 $2^h-1$ 个结点 $(h \geq 1)$ 。
对完全二叉树按从上到下、从左到右的顺序依次编号 $1, 2.. *, n$ 则有以下关系:
- $i > 1$ 时，结点 $i$ 的双亲的编号为 $i /2$ ,即当 $i$ 为偶数时，它是双亲的左孩子;当 $i$ 为奇数时，它是双亲的右孩子。
- 当 $2 i \leq n$ 时，结点 $i$ 的左孩子编号为 $2 i$ , 否则无左孩子。
- 当 $2 i + 1 \leq n$ 时，结点 $i$ 的右孩子编号为 $2 i + 1$ ，否则无右孩子。
- 结点 $i$ 所在层次(深度)为 $1 \{log_2i\}+ 1$ 。
具有 $n$ 个 $(n > 0)$ 结点的完全二叉树的高度为 ${log_2n\}+1$

3.4 二叉树的存储结构

3.4.1 顺序存储结构

二叉树的顺序存储是指用一组地址连续的存储单元依次自上而下、自左至右存储完全二叉树上的结点元素，即将完全二叉树上编号为 $i$ 的结点元素存储在一维数组下标为 $i - 1$ 的分量中。

依据二叉树的性质，完全二叉树和满二叉树采用顺序存储比较合适，树中结点的序号可以唯一地反映结点之间的逻辑关系，这样既能最大可能地节省存储空间，又能利用数组元素的下标值确定结点在二叉树中的位置，以及结点之间的关系。
但对于一般的二叉树，为了让数组下标能反映二叉树中结点之间的逻辑关系，**只能添加一些并不存在的空结点，**让其每个结点与完全二叉树上的结点相对照，再存储到一维数组的相应分量中。然而，在最坏情况下，一个高度为 $h$ 且只有 $h$ 个结点的单支树却需要占据近 $2 h - 1$ 个存储单元。二叉树的顺序存储结构如图所示，其中 0 表示并不存在的空结点。

在这里插入图片描述

3.4.1 链式存储结构

既然顺序存储适用性不强，我们就要考虑链式存储结构。二叉树每个结点最多有两个孩子，所以为它设计一个数据域和两个指针域是比较自然的想法，我们称这样的链表叫做二叉链表。
在这里插入图片描述
其中data是数据域，lchild 和rchild都是指针域，分别存放指向左孩子和右孩子的指针。
以下是我们的二叉链表的结点结构定义代码。

容易验证，在含有 $n$ 个结点的二叉链表中，含有 $n + 1$ 个空链域

class TreeNode:
    def __init__(self,x,left=None,right=None):
        self.val=x
        self.left=left
        self.right=right

4. 遍历二叉树

二叉树的遍历( traversing binary tree )是指从根结点出发，按照某种次序依次访问二叉树中所有结点，使得每个结点被访问一次且仅被访问一次。

4.1 先序遍历

先序遍历(PreOrder) 的操作过程如下：

- 若二叉树为空：
	则什么也不做；
- 否则：
		1. 访问根结点;
		2. 先序遍历左子树;
		3. 先序遍历右子树。

递归实现：

class TreeNode:
    def __init__(self,x,left=None,right=None):
        self.val=x
        self.left=left
        self.right=right
def preorder(root):
    if not root:
        #可根据条件返回不同的值
        return 
    print(root.val,end='')
    preorder(root.left)
    preorder(root.right)
root=TreeNode(1,TreeNode(2,TreeNode(4,TreeNode(5),TreeNode(6))),TreeNode(3))
print("前序遍历",end=':')
preorder(root)

回溯实现：

def traverse(root):
	st = [(root,0)]  #0为遍历，1为输出
	while st:
		node,task = st.pop()
		if task: 
			print(node.val)
		else:  #调换位置即可实现前序、中序、后序遍历
			if node.right:
				st.append((node.right,0))
			if node.left:
				st.append((node.left,0))
			st.append((node,1))
print("前序遍历",end=':')
traverse(root)

4.2 中序遍历

中序遍历( InOrder)的操作过程如下：

- 若二叉树为空：
	则什么也不做；
- 否则：
		1. 中序遍历左子树;
		2. 访问根结点;
		3. 中序遍历右子树。

递归实现：

class TreeNode:
    def __init__(self,x,left=None,right=None):
        self.val=x
        self.left=left
        self.right=right
def inorder(root):
    if not root:
        #可根据条件返回不同的值
        return
    inorder(root.left)
    print(root.val,end='')
    inorder(root.right)
root=TreeNode(1,TreeNode(2,TreeNode(4,TreeNode(5),TreeNode(6))),TreeNode(3))

print("中序遍历",end=':')
inorder(root)

回溯实现：

def traverse(root):
	st = [(root,0)]
	while st:
		node,task = st.pop()
		if task:
			print(node.val)
		else:
			if node.right:
				st.append((node.right,0))
			st.append((node,1))
			if node.left:
				st.append((node.left,0))
print("中序遍历",end=':')
traverse(root)

4.3 后序遍历

后序遍历(PostOrder) 的操作过程如下：

- 若二叉树为空：
	则什么也不做；
- 否则：
		1. 后序遍历左子树;
		2. 后序遍历右子树。
		3. 访问根结点;

递归实现：

class TreeNode:
    def __init__(self,x,left=None,right=None):
        self.val=x
        self.left=left
        self.right=right
def postorder(root):
    if not root:
        #可根据条件返回不同的值
        return 
    postorder(root.left)
    postorder(root.right)
    print(root.val,end='')
root=TreeNode(1,TreeNode(2,TreeNode(4,TreeNode(5),TreeNode(6))),TreeNode(3))

print("后序遍历",end=':')
postorder(root)

回溯实现：

def traverse(root):
	st = [(root,0)]
	while st:
		node,task = st.pop()
		if task:
			print(node.val)
		else:
			st.append((node,1))
			if node.right:
				st.append((node.right,0))
			if node.left:
				st.append((node.left,0))

4.4 层次遍历

下图为二叉树的层次遍历，即按照箭头所指方向，按照1,2,3, 4的层次顺序，对二叉树中的各个结点进行访问。
在这里插入图片描述
要进行层次遍历，需要借助一个队列。
先将二叉树根结点入队，然后出队，访问出队结点，若它有左子树，则将左子树根结点入队;
若它有右子树，则将右子树根结点入队。
然后出队，访问出队结点…如此反复，直至队列为空。

class TreeNode:
    def __init__(self,x,left=None,right=None):
        self.val=x
        self.left=left
        self.right=right
def traverse(root):
    sq=deque()
    sq.append(root)
    while len(sq)!=0:
        root=sq.popleft()
        print(root.val,end='')
        if root.left:
            sq.append(root.left)
        if root.right:
            sq.append(root.right)
from collections import deque
root=TreeNode(1,TreeNode(2,TreeNode(4,TreeNode(5),TreeNode(6))),TreeNode(3))
traverse(root)

4.5 由遍历序列构造二叉树

4.5.1由二叉树的先序序列和中序序列可以唯一地确定一棵二叉树。

在先序遍历序列中,第一个结点一定是二叉树的根结点;
而在中序遍历中,根结点必然将中序序列分割成两个子序列,前一个子序列是根结点的左子树的中序序列,后一个子序列是根结点的右子树的中序序列。
根据这两个子序列,在先序序列中找到对应的左子序列和右子序列。在先序序列中,左子序列的第一个结点是左子树的根结点,右子序列的第一个结点是右子树的根结点。
如此递归地进行下去,便能唯一地确定这棵二叉树