程序员的串联——数据结构与算法

在程序员的日常工作中，涉及到大量的数据操作，因此熟练掌握数据结构与算法是非常必要的。而数据结构与算法的学习，是一种串联的过程。

什么是数据结构？

数据结构是指数据的组织形式，是程序中数据存储、处理以及访问的方式。常见的数据结构包括数组、链表、栈、队列、树、图等。

数组

数组是指一种线性表，可以按照一定的次序排列组合。数组中所有元素具有相同的类型，并且每个元素占用同样大小的内存。

# 定义一个长度为10的整型数组
int_list = [0] * 10

# 赋值
for i in range(10):
    int_list[i] = i

# 访问元素
print(int_list[0]) # 0

链表

链表是指一种链式存储的线性表，每个节点包含一个数据元素和一个指向下一个节点的引用。

# 链表节点类
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

# 定义一个链表
head = ListNode(1)
node1 = ListNode(2)
node2 = ListNode(3)

head.next = node1
node1.next = node2

# 遍历链表
p = head
while p:
    print(p.val)
    p = p.next

栈

栈是指一种线性表，具有后进先出的特点。栈顶指针指向最后插入的元素，插入和删除操作总是在栈顶进行。

# 栈类
class Stack:
    def __init__(self):
        self.data = []

    def push(self, val):
        self.data.append(val)

    def pop(self):
        if not self.empty():
            return self.data.pop()

    def top(self):
        if not self.empty():
            return self.data[-1]

    def empty(self):
        return len(self.data) == 0

# 使用栈进行括号匹配
def is_valid(s: str) -> bool:
    stack = Stack()
    for c in s:
        if c == '(':
            stack.push(')')
        elif c == '{':
            stack.push('}')
        elif c == '[':
            stack.push(']')
        else:
            if stack.empty() or stack.pop() != c:
                return False
    return stack.empty()

print(is_valid('()[]{}')) # True
print(is_valid('(]')) # False

队列

队列是指一种线性表，具有先进先出的特点。队头指针指向最先插入的元素，队尾指针指向最后插入的元素。

# 队列类
class Queue:
    def __init__(self):
        self.data = []

    def push(self, val):
        self.data.append(val)

    def pop(self):
        if not self.empty():
            return self.data.pop(0)

    def front(self):
        if not self.empty():
            return self.data[0]

    def empty(self):
        return len(self.data) == 0

# 使用队列进行广度优先搜索
def bfs(graph, start, end):
    queue = Queue()
    queue.push(start)
    visited = {start}

    while not queue.empty():
        node = queue.pop()
        for neighbor in graph[node]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.push(neighbor)
                if neighbor == end:
                    return True

    return False

graph = {
    'A': ['B', 'C'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F'],
    'D': ['B'],
    'E': ['B', 'F'],
    'F': ['C', 'E']
}

print(bfs(graph, 'A', 'F')) # True

什么是算法？

算法是指用于解决特定问题的一系列指令，是程序中的具体实现过程。常见的算法包括排序算法、查找算法、字符串匹配算法等。

排序算法

排序算法是指将一组数据按照一定的规则进行排列的算法。常见的排序算法包括冒泡排序、选择排序、插入排序、归并排序、快速排序等。

# 快速排序
def quick_sort(nums):
    if len(nums) <= 1:
        return nums

    pivot = nums[0]
    left = []
    right = []
    for num in nums[1:]:
        if num < pivot:
            left.append(num)
        else:
            right.append(num)

    return quick_sort(left) + [pivot] + quick_sort(right)

nums = [3, 5, 2, 1, 6, 4]
print(quick_sort(nums)) # [1, 2, 3, 4, 5, 6]

查找算法

查找算法是指在一组数据中查找指定的元素的算法。常见的查找算法包括线性查找、二分查找、哈希查找等。

# 二分查找
def binary_search(nums, target):
    left = 0
    right = len(nums) - 1

    while left <= right:
        mid = (left + right) // 2
        if nums[mid] == target:
            return mid
        elif nums[mid] < target:
            left = mid + 1
        else:
            right = mid - 1

    return -1

nums = [1, 2, 3, 4, 5, 6]
target = 4
print(binary_search(nums, target)) # 3

字符串匹配算法

字符串匹配算法是指在一个文本串中查找一个模式串的算法。常见的字符串匹配算法包括朴素的暴力匹配算法、KMP算法、Boyer-Moore算法等。

# KMP算法
def kmp_search(s, p):
    n = len(s)
    m = len(p)
    next = get_next(p)

    i = 0
    j = 0

    while i < n and j < m:
        if j == -1 or s[i] == p[j]:
            i += 1
            j += 1
        else:
            j = next[j]

    if j == m:
        return i - j

    return -1

def get_next(p):
    m = len(p)
    next = [-1] * m

    i = 0
    j = -1

    while i < m - 1:
        if j == -1 or p[i] == p[j]:
            i += 1
            j += 1
            next[i] = j
        else:
            j = next[j]

    return next

s = 'hello world'
p = 'world'
print(kmp_search(s, p)) # 6

强调

数据结构与算法的学习是一个串联的过程，只有掌握了基础的数据结构和算法，才能从容应对各种复杂的问题。因此在日常工作中，我们应该重视数据结构与算法的学习，可以从这些方面提升自己的能力和水平。