数据结构与算法教程入门指南

数据结构与算法教程是一篇为初学者打造的指南，全面介绍了数组、链表、栈、队列、哈希表、树与图等数据结构的基础概念与应用实例。同时，深度解读了排序与搜索算法，包括冒泡、选择、插入、快速、归并、堆排序等，并通过实际代码示例展示解决问题的核心技能及灵活运用数据结构与算法的实践方法。通过本教程的学习，读者将掌握高效解决问题的技能，并在编程实践中灵活运用知识。

数组基础

数组是一种线性数据结构，元素按照特定顺序排列在存储空间中。数组通过下标访问元素，查找效率高，但插入、删除操作较为耗时。

# 定义一个数组
arr = [1, 2, 3, 4, 5]

# 访问数组元素
print(arr[0])  # 输出：1

# 插入元素
arr.insert(2, 6)
print(arr)  # 输出：[1, 2, 6, 3, 4, 5]

# 删除元素
del arr[2]
print(arr)  # 输出：[1, 2, 3, 4, 5]

链表基础

链表是一种非线性数据结构，由节点组成，每个节点包含数据和指向下一个节点的指针。分为单链表和双链表，单链表插入和删除操作效率较低。

class Node:
    def __init__(self, data=None):
        self.data = data
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None

    def append(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            return
        last_node = self.head
        while last_node.next:
            last_node = last_node.next
        last_node.next = new_node

# 创建链表实例并添加元素
linked_list = LinkedList()
linked_list.append(1)
linked_list.append(2)
linked_list.append(3)
print(linked_list.head.data)  # 输出：1

栈基础

栈遵循后进先出（LIFO）原则，支持压栈（push）和弹栈（pop）操作。

class Stack:
    def __init__(self):
        self.items = []

    def push(self, item):
        self.items.append(item)

    def pop(self):
        if not self.items:
            return None
        return self.items.pop()

# 使用栈实例
s = Stack()
s.push(1)
s.push(2)
s.push(3)
print(s.pop())  # 输出：3

队列基础

队列遵循先进先出（FIFO）原则，包括入队（enqueue）和出队（dequeue）操作。

class Queue:
    def __init__(self):
        self.items = []

    def enqueue(self, item):
        self.items.append(item)

    def dequeue(self):
        if not self.items:
            return None
        return self.items.pop(0)

# 使用队列实例
q = Queue()
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
print(q.dequeue())  # 输出：1

哈希表基础

哈希表使用哈希函数将键映射到数组位置，便于快速查找、插入和删除元素。

class HashTable:
    def __init__(self, size=1024):
        self.size = size
        self.table = [None] * size

    def _hash(self, key):
        return hash(key) % self.size

    def insert(self, key, value):
        index = self._hash(key)
        if self.table[index] is None:
            self.table[index] = [(key, value)]
        else:
            for pair in self.table[index]:
                if pair[0] == key:
                    pair[1] = value
                    return
            self.table[index].append((key, value))

    def get(self, key):
        index = self._hash(key)
        if self.table[index] is None:
            return None
        for pair in self.table[index]:
            if pair[0] == key:
                return pair[1]
        return None

# 使用哈希表实例
ht = HashTable()
ht.insert("apple", 10)
ht.insert("banana", 20)
print(ht.get("apple"))  # 输出：10

树基础

树是一种非线性数据结构，由结点和边组成，每个结点可以有多个子结点。

class TreeNode:
    def __init__(self, value):
        self.value = value
        self.children = []

    def add_child(self, child_node):
        self.children.append(child_node)

# 构建树的基本操作
root = TreeNode("root")
node1 = TreeNode("node1")
root.add_child(node1)

图基础

图是一种复杂数据结构，由节点（顶点）和边组成，用于表示实体间的关系。

class Graph:
    def __init__(self):
        self.nodes = {}

    def add_node(self, node_id):
        self.nodes[node_id] = []

    def add_edge(self, from_id, to_id):
        if from_id in self.nodes and to_id in self.nodes:
            self.nodes[from_id].append(to_id)

# 使用图实例
g = Graph()
g.add_node("A")
g.add_node("B")
g.add_edge("A", "B")

数据结构的选择与应用实例

在选择数据结构时，应考虑访问频率、更新频率、数据大小、内存使用效率、运行速度等因素。针对不同应用场景，可选择合适的数据结构，如数据库索引、搜索引擎、缓存、任务调度等。

排序与搜索算法详解

排序算法实践

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

def selection_sort(arr):
    for i in range(len(arr)):
        min_idx = i
        for j in range(i+1, len(arr)):
            if arr[j] < arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]
    return arr

def insertion_sort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        while j >= 0 and key < arr[j]:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key
    return arr

def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quick_sort(left) + middle + quick_sort(right)

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)

def merge(left, right):
    result = []
    while left and right:
        if left[0] < right[0]:
            result.append(left.pop(0))
        else:
            result.append(right.pop(0))
    result.extend(left or right)
    return result

def heap_sort(arr):
    n = len(arr)
    for i in range(n // 2 - 1, -1, -1):
        heapify(arr, n, i)
    for i in range(n-1, 0, -1):
        arr[i], arr[0] = arr[0], arr[i]
        heapify(arr, i, 0)
    return arr

def heapify(arr, n, i):
    largest = i
    left = 2 * i + 1
    right = 2 * i + 2
    if left < n and arr[i] < arr[left]:
        largest = left
    if right < n and arr[largest] < arr[right]:
        largest = right
    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]
        heapify(arr, n, largest)

搜索算法实践

def linear_search(arr, target):
    for i in range(len(arr)):
        if arr[i] == target:
            return i
    return -1

def binary_search(arr, target):
    low, high = 0, len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return -1

树与图的遍历

def pre_order_traversal(node):
    if node is not None:
        print(node.value)
        pre_order_traversal(node.left)
        pre_order_traversal(node.right)

def in_order_traversal(node):
    if node is not None:
        in_order_traversal(node.left)
        print(node.value)
        in_order_traversal(node.right)

def post_order_traversal(node):
    if node is not None:
        post_order_traversal(node.left)
        post_order_traversal(node.right)
        print(node.value)

def dfs(graph, node, visited):
    if node not in visited:
        visited.add(node)
        for neighbor in graph[node]:
            dfs(graph, neighbor, visited)

def bfs(graph, start):
    visited = set()
    queue = deque([start])
    visited.add(start)
    while queue:
        node = queue.popleft()
        print(node, end=' ')
        for neighbor in graph[node]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor)

实战演练与问题解决

LRU缓存

from collections import OrderedDict

class LRUCache:
    def __init__(self, capacity):
        self.cache = OrderedDict()
        self.capacity = capacity

    def get(self, key):
        if key in self.cache:
            self.cache.move_to_end(key)
            return self.cache[key]
        return -1

    def put(self, key, value):
        if key in self.cache:
            self.cache.move_to_end(key)
        self.cache[key] = value
        if len(self.cache) > self.capacity:
            self.cache.popitem(last=False)

Top K问题

def top_k_elements(arr, k):
    return sorted(arr, reverse=True)[:k]

arr = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
k = 3
print(top_k_elements(arr, k))  # 输出: [9, 6, 5]

通过上述代码示例，读者可以直观地理解和掌握数据结构和算法的基本概念与实现方法。