📅 最后修改于: 2023-12-03 15:10:20.429000 🧑 作者: Mango
数据结构和算法是计算机科学的核心概念之一。它们是编写高性能程序的基础，也是实现最复杂计算机应用程序的关键因素。本文介绍8套数据结构和算法，从基本数据结构（如数组和链表）到高级搜索算法（如深度优先搜索和广度优先搜索）。
数组是存储一系列相同类型数据的数据结构。它可以通过索引非常高效地访问其中的元素。以下是一个示例数组的定义和初始化：
# 定义一个整数数组
numbers = [1, 2, 3, 4, 5]
链表是一种线性数据结构，由一系列节点组成。每个节点包含一个值和指向下一个节点的指针。以下是一个示例单向链表的定义和初始化：
# 定义一个单向链表节点
class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
# 初始化一个单向链表
head = ListNode(1, ListNode(2, ListNode(3, ListNode(4, ListNode(5)))))
栈是一种先进后出的数据结构，可以用数组或链表实现。以下是一个示例基于数组的栈的定义和初始化：
# 定义一个基于数组的栈
class Stack:
def __init__(self):
self.items = []
def is_empty(self):
return not bool(self.items)
def push(self, item):
self.items.append(item)
def pop(self):
return self.items.pop()
# 初始化一个基于数组的栈
stack = Stack()
stack.push(1)
stack.push(2)
stack.push(3)
队列是一种先进先出的数据结构，可以用数组或链表实现。以下是一个示例基于链表的队列的定义和初始化：
# 定义一个基于链表的队列
class Queue:
def __init__(self):
self.head = None
self.tail = None
def is_empty(self):
return not bool(self.head)
def enqueue(self, item):
node = ListNode(item)
if not self.head:
self.head = node
self.tail = node
else:
self.tail.next = node
self.tail = node
def dequeue(self):
item = self.head.val
self.head = self.head.next
return item
# 初始化一个基于链表的队列
queue = Queue()
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(3)
冒泡排序是一种简单的排序算法，它的思想是多次交换相邻的未排序元素，每次交换可以将一个未排序的元素移到其正确的位置。以下是一个示例冒泡排序算法实现：
# 冒泡排序
def bubble_sort(array):
n = len(array)
for i in range(n):
for j in range(0, n-i-1):
if array[j] > array[j+1]:
array[j], array[j+1] = array[j+1], array[j]
# 使用冒泡排序排序一个整数数组
numbers = [5, 2, 9, 1, 5, 6]
bubble_sort(numbers)
print(numbers) # 输出 [1, 2, 5, 5, 6, 9]
快速排序是一种分治算法，它的思想是将一个数组分成两个子数组，分别对这两个子数组递归地进行快速排序，直到所有子数组都是有序的。以下是一个示例快速排序算法实现：
# 快速排序
def quick_sort(array):
if len(array) < 2:
return array
pivot = array[0]
less = [x for x in array[1:] if x <= pivot]
greater = [x for x in array[1:] if x > pivot]
return quick_sort(less) + [pivot] + quick_sort(greater)
# 使用快速排序排序一个整数数组
numbers = [5, 2, 9, 1, 5, 6]
numbers = quick_sort(numbers)
print(numbers) # 输出 [1, 2, 5, 5, 6, 9]
归并排序是一种比较高效的排序算法，它的思想是将一个数组分成两个子数组，对它们分别递归地进行归并排序，然后将子数组合并成一个有序的数组。以下是一个示例归并排序算法实现：
# 归并排序
def merge_sort(array):
if len(array) < 2:
return array
mid = len(array) // 2
left = merge_sort(array[:mid])
right = merge_sort(array[mid:])
i = j = 0
result = []
while i < len(left) and j < len(right):
if left[i] < right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
result += left[i:]
result += right[j:]
return result
# 使用归并排序排序一个整数数组
numbers = [5, 2, 9, 1, 5, 6]
numbers = merge_sort(numbers)
print(numbers) # 输出 [1, 2, 5, 5, 6, 9]
二分查找是一种高效的搜索算法，适用于有序数组。它的思想是重复地将搜索范围折半，直到找到所需元素或范围为空。以下是一个示例二分查找算法实现：
# 二分查找
def binary_search(array, target):
low = 0
high = len(array) - 1
while low <= high:
mid = (low + high) // 2
if array[mid] == target:
return mid
elif array[mid] < target:
low = mid + 1
else:
high = mid - 1
return -1
# 在一个有序整数数组中查找一个元素
numbers = [1, 2, 5, 5, 6, 9]
index = binary_search(numbers, 5)
print(index) # 输出 2
深度优先搜索是一种遍历图或树的算法，它的思想是先沿着一个路径遍历到底，然后回溯到上一个节点，再从它的另一个邻接节点开始遍历。以下是一个示例深度优先搜索算法实现：
# 深度优先搜索
def dfs(graph, start, visited=None):
if visited is None:
visited = set()
visited.add(start)
for neighbor in graph[start]:
if neighbor not in visited:
dfs(graph, neighbor, visited)
# 使用深度优先搜索遍历一个图
graph = {'A': set(['B', 'C']),
'B': set(['A', 'D', 'E']),
'C': set(['A', 'F']),
'D': set(['B']),
'E': set(['B', 'F']),
'F': set(['C', 'E'])}
dfs(graph, 'A')
广度优先搜索是一种遍历图或树的算法，它的思想是先遍历距离起始节点最近的节点，然后遍历它们的邻接节点，直到找到所需节点或遍历完整个图。以下是一个示例广度优先搜索算法实现：
# 广度优先搜索
def bfs(graph, start):
visited = set()
queue = [start]
while queue:
vertex = queue.pop(0)
if vertex not in visited:
visited.add(vertex)
queue.extend(graph[vertex] - visited)
# 使用广度优先搜索遍历一个图
graph = {'A': set(['B', 'C']),
'B': set(['A', 'D', 'E']),
'C': set(['A', 'F']),
'D': set(['B']),
'E': set(['B', 'F']),
'F': set(['C', 'E'])}
bfs(graph, 'A')
本文介绍了8套数据结构和算法，包括基本数据结构、排序算法和搜索算法。每一个主题都包含了一个概念介绍和示例算法实现。这些算法是程序员必须掌握的基础算法，理解它们能帮助我们编写高效程序。