重学数据结构之树和二叉树

时间:2020-05-18 TM0831 人气:1

一、树和森林

1.基本概念

　　树状图（Tree）又称为树，是一种复杂的数据结构。树是由 n（n>=0）个有限节点组成一个具有层次关系的集合，把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。当 n=0 时，称之为空树，否则是非空树。

　　树具有以下的特点：

每个节点有零个或多个子节点；
没有父节点的节点称为根节点；
每一个非根节点有且只有一个父节点；
除了根节点外，每个子节点可以分为多个不相交的子树。

2.基本术语

　　子女：若节点的子树非空，则节点子树的根即为该节点的子女。

　　双亲：若节点有子女，则该节点即为子女的双亲。

　　兄弟：同一节点的子女互称为兄弟。

　　度：节点的子女个数即为该节点的度。

　　分支节点：度不为0的节点即为分支节点。

　　叶子节点：度为0的节点即为叶子节点。

　　深度：节点的深度即为该节点所在的层次。

　　高度：规定叶子节点的高度为1，其双亲节点的高度等于它的高度加1。

　　森林：森林是 m（m>=0）颗树的集合。

二、二叉树

1.基本概念

　　一颗二叉树是节点的有限集合，该集合或者为空，或者由一个根节点和两颗分别称为左子树和右子树的、互不交叉的二叉树组成（子树有左右之分，不可颠倒）。下面是二叉树的五种形态：

2.基本性质

　　性质1：若二叉树节点的层次从1开始，则在二叉树的第 i 层最多有 2^i-1个节点（i>=1）。

　　性质2：深度为 k 的二叉树最少有 k 个节点，最多有 2^k-1个节点（k>=1）。

　　性质3：对任意一颗二叉树，如果其叶子节点有 m 个，度为2的非叶子节点为 n 个，则有：m = n + 1。

　　设度为1的节点有 p 个，总节点数为 x，总边数为 e，则 x = m + n + p，e = n - 1 = 2 * n + p。因此有：

2 * n + p = m + n + p - 1

n = m - 1

m = n + 1

3.满二叉树和完全二叉树

1）满二叉树：除了最后一层无任何子节点，每一层的所有节点都有两个子节点，即除了叶子节点外的所有节点均有两个子节点，这样的二叉树就称为满二叉树。

2）完全二叉树：设一个二叉树的深度为 k，即共有 k 层。除了第 k 层外，其他各层的节点数都达到最大个数，且最后一层上只缺少右边的若干节点，这样的二叉树就称为完全二叉树。

4.Python 实现

　　下面是用 Python 实现的一个二叉树的代码，除了实现创建二叉树，还实现了四种遍历二叉树的方法，分别是：前序遍历、中序遍历、后序遍历和层次遍历。

  1 # 自定义树节点
  2 class Node:
  3     def __init__(self, value=None, left=None, right=None):
  4         self.value = value
  5         self.left = left
  6         self.right = right
  7 
  8 
  9 # 自定义二叉树
 10 class BinaryTree:
 11     def __init__(self, value=None, left=None, right=None):
 12         """
 13         根据传入的参数决定树的形态
 14         :param value: 节点值
 15         :param left: 左子树
 16         :param right: 右子树
 17         """
 18         self.root = Node(value, left, right) if value else None
 19 
 20     def is_empty(self):
 21         """
 22         判断是否为空树
 23         :return: 
 24         """
 25         return True if self.root else False
 26 
 27     def get_root(self):
 28         """
 29         获取根节点
 30         :return: 
 31         """
 32         return self.root
 33 
 34     def get_left(self):
 35         """
 36         获取左子树
 37         :return: 
 38         """
 39         return self.root.left if self.root else None
 40 
 41     def get_right(self):
 42         """
 43         获取右子树
 44         :return: 
 45         """
 46         return self.root.right if self.root else None
 47 
 48     def set_left(self, node: Node):
 49         """
 50         设置左子树
 51         :param node: 树节点
 52         :return: 
 53         """
 54         self.root.left = node
 55 
 56     def set_right(self, node: Node):
 57         """
 58         设置右子树
 59         :param node: 树节点
 60         :return: 
 61         """
 62         self.root.right = node
 63     
 64     def pre_traverse(self, node: Node):
 65         """
 66         前序遍历
 67         :param node: 根节点
 68         :return:
 69         """
 70         if not node:
 71             return
 72         print(node.value, end=" ")
 73         self.pre_traverse(node.left)
 74         self.pre_traverse(node.right)
 75 
 76     def mid_traverse(self, node: Node):
 77         """
 78         中序遍历
 79         :param node: 根节点
 80         :return:
 81         """
 82         if not node:
 83             return
 84         self.mid_traverse(node.left)
 85         print(node.value, end=" ")
 86         self.mid_traverse(node.right)
 87 
 88     def after_traverse(self, node: Node):
 89         """
 90         后序遍历
 91         :param node: 根节点
 92         :return:
 93         """
 94         if not node:
 95             return
 96         self.after_traverse(node.left)
 97         self.after_traverse(node.right)
 98         print(node.value, end=" ")
 99 
100     def level_traverse(self, nodes: list):
101         next_nodes = []
102         if nodes:
103             for node in nodes:
104                 print(node.value, end=" ")
105                 if node.left:
106                     next_nodes.append(node.left)
107                 if node.right:
108                     next_nodes.append(node.right)
109             self.level_traverse(next_nodes)

　　当然光有这些方法还是不够的，因为要一个个的创建节点还是很麻烦，我们可以将一个树节点定义成一个三元组：

（树节点的值，左子树，右子树）

　　而左子树和右子树也都可以用这种三元组来表示，例如下面是一颗二叉树的三元组表示：

(F, (C, A, (D, B, None)), (E, H, (G, M, None)))　　

　　因此还需要实现一个将这种三元组表达形式转换成二叉树的方法：

 1     def create(self, data: tuple):
 2         """
 3         创建一个二叉树
 4         :param data: 例如(1,(2,4,5),(3,6,7))
 5         """
 6         self.root = self.parse(data)
 7 
 8     def parse(self, data: tuple):
 9         """
10         解析传入的三元组，创建二叉树
11         :param data: 三元组
12         :return:
13         """
14         if data:
15             node = Node(data[0])
16             node.left = self.parse(data[1]) if type(data[1]) == tuple else Node(data[1])
17             node.right = self.parse(data[2]) if type(data[2]) == tuple else Node(data[2])
18             return node

三、树的应用

1.表达式计算问题

1）问题描述

　　一个结构正确的二元表达式对应于一个满二叉树，例如下面这样一颗二叉树：

　　这样一颗二叉树前序遍历得到“-+1*23/45”，后序遍历得到“123*+45/-”，正是波兰表达式的形式，而其中序遍历结果就是“1+2*3-4/5”，基本就是相应数学表达式的正确形式，只是缺少了表达计算顺序的括号。输入一个简单的只包含四则运算的数学计算表达式，求出其计算后的结果。

2）问题分析

　　对于任意一个二元表达式（如“a+b”）都可以用一个三元组来表示（如“('+', a, b)”），而像上面示例中的表达式，就可以用下面这种三元组表示：

("-", ("+", 1, ("*", 2, 3)), ("/", 4, 5))

　　这种三元表达式都包含一个操作符设为 op，两个操作数分别为 x 和 y，因而可以写出下面的计算方法：

1 if op == "+":
2     return x + y
3 if op == "-":
4     return x - y
5 if op == "*":
6     return x * y
7 if op == "/":
8     return x / y if y else 0

　　那么现在的问题就是如何将数学表达式转换成二叉树，再就根据二叉树得到三元组，最后就能使用上面的方法把表达式的值求出来了。因为我们都知道在没有括号的情况下，乘除的优先级是高于加减的，而利用二叉树求解表达式时会从下往上，从叶子节点往根节点进行计算，所以要把加减号放在上面，乘除号放在下面。

3）二叉树求解

　　下面是根据输入的表达式字符串建立二叉树的具体代码：

 1 def build_tree(input_string):
 2     """
 3     根据输入的表达式字符串建立二叉树
 4     :param input_string: 输入表达式
 5     :return:
 6     """
 7     if "+" in input_string or "-" in input_string:
 8         for i in range(len(input_string)):
 9             if input_string[i] in ["+", "-"] and "+" not in input_string[i + 1:] and "-" not in input_string[i + 1:]:
10                 node = Node(input_string[i], build_tree(input_string[:i]), build_tree(input_string[i + 1:]))
11                 return node
12     elif "*" in input_string or "/" in input_string:
13         for i in range(len(input_string)):
14             if input_string[i] in ["*", "/"]:
15                 node = Node(input_string[i], build_tree(input_string[:i]), build_tree(input_string[i + 1:]))
16                 return node
17     else:
18         return Node(input_string)

　　在生成二叉树之后，还要根据这个二叉树得到三元组，下面就是使用递归算法得到三元组的代码：

 1 def trans(self, node: Node, data: tuple):
 2     """
 3     将二叉树转换成三元组
 4     :param node: 节点
 5     :param data: 三元组
 6     :return:
 7     """
 8     left = self.trans(node.left, data) if node.left.left else node.left.value
 9     right = self.trans(node.right, data) if node.right.left else node.right.value
10     data = (node.value, left, right)
11     return data

　　现在已经能生成二叉树并得到表达式的三元组了，再就是求值了，下面是使用递归算法计算三元表达式的值的代码：

 1 def solution(e):
 2     """
 3     计算表达式的值
 4     :param e: 转化成三元组表达的计算表达式
 5     :return:
 6     """
 7     if type(e) == tuple:
 8         op, a, b = e[0], solution(e[1]), solution(e[2])
 9         x, y = float(a), float(b)
10         if op == "+":
11             return x + y
12         if op == "-":
13             return x - y
14         if op == "*":
15             return x * y
16         if op == "/":
17             return x / y if y else 0
18     else:
19         return e

　　求解计算表达式的代码已经完成了，下面是使用这些代码来求"1+2*3-4/5"的代码示例：

1 s = build_tree("1+2*3-4/5")
2 tree = Tree()
3 tree.root = s
4 exp = tree.trans(s, ())
5 print(solution(exp))
6 # 6.2

加载全部内容