数据结构 on Dapeng Zhang

Python 入门基础知识 - 数据结构与算法 - 排序

Mon, 28 Jul 2025 17:05:57 +0800

排序

排序相对于查找来说要复杂的多，排序的方法也较多，有冒泡排序、希尔排序、二叉树排序和快速排序等，其中二叉树排序是比较有意思的一种排序方法，而且也便于操作。二叉树排序的过程主要是二叉树的建立和遍历的过程。例如有一组数据"3,5,7,20,44,2,15,30"，则二叉树的建立过程如下

1、首先将第一个数据3放如根节点

2、将数据5与节点中的数据3比较，由于5大于3，则将5放入3的右子树中

3、将数据7与根节点中的数据3比较，由于7大于3，则将7放入3的右子树中，由于2已经有右子树5，将7与5比较，因为7大于5，则将7放入5的有子树中。

4、将数据20与根节点3进行比较，由于20大于3，则将7放入3的右子树中，重复比较，最终将20放入7的右子树中

5，将数据44与树中的节点值进行比较，最终将其放入20的右子树中

6、将数据2与根节点3比较，由于2小于3，则将2放入3的左子树中

7、同样的对数据15和30进行处理，最终形成如下图的树

当树创建好后，对树进行中序遍历后的结果就是对数据从小到大的排序。如果要从大到小进行排序，则可以先从右子树开始进行中序遍历。

实例代码演示如下，采用二叉树排序的方式对数据进行排序

# _*_ coding: utf-8 -*-
# version 2.7.13

class BTree: # 二叉树节点

 def __init__(self, value): # 初始化函数
 self.left = None # 左子树
 self.data = value # 节点值
 self.right = None # 右子树

 def insertLeft(self, value): # 向左子树插入节点
 self.left = BTree(value)
 return self.left

 def insertRight(self, value): # 向右子树插入节点
 self.right = BTree(value)
 return self.right

 def show(self): # 输出节点数据
 print(self.data)

def inorder(node):
 if node.data:
 if node.left:
 inorder(node.left)
 node.show()

 if node.right:
 inorder(node.right)

def rinorder(node):
 if node.data:
 if node.right:
 rinorder(node.right)
 node.show()

 if node.left:
 rinorder(node.left)

def insert(node, value):
 if value > node.data:
 if node.right:
 insert(node.right, value)
 else:
 node.insertRight(value)

 else:
 if node.left:
 insert(node.left, value)
 else:
 node.insertLeft(value)

if __name__ == '__main__':
 l = [3, 5, 7, 20, 44, 2, 15, 30]
 Root = BTree(l[0])
 node = Root

 for i in range(1, len(l)):
 insert(Root, l[i])

 print('********************************')
 print(' 从小到大 ')
 print('********************************')
 inorder(Root)

 print('********************************')
 print(' 从大到小 ')
 print('********************************')
 rinorder(Root)

运行结果如下

********************************
 从小到大
********************************
2
3
5
7
15
20
30
44
********************************
 从大到小
********************************
44
30
20
15
7
5
3
2

Python 入门基础知识 - 数据结构与算法 - 查找

Mon, 28 Jul 2025 17:05:52 +0800

查找与排序

查找和排序是最基本的算法。在很多脚本中都会用到查找和排序，在前边的文章中，多次使用Python的函数查找字符串中的子字符串。尽管Python提供了用户查找和排序的函数能够满足绝大多数需求，但还是有必要了解最基本的查找和排序算法。

查找

基本的查找方法有顺序查找、二分查找和分块查找。其中，顺序查找是最简单的查找方法，就是按数据排列的顺序依次查找，直到找到所查找的数据为止。二分查找是首先对要进行查找的数据进行排序，有按大小顺序排好的9个数字，如下图

如果要查找数字5，首先与中间值10进行比较，5小于10，于是对序列的前半部分1~9进行查找。此时，中间值为5，恰好为要找的数字，查找结束。

分块查找是顺序查找和二分查找之间的一种查找方法。使用分块查找时首先对查找表建立一个索引表，再进行分块查找。建立索引表时，首先对查找表进行分块，要求"分块有序"，即块内关键字不一定有序，但分块之间有大小顺序。索引表是抽取各块中的最大关键字及起始位置构成的，如下图

分块查找分两步进行，首先查找索引表，因为索引表是有序的，查找索引表时可以使用二分查找。查找完索引表以后，就确定了要查找的数据所在的分块，然后在改分块中进行顺序查找。

实例演示代码如下

# _*_ coding: utf-8 -*-
# version 2.7.13

def binary_search(l, key): # 二分查找
 low = 0
 high = len(l) - 1
 i = 0
 while (low <= high):
 i = i + 1
 mid = (high + low) / 2
 if (l[mid] < key):
 low = mid + 1
 elif (l[mid] > key):
 high = mid - 1
 else:
 print('use %d time(s)' % i)
 return mid
 return -1

if __name__ == '__main__':
 l = [1, 5, 6, 9, 10, 51, 62, 65, 70] # 构造列表
 print(binary_search(l, 5)) # 在列表中查找
 print(binary_search(l, 10))
 print(binary_search(l, 65))
 print(binary_search(l, 70))

运行结果如下

use 2 time(s)
1
use 1 time(s)
4
use 3 time(s)
7
use 4 time(s)
8

Python 入门基础知识 - 数据结构与算法 - 图

Mon, 28 Jul 2025 17:05:48 +0800

图

图也是非线性的数据结构，是由顶点和边组成的。如果图中的顶点是有序的，那么图是有方向的，称之为有向图，

否则，图是无方向的，称之为无向图。在图中，由顶点组成的序列称为路径。

图和树相比，少了树明显的层次结构。在Python中可以采用字典的方式来创建图，图中的每个元素是字典中的键，该元素所指向的图中其他元素则组成键的值。同树一样，对于图来说也可以对其进行遍历。除了遍历外，可以在图中搜索所有的从一个顶点到另一个定点的路径。图中的顶点可以看做是城市，路径可以看做是城市到城市之间的公路。因此，通过搜索所有的路径，可以找到一个顶点到另一个顶点的最短路径，即城市到城市间的最短路线。

如下代码所示，使用字典的方法构建了有向图，并搜索图中的路径。

# _*_ coding: utf-8 -*-
# version 2.7.13

def searchGraph(graph, start, end): # 搜索树
 results = [] # 路径列表
 generatePath(graph, [start], end, results) # 生成路径
 results.sort(lambda x, y: cmp(len(x), len(y))) # 按路径长短排序
 return results

def generatePath(graph, path, end, results): # 生成路径
 state = path[-1]
 if state == end:
 results.append(path)
 else:
 for arc in graph[state]:
 if arc not in path:
 generatePath(graph, path + [arc], end, results)

if __name__ == '__main__':
 Graph = {
 'A': ['B', 'C', 'D'],
 'B': ['E'],
 'C': ['D', 'F'],
 'D': ['B', 'E', 'G'],
 'E': [],
 'F': ['D', 'G'],
 'G': ['E']
 }

 r = searchGraph(Graph, 'A', 'D') # 搜索A到D的路径
 print('*******************************')
 print(' A TO D ')
 print('*******************************')

 for i in r:
 print(i)

 r = searchGraph(Graph, 'A', 'E') # 搜索A到E的路径
 print('*******************************')
 print(' A TO E ')
 print('*******************************')

 for i in r:
 print(i)

 r = searchGraph(Graph, 'C', 'E') # 搜索C到E的路径
 print('*******************************')
 print(' C TO E ')
 print('*******************************')

 for i in r:
 print(i)

运行的结果如下

*******************************
 A TO D
*******************************
['A', 'D']
['A', 'C', 'D']
['A', 'C', 'F', 'D']
*******************************
 A TO E
*******************************
['A', 'B', 'E']
['A', 'D', 'E']
['A', 'C', 'D', 'E']
['A', 'D', 'B', 'E']
['A', 'D', 'G', 'E']
['A', 'C', 'D', 'B', 'E']
['A', 'C', 'D', 'G', 'E']
['A', 'C', 'F', 'D', 'E']
['A', 'C', 'F', 'G', 'E']
['A', 'C', 'F', 'D', 'B', 'E']
['A', 'C', 'F', 'D', 'G', 'E']
*******************************
 C TO E
*******************************
['C', 'D', 'E']
['C', 'D', 'B', 'E']
['C', 'D', 'G', 'E']
['C', 'F', 'D', 'E']
['C', 'F', 'G', 'E']
['C', 'F', 'D', 'B', 'E']
['C', 'F', 'D', 'G', 'E']

Python 入门基础知识 - 数据结构与算法 - 二叉树遍历

Mon, 28 Jul 2025 17:05:42 +0800

二叉树遍历

按照先左后右，树的遍历方法有3种：

先序遍历、中序遍历、后序遍历。其中，先序遍历的次序是：如果二叉树不为空，则访问根节点，然后访问左子树，最后访问右子树；否则，程序退出。中序遍历的次序是：如果二叉树不为空，则先访问左子树，然后范文根节点，最后访问右子树；否则，程序退出。后序遍历的次序依次是：如果二叉树不为空，则先访问左子树，然后访问右子树，最后访问根节点。

代码实例演示如下

# _*_ coding: utf-8 -*-
# version 2.7.13

class BTree: # 二叉树节点

 def __init__(self, value): # 初始化函数
 self.left = None # 左儿子
 self.data = value # 节点值
 self.right = None # 右儿子

 def insertLeft(self, value): # 向左子树中插入节点
 self.left = BTree(value)
 return self.left

 def insertRight(self, value): # 向右子树中插入节点
 self.right = BTree(value)
 return self.right

 def show(self): # 输出节点数据
 print(self.data)

def preorder(node): # 先序遍历
 if node.data:
 node.show()
 if node.left:
 preorder(node.left)

 if node.right:
 preorder(node.right)

def inorder(node): # 中序遍历
 if node.data:
 if node.left:
 inorder(node.left)
 node.show()

 if node.right:
 inorder(node.right)

def postorder(node):
 if node.data:
 if node.left:
 postorder(node.left)
 if node.right:
 postorder(node.right)

 node.show()

if __name__ == "__main__":
 Root = BTree('Root')
 A = Root.insertLeft('A')
 C = A.insertLeft('C')
 D = A.insertRight('D')
 F = D.insertLeft('F')
 G = D.insertRight('G')
 B = Root.insertRight('B')
 E = B.insertRight('E')

 print('*********************************')
 print('Binary Tree Pre Order')
 print('*********************************')
 preorder(Root)

 print('*********************************')
 print('Binary Tree In Order')
 print('*********************************')
 inorder(Root)

 print('*********************************')
 print('Binary Tree Post Order')
 print('*********************************')
 postorder(Root)

运行后结果如下

*********************************
Binary Tree Pre Order
*********************************
Root
A
C
D
F
G
B
E
*********************************
Binary Tree In Order
*********************************
C
A
F
D
G
Root
B
E
*********************************
Binary Tree Post Order
*********************************
C
F
G
D
A
E
B
Root

Python 入门基础知识 - 数据结构与算法 - 二叉树

Mon, 28 Jul 2025 17:05:39 +0800

二叉树

二叉树是一类比较特殊的数，在二叉树中每个节点最多只有两个儿子，分为左和右

相对于树而言，二叉树的构建和使用都要简单的多，而且任何一棵树，都可以通过变换转换成一颗二叉树。

在Python中，二叉树的构建和树一样，可以使用列表或者类的方式。由于二叉树中的节点具有确定的儿子数，

因此，使用类的方式要更为简便。代理实例演示如下

# _*_ coding: utf-8 -*-
# version 2.7.13

class BTree: # 二叉树节点

 def __init__(self, value): # 初始化函数
 self.left = None # 左儿子
 self.data = value # 节点值
 self.right = None # 右儿子

 def insertLeft(self, value): # 向左子树中插入节点
 self.left = BTree(value)
 return self.left

 def insertRight(self, value): # 向右子树中插入节点
 self.right = BTree(value)
 return self.right

 def show(self): # 输出节点数据
 print(self.data)

if __name__ == "__main__":
 Root = BTree('Root')
 A = Root.insertLeft('A')
 C = A.insertLeft('C')
 D = A.insertRight('D')
 F = D.insertLeft('F')
 G = D.insertRight('G')
 B = Root.insertRight('B')
 E = B.insertRight('E')
 Root.show()
 Root.left.show()
 Root.right.show()
 A = Root.left
 A.left.show()
 Root.left.right.show()

运行后输出结果如下

Root
A
B
C
D

当创建好一颗二叉树后，可以按照一定的顺序对树中所有的元素进行遍历。按照先左后右，树的遍历方法有3种：

先序遍历、中序遍历、后序遍历。其中，先序遍历的次序是：如果二叉树不为空，则访问根节点，然后访问左子树，

最后访问右子树；否则，程序退出。中序遍历的次序是：如果二叉树不为空，则先访问左子树，然后范文根节点，

最后访问右子树；否则，程序退出。后序遍历的次序依次是：如果二叉树不为空，则先访问左子树，然后访问右子树，

最后访问根节点。

遍历的方式我们下篇文章继续概述。

Python 入门基础知识 - 数据结构与算法 - 树

Mon, 28 Jul 2025 17:05:36 +0800

树和图

树和前几篇文章说的数据结构不同，树不是线性的。在处理较多数据的时候，使用线性结构较慢，而使用树结构则

可以提高处理速度。不过树的构建相对于线性的表、堆栈和队列等较为复杂。

树

树是一种非线性的数据结构

之所以称为树，是因为其形状像一颗倒置的大树。每颗树都有一个跟节点，如上图所示，Root为根节点。A、B、C

为Root的儿子，Root为A、B、C的父亲，A、B、C为兄弟。同样A为D、E的父亲，D、E为A的儿子，D、E为兄弟。D、E

为Root的孙子，Root为D、E的祖父。在树中，如果一个元素没有儿子，则称为树的叶子。

在Python中树的实现可以使用列表或者类的方式实现。使用列表的方式较为简单，但树的构建较为复杂。使用类的

方式构建树时，需要首先确定树中的节点所能拥有的最大儿子树。因为每个节点所拥有的儿子树并不一定相同，因此使用

类的方法将占用更大的存储空间，如下代码实例，以列表的方式构建了上图所示的树

# _*_ coding: utf-8 -*-
# version 2.7.13

G = ['G', []] # 构造叶子G，树中每个元素都由该元素的值和该元素的儿子列表组成
H = ['H', []] # 构造叶子节点H
I = ['I', []] # 构造叶子节点I
K = ['K', []] # 构造叶子节点K
E = ['E', [G, H, I, K]] # 构造E节点
D = ['D', []] # 构造叶子节点D
F = ['F', []] # 构造叶子节点F
A = ['A', [D, E]] # 构造A节点
B = ['B', []] # 构造叶子节点D
C = ['C', [F]] # 构造C节点
Root = ['Root', [A, B, C]] # 构造树根
print(Root)

输出结果如下

['Root', [['A', [['D', []], ['E', [['G', []], ['H', []], ['I', []], ['K', []]]]]], ['B', []], ['C', [['F', []]]]]]

Python 入门基础知识 - 数据结构与算法 - 队列

Mon, 28 Jul 2025 17:05:32 +0800

队列

队列和栈类似

但不同的是，队列的出队操作是队首元素进行的删除操作，因而对于队列而言，先入队的元素将先出队。因此队

的特性可以称为先进先出（FIFO）。

和堆栈类似，在Python中同样可以使用列表来构建一个队列，并完成对队列的操作。如下实例

# _*_ coding: utf-8 -*-
# version 2.7.13
class TestQueue:

 def __init__(self, size=20): # 创建队列
 self.queue = [] # 队列
 self.size = size # 队列大小
 self.end = -1 # 队列尾

 def setSize(self, size): # 设置队列大小
 self.size = size

 def In(self, element): # 入队
 if self.end < self.size - 1:
 self.queue.append(element)
 self.end = self.end + 1
 else:
 raise 'TestQueue Full' # 如果队列满，则引发异常

 def Out(self): # 出队
 if self.end != -1:
 element = self.queue[0]
 self.queue = self.queue[1:]
 self.end = self.end - 1
 return element
 else:
 raise 'TestQueue Empty'

 def End(self):
 return self.end

 def Empty(self): # 清空队列
 self.queue = []
 self.end = -1

if __name__ == '__main__':
 queue = TestQueue()
 for i in range(10):
 queue.In(i)

 print(queue.End())

 for i in range(10):
 print(queue.Out())

 for i in range(20):
 queue.In(i)

 print(queue.Empty())

 for i in range(20):
 print(queue.Out())

运行结果如下

9
0
1
2
3
4
5
6
7
8
9
None
Traceback (most recent call last):
 File "base_phrase.py", line 64, in <module>
 print(queue.Out())
 File "base_phrase.py", line 38, in Out
 raise 'TestQueue Empty'
TypeError: exceptions must be old-style classes or derived from BaseException, not str

Python 入门基础知识 - 数据结构与算法 - 栈

Mon, 28 Jul 2025 17:05:16 +0800

栈

栈可以看做插入和删除在同一个位置上进行的表，一般是栈顶。栈的基本操作是进栈和出栈，栈可以看作是一个容器。

如下图，

先入栈的在容器底部，后入栈的在容器顶部。在出栈的时候，后入栈的先出，而先入栈的后出，因此栈有一个特性叫做

后进先出

在Python中，仍然可以使用列表来存储堆栈数据。通过创建堆栈类，来实现对堆栈进行操作的方法。如，进栈PUSH

方法、出栈POP方法，编写检查栈是都为满栈，或者是否为空栈的方法等。

如下示例代码

# _*_ coding: utf-8 -*-
# version 2.7.13
class TestStack:

 def __init__(self, size=20):
 self.stack = []
 self.size = size
 self.top = -1

 def setSize(self, size):
 self.size = size

 def push(self, element):
 if self.is_full():
 raise 'TestStack OverFlow'
 else:
 self.stack.append(element)
 self.top = self.top + 1

 def pop(self):
 if self.is_empty():
 raise 'TestStack Empty'
 else:
 element = self.stack[-1]
 self.top = self.top - 1
 del self.stack[-1]
 return element

 def Top(self):
 return self.top

 def empty(self):
 self.stack = []
 self.top = -1

 def is_empty(self):
 if self.top == -1:
 return True
 else:
 return False

 def is_full(self):
 if self.top == self.size - 1:
 return True
 else:
 return False

if __name__ == '__main__':
 stack = TestStack()
 for i in range(10):
 stack.push(i)

 print('%d' % stack.Top())

 for i in range(10):
 print(stack.pop())

 stack.empty()
 for i in range(21):
 stack.push(i)

Python 入门基础知识 - 数据结构与算法 - 表

Mon, 28 Jul 2025 17:05:13 +0800

数据结构与算法

数据结构用来描述一种或多种数据元素之间的特定关系。算法是程序设计中对数据操作的描述。数据结果和算法组成

了程序。对于简单的任务，只要使用编程语言提供的基本数据类型就足够了。而对于较复杂的任务，就需要使用基本

的数据类型构造更加复杂的数据结构。

表、栈和队列

表、栈和队列都是基本的线性数据结构。由于Python设计良好的数据结构，其列表可以当做表来使用。而且列表的

某些特性跟链表相似，在Python中表的实现非常简单。对于栈和队列，则可以自己在脚本中构建。

表

表示最基本的数据结构，在Python中可以使用列表来创建表。而在C语言中，一般使用数组来创建表。由于使用数组

创建表，对表中元素进行插入和删除操作的开销较大。当插入一个元素时，要先将该元素后的所有元素，从最后一个

元素开始，依次向后移动一个位置。完成元素移动后，再将元素插入数组中。同样，要删除表中的元素时，首先删除

元素，然后将位于该元素之后的元素从前向后，依次向前移动一个位置。

如果一个表含有元素较多，而要进行插入或删除的位置又比较靠近表的前端，则移动元素的操作将耗费大量的时间。

为了减少插入和删除元素的线性开销，可以使用链表代替表。在C语言中，链表中不仅保存数据，还保存了指向下一个

元素的指针，如下图

当进行插入操作时，要先将位于插入元素前的元素指针赋值给插入元素。完成赋值后再将插入元素的地址赋值给位于

其前的元素，如下图

当进行删除元素时，只需要删除元素的指针赋值给其前边的元素即可。如下图

使用链表，可以降低插入、删除元素的线性开销。由于链表中不仅存储了数据，而且还保存了指向下一个元素的指针，

因而使用链表将占用更大的存储空间。而在Python中，列表本身就提供了插入和删除操作。因此，在Python中列表

也可以充当链表使用，而不用自己构建。

还有一种链表，称之为双向链表，如下图

双向链表中不仅保存了指向下一个元素地址的指针，而且还保存了指向其上一个元素地址的指针。相对于单向链表，

双向链表需要更大的存储空间，但使用双向列表可以完成倒序扫描连边表。