python数据结构与算法-14_树与二叉树

树和二叉树

前面我们讲了两种使用分治和递归解决排序问题的归并排序和快速排序，堆排序先就此打住，因为涉及到树的概念，所以我们先来讲讲树。
讲完了树之后后面我们开始介绍一种有用的数据结构堆(heap)， 以及借助堆来实现的堆排序，相比前两种排序算法要稍难理解和实现一些。

树

这里先简单讲讲树的概念。树结构是一种包括节点(nodes)和边(edges)的拥有层级关系的一种结构， 它的形式和家谱树非常类似:

在这里插入图片描述

如果你了解 linux 文件结构（tree 命令），它的结构也是一棵树。我们快速看下树涉及到的一些概念：
在这里插入图片描述

  • 根节点(root): 树的最上层的节点，任何非空的树都有一个节点
  • 路径(path): 从起始节点到终止节点经历过的边
  • 父亲(parent)：除了根节点，每个节点的上一层边连接的节点就是它的父亲(节点)
  • 孩子(children): 每个节点由边指向的下一层节点
  • 兄弟(siblings): 同一个父亲并且处在同一层的节点
  • 子树(subtree): 每个节点包含它所有的后代组成的子树
  • 叶子节点(leaf node): 没有孩子的节点成为叶子节点

二叉树

了解完树的结构以后，我们来看树结构里一种简单但是却比较常用的树-二叉树。
二叉树是一种简单的树，它的每个节点最多只能包含两个孩子，以下都是一些合法的二叉树:

在这里插入图片描述
在这里插入图片描述

通过上边这幅图再来看几个二叉树相关的概念:

  • 节点深度(depth): 节点对应的 level 数字
  • 树的高度(height): 二叉树的高度就是 level 数 + 1，因为 level 从 0开始计算的
  • 树的宽度(width): 二叉树的宽度指的是包含最多节点的层级的节点数
  • 树的 size：二叉树的节点总个数。

一棵 size 为 n 的二叉树高度最多可以是 n，最小的高度是 $ \lfloor lgn \rfloor + 1 $，这里 log 以 2 为底简写为
lgn，和算法导论保持一致。这个结果你只需要用高中的累加公式就可以得到。

一些特殊的二叉树

在了解了二叉树的术语和概念之后，我们来看看一些特殊的二叉树，后续章节我们会用到：

满二叉树(full binary tree)

如果每个内部节点（非叶节点）都包含两个孩子，就成为满二叉树。下边是一些例子，它可以有多种形状：

在这里插入图片描述

完美二叉树(perfect binary tree)

当所有的叶子节点都在同一层就是完美二叉树，毫无间隙填充了 h 层。

在这里插入图片描述

完全二叉树(complete binary tree)

当一个高度为 h 的完美二叉树减少到 h-1，并且最底层的槽被毫无间隙地从左到右填充，我们就叫它完全二叉树。
下图就是完全二叉树的例子：

在这里插入图片描述

二叉树的表示

说了那么多，那么怎么表示一棵二叉树呢？其实你发现会和链表有一些相似之处，一个节点，然后节点需要保存孩子的指针，我以构造下边这个二叉树为例子：
我们先定义一个类表示节点：

在这里插入图片描述

class BinTreeNode(object):def __init__(self, data, left=None, right=None):self.data, self.left, self.right = data, left, right

当然和链表类似，root 节点是我们的入口，于是乎定义一个 二叉树：

class BinTree(object):def __init__(self, root=None):self.root = root

怎么构造上图中的二叉树呢，似乎其他课本没找到啥例子(有些例子是写了一堆嵌套节点来定义，很难搞清楚层次关系)，我自己定义了一种方法，首先我们输入节点信息，仔细看下边代码，叶子节点的 left 和 right 都是 None，并且只有一个根节点 A:

node_list = [{'data': 'A', 'left': 'B', 'right': 'C', 'is_root': True},{'data': 'B', 'left': 'D', 'right': 'E', 'is_root': False},{'data': 'D', 'left': None, 'right': None, 'is_root': False},{'data': 'E', 'left': 'H', 'right': None, 'is_root': False},{'data': 'H', 'left': None, 'right': None, 'is_root': False},{'data': 'C', 'left': 'F', 'right': 'G', 'is_root': False},{'data': 'F', 'left': None, 'right': None, 'is_root': False},{'data': 'G', 'left': 'I', 'right': 'J', 'is_root': False},{'data': 'I', 'left': None, 'right': None, 'is_root': False},{'data': 'J', 'left': None, 'right': None, 'is_root': False},
]

然后我们给 BinTreeNode 定义一个 build_from 方法，当然你也可以定义一种自己的构造方法：

class BinTree(object):def __init__(self, root=None):self.root = root@classmethoddef build_from(cls, node_list):"""通过节点信息构造二叉树第一次遍历我们构造 node 节点第二次遍历我们给 root 和 孩子赋值最后我们用 root 初始化这个类并返回一个对象:param node_list: {'data': 'A', 'left': None, 'right': None, 'is_root': False}"""node_dict = {}for node_data in node_list:data = node_data['data']node_dict[data] = BinTreeNode(data)for node_data in node_list:data = node_data['data']node = node_dict[data]if node_data['is_root']:root = nodenode.left = node_dict.get(node_data['left'])node.right = node_dict.get(node_data['right'])return cls(root)
btree = BinTree.build_from(node_list)

大功告成，这样我们就构造了一棵二叉树对象。下边我们看看它的一些常用操作。

二叉树的遍历

不知道你有没有发现，二叉树其实是一种递归结构，因为单独拿出来一个 subtree 子树出来，其实它还是一棵树。那遍历它就很方便啦，我们可以直接用递归的方式来遍历它。但是当处理顺序不同的时候，树又分为三种遍历方式:

  • 先(根)序遍历: 先处理根，之后是左子树，然后是右子树
  • 中(根)序遍历: 先处理左子树，之后是根，最后是右子树
  • 后(根)序遍历: 先处理左子树，之后是右子树，最后是根

我们来看下实现，其实算是比较直白的递归函数:

class BinTreeNode(object):def __init__(self, data, left=None, right=None):self.data, self.left, self.right = data, left, rightclass BinTree(object):def __init__(self, root=None):self.root = root@classmethoddef build_from(cls, node_list):"""通过节点信息构造二叉树第一次遍历我们构造 node 节点第二次遍历我们给 root 和 孩子赋值:param node_list: {'data': 'A', 'left': None, 'right': None, 'is_root': False}"""node_dict = {}for node_data in node_list:data = node_data['data']node_dict[data] = BinTreeNode(data)for node_data in node_list:data = node_data['data']node = node_dict[data]if node_data['is_root']:root = nodenode.left = node_dict.get(node_data['left'])node.right = node_dict.get(node_data['right'])return cls(root)def preorder_trav(self, subtree):""" 先(根)序遍历:param subtree:"""if subtree is not None:print(subtree.data)    # 递归函数里先处理根self.preorder_trav(subtree.left)   # 递归处理左子树self.preorder_trav(subtree.right)    # 递归处理右子树node_list = [{'data': 'A', 'left': 'B', 'right': 'C', 'is_root': True},{'data': 'B', 'left': 'D', 'right': 'E', 'is_root': False},{'data': 'D', 'left': None, 'right': None, 'is_root': False},{'data': 'E', 'left': 'H', 'right': None, 'is_root': False},{'data': 'H', 'left': None, 'right': None, 'is_root': False},{'data': 'C', 'left': 'F', 'right': 'G', 'is_root': False},{'data': 'F', 'left': None, 'right': None, 'is_root': False},{'data': 'G', 'left': 'I', 'right': 'J', 'is_root': False},{'data': 'I', 'left': None, 'right': None, 'is_root': False},{'data': 'J', 'left': None, 'right': None, 'is_root': False},
]
btree = BinTree.build_from(node_list)
btree.preorder_trav(btree.root)    # 输出 A, B, D, E, H, C, F, G, I, J

怎么样是不是挺简单的，比较直白的递归函数。如果你不明白，视频里我们会画个图来说明。

二叉树层序遍历

除了递归的方式遍历之外，我们还可以使用层序遍历的方式。层序遍历比较直白，就是从根节点开始按照一层一层的方式遍历节点。
我们可以从根节点开始，之后把所有当前层的孩子都按照从左到右的顺序放到一个列表里，下一次遍历所有这些孩子就可以了。

    def layer_trav(self, subtree):cur_nodes = [subtree]  # current layer nodesnext_nodes = []while cur_nodes or next_nodes:for node in cur_nodes:print(node.data)if node.left:next_nodes.append(node.left)if node.right:next_nodes.append(node.right)cur_nodes = next_nodes  # 继续遍历下一层next_nodes = []

还有一种方式就是使用一个队列，之前我们知道队列是一个先进先出结构，如果我们按照一层一层的顺序从左往右把节点放到一个队列里，
也可以实现层序遍历：

    def layer_trav_use_queue(self, subtree):q = Queue()q.append(subtree)while not q.empty():cur_node = q.pop()print(cur_node.data)if cur_node.left:q.append(cur_node.left)if cur_node.right:q.append(cur_node.right)from collections import deque
class Queue(object):  # 借助内置的 deque 我们可以迅速实现一个 Queuedef __init__(self):self._items = deque()def append(self, value):return self._items.append(value)def pop(self):return self._items.popleft()def empty(self):return len(self._items) == 0

反转二叉树

之所以单拎出来说这个是因为 mac 下著名的 brew 工具作者据说是因为面试 google 白板编程没写出来反转二叉树跪了。然后人家就去了苹果 😂。其实吧和遍历操作相比也没啥太大区别，递归交换就是了：

    def reverse(self, subtree):if subtree is not None:subtree.left, subtree.right = subtree.right, subtree.leftself.reverse(subtree.left)self.reverse(subtree.right)

练习题

  • 请你完成二叉树的中序遍历和后序遍历以及单元测试
  • 树的遍历我们用了 print，请你尝试换成一个 callback，这样就能自定义处理树节点的方式了。
  • 请问树的遍历操作时间复杂度是多少？假设它的 size 是 n
  • 你能用非递归的方式来实现树的遍历吗？我们知道计算机内部使用了 stack，如果我们自己模拟如何实现？请你尝试完成
  • 只根据二叉树的中序遍历和后序遍历能否确定一棵二叉树？你可以举一个反例吗？

源码

# -*- coding: utf-8 -*-from collections import dequeclass Queue(object):  # 借助内置的 deque 我们可以迅速实现一个 Queuedef __init__(self):self._items = deque()def append(self, value):return self._items.append(value)def pop(self):return self._items.popleft()def empty(self):return len(self._items) == 0class Stack(object):def __init__(self):self._items = deque()def push(self, value):return self._items.append(value)def pop(self):return self._items.pop()def empty(self):return len(self._items) == 0class BinTreeNode(object):def __init__(self, data, left=None, right=None):self.data, self.left, self.right = data, left, rightclass BinTree(object):def __init__(self, root=None):self.root = root@classmethoddef build_from(cls, node_list):"""build_from:param node_list: {'data': 'A', 'left': None, 'right': None, 'is_root': False}"""node_dict = {}for node_data in node_list:data = node_data['data']node_dict[data] = BinTreeNode(data)for node_data in node_list:data = node_data['data']node = node_dict[data]if node_data['is_root']:root = nodenode.left = node_dict.get(node_data['left'])node.right = node_dict.get(node_data['right'])return cls(root)def preorder_trav(self, subtree):if subtree is not None:print(subtree.data)self.preorder_trav(subtree.left)self.preorder_trav(subtree.right)def preorder_trav_use_stack(self, subtree):"""递归的方式其实是计算机帮我们实现了栈结构，我们可以自己显示的用栈来实现"""s = Stack()if subtree:s.push(subtree)while not s.empty():top_node = s.pop()print(top_node.data)    # 注意这里我用了 print，你可以用 yield 产出值然后在调用的地方转成 listif top_node.right:s.push(top_node.right)if top_node.left:s.push(top_node.left)def inorder_trav(self, subtree):if subtree is not None:self.inorder_trav(subtree.left)print(subtree.data)self.inorder_trav(subtree.right)def yield_inorder(self, subtree):  # for val in yield_inorder(root): print(val)if subtree:yield from self.inorder(subtree.left)yield subtree.valyield from self.inorder(subtree.right)def reverse(self, subtree):if subtree is not None:subtree.left, subtree.right = subtree.right, subtree.leftself.reverse(subtree.left)self.reverse(subtree.right)def layer_trav(self, subtree):cur_nodes = [subtree]next_nodes = []while cur_nodes or next_nodes:for node in cur_nodes:print(node.data)if node.left:next_nodes.append(node.left)if node.right:next_nodes.append(node.right)cur_nodes = next_nodes  # 继续遍历下一层next_nodes = []def layer_trav_use_queue(self, subtree):q = Queue()q.append(subtree)while not q.empty():cur_node = q.pop()print(cur_node.data)if cur_node.left:q.append(cur_node.left)if cur_node.right:q.append(cur_node.right)node_list = [{'data': 'A', 'left': 'B', 'right': 'C', 'is_root': True},{'data': 'B', 'left': 'D', 'right': 'E', 'is_root': False},{'data': 'D', 'left': None, 'right': None, 'is_root': False},{'data': 'E', 'left': 'H', 'right': None, 'is_root': False},{'data': 'H', 'left': None, 'right': None, 'is_root': False},{'data': 'C', 'left': 'F', 'right': 'G', 'is_root': False},{'data': 'F', 'left': None, 'right': None, 'is_root': False},{'data': 'G', 'left': 'I', 'right': 'J', 'is_root': False},{'data': 'I', 'left': None, 'right': None, 'is_root': False},{'data': 'J', 'left': None, 'right': None, 'is_root': False},
]btree = BinTree.build_from(node_list)
print('====先序遍历=====')
btree.preorder_trav(btree.root)print('====使用 stack 实现先序遍历=====')
btree.preorder_trav_use_stack(btree.root)print('====层序遍历=====')
btree.layer_trav(btree.root)
print('====用队列层序遍历=====')
btree.layer_trav_use_queue(btree.root)btree.reverse(btree.root)
print('====反转之后的结果=====')
btree.preorder_trav(btree.root)

延伸阅读

  • 《Data Structures and Algorithms in Python》 13 章 Binary Trees
  • https://www.geeksforgeeks.org/iterative-preorder-traversal/

Leetcode 练习

  • leetcode binary-tree-preorder-traversal
    二叉树的先序遍历

  • leetcode binary-tree-inorder-traversal/
    二叉树的中序遍历

  • leetcode binary-tree-postorder-traversal
    二叉树的后序遍历

  • leetcode binary-tree-right-side-view
    使用树的层序遍历我们能实现一个树的左右视图，比如从一个二叉树的左边能看到哪些节点。 请你尝试做这个练习题

  • leetcode construct-binary-tree-from-preorder-and-postorder-traversal
    根据二叉树的 前序和后序遍历，返回一颗完整的二叉树。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/209859.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Leetcode1410. HTML 实体解析器

Leetcode1410. HTML 实体解析器

Every day a Leetcode 题目来源：1410. HTML 实体解析器 解法1：模拟 遍历字符串 text，每次遇到 ’&‘，就判断以下情况： 双引号：字符实体为 " ，对应的字符是 " 。单引号&a…
阅读更多...
CentOS 7 使用cJSON 库

CentOS 7 使用cJSON 库

什么是JSON JSON是一种轻量级的数据交换格式，可读性强、编写简单。键值对组合编写规则，键名使用双引号包裹，冒号：分隔符后面紧跟着数值，有两种常用的数据类型是对象和数组。 对象：使用花括号{}包裹起来的…
阅读更多...
Java之API(上)

Java之API(上)

前言： 这一次内容主要是围绕Java开发中的一些常用类，然后主要是去学习这些类里面的方法。 一、高级API： (1)介绍：API指的是应用程序编程接口，API可以让编程变得更加方便简单。Java也提供了大量API供程序开发者使用&…
阅读更多...
Navicat 技术指引 | 适用于 GaussDB 的备份与还原功能

Navicat 技术指引 | 适用于 GaussDB 的备份与还原功能

Navicat Premium（16.2.8 Windows版或以上） 已支持对 GaussDB 主备版的管理和开发功能。它不仅具备轻松、便捷的可视化数据查看和编辑功能，还提供强大的高阶功能（如模型、结构同步、协同合作、数据迁移等），这…
阅读更多...
GIT,解决远程分支冲突

GIT,解决远程分支冲突

背景：当远程分支A 与maste 有冲突如何解决–此时无法在这两个版本之间merge 1、切换到master分支： git checkout master 2、更新master分支代码： git pull 3、再次切换到自己新建的分支： git checkout add_login_check_func 4、将…
阅读更多...
重生奇迹mu迹辅助什么好

重生奇迹mu迹辅助什么好

主流辅助一号选手：弓箭手 智弓作为最老、最有资历的辅助职业，一直都是各类玩家的首要选择。因为智力MM提供的辅助能力都是最基础、最有效、最直观的辅助。能够减少玩家对于装备的渴求度，直接提升人物的攻防，大大降低了玩家升级打…
阅读更多...
【giszz笔记】产品设计标准流程【合集】【1.79 万字】

【giszz笔记】产品设计标准流程【合集】【1.79 万字】

Tips：原笔记共8篇，本文是合集，字数较多，可收藏或关注。 目录 一、普通产品打造的流程 二、更标准一点的产品打造过程（十一步） （一）制定工作计划 （二）用户…
阅读更多...
【数据结构】树如何定义 | 如何存储 | 实际应用

【数据结构】树如何定义 | 如何存储 | 实际应用

前言 如上图，A中的孩子的个数是不固定的。我们无法精确的每个不同的根结点有多少个孩子。所以并不能精确知道需要定义多少个孩子节点。 struct TreeNode {int val;struct TreeNode* child1;struct TreeNode* child2;struct TreeNode* child3;//...//这样显然是不能…
阅读更多...
数字人直播系统开发要注意的陷阱

数字人直播系统开发要注意的陷阱

数字人做为元宇宙的底层基座，BAT都在跑步进场，目前具有前瞻性的公司都在布局数字人产业。数字人可以应用于很多业务场景，对今年来说，无疑数字人直播系统是最火的。像去年数字人直播SAAS系统定制开发的话没有个百把万是下不来的。但…
阅读更多...
Harmony 应用开发之size 脚本

Harmony 应用开发之size 脚本

作者：麦客奥德彪 在应用开发中，最终呈现在用户面前的UI，是用户能否继续使用应用的强力依据之一，在之前的开发中，Android 屏幕碎片化严重，所以出现了很多尺寸适配方案。 最小宽适配、百分比适配等等。 还有一…
阅读更多...
Navicat 技术指引 | 适用于 GaussDB 的数据迁移工具

Navicat 技术指引 | 适用于 GaussDB 的数据迁移工具

Navicat Premium（16.2.8 Windows版或以上） 已支持对 GaussDB 主备版的管理和开发功能。它不仅具备轻松、便捷的可视化数据查看和编辑功能，还提供强大的高阶功能（如模型、结构同步、协同合作、数据迁移等），这…
阅读更多...
局域网协议：地址解析协议（ARP，Address Resolution Protocol）

局域网协议：地址解析协议（ARP，Address Resolution Protocol）

地址解析协议（ARP，Address Resolution Protocol）是一种用于在IP网络中将IP地址映射到物理MAC地址的协议。在IP网络中，IP是用于寻址，真正将数据包从一个设备发送到另外一个设备，用于通信的是物理MAC地址。 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023