码迷,mamicode.com
首页 > 其他好文 > 详细

重学数据结构之树

时间:2020-05-17 13:16:29      阅读:51      评论:0      收藏:0      [点我收藏+]

标签:顺序   前序遍历   put   不可   print   inf   遍历二叉树   建二叉树   设置   

一、树和森林

1.基本概念

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

  树具有以下的特点:

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

2.基本术语

  子女:若节点的子树非空,则节点子树的根即为该节点的子女。

  双亲:若节点有子女,则该节点即为子女的双亲。

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

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

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

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

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

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

  森林:森林是 m(m>=0)颗树的集合。

  

二、二叉树

1.基本概念

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

  技术图片

2.基本性质

  性质1:若二叉树节点的层次从1开始,则在二叉树的第 i 层最多有 2i-1 个节点(i>=1)。

  性质2:深度为 k 的二叉树最少有 k 个节点,最多有 2k-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

 

重学数据结构之树

标签:顺序   前序遍历   put   不可   print   inf   遍历二叉树   建二叉树   设置   

原文地址:https://www.cnblogs.com/TM0831/p/12901302.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!