手记

回到首页 个人中心 反馈问题 注册登录
下载APP
首页 课程 实战 体系课 手记 专栏 慕课教程
继续浏览精彩内容
慕课网APP
程序员的梦工厂
打开
继续
感谢您的支持，我会继续努力的
赞赏金额会直接到老师账户
将二维码发送给自己后长按识别
微信支付
支付宝支付

算法与数据结构入门详解

慕少森 2024-11-04 17:00:15 浏览 57
慕少森
关注TA
已关注
手记 269
粉丝 42
获赞 216
概述

本文详细介绍了算法与数据结构的基础概念，包括算法的定义、特性及其评价指标，以及常见的数据结构如数组、链表、栈、队列、树、图和哈希表。文章还提供了多种算法示例，如排序和搜索算法，并探讨了这些数据结构和算法的实际应用场景。

算法基础概念

什么是算法

算法是一组有序的、定义明确的指令集，用于解决特定问题或执行特定任务。它包括输入、输出、处理步骤以及终止条件。算法的目标是使用最少的资源（如时间、空间）来获得预期的结果。

算法的特性

  1. 输入：算法可以有零个或多个输入。
  2. 输出：算法至少应该有一个输出。
  3. 确定性：每个步骤都必须明确定义，确保没有不确定性。
  4. 有限性：算法必须在有限的步骤内终止。
  5. 有效性：算法必须能够在一定的时间和空间资源内执行。

如何评价算法的优劣

评价算法优劣的指标主要包括时间复杂度和空间复杂度。

  1. 时间复杂度：衡量算法运行时间与输入大小的关系。通常用大O符号表示，如O(1), O(n), O(log n)等。
  2. 空间复杂度：衡量算法运行过程中需要的内存大小与输入大小的关系。同样使用大O符号表示。

简单算法示例（如排序算法）

排序是算法中最常见的应用之一。这里以简单的冒泡排序为例进行说明：

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

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = bubble_sort(arr)
print("排序后的数组:", sorted_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 selection_sort(arr):
    n = len(arr)
    for i in range(n):
        min_idx = i
        for j in range(i+1, n):
            if arr[j] < arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]
    return arr

# 插入排序示例
arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = insertion_sort(arr)
print("插入排序后的数组:", sorted_arr)

# 选择排序示例
arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = selection_sort(arr)
print("选择排序后的数组:", sorted_arr)

常见数据结构介绍

数组与链表

数组是一种线性数据结构，所有元素在内存中连续存储。链表则是通过指针进行连接的数据结构，每个元素包含数据和指向下一个元素的指针。

# 数组示例
arr = [1, 2, 3, 4, 5]
print("数组元素:", arr[0])  # 输出第一个元素

# 链表示例
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

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

    def append(self, data):
        new_node = Node(data)
        if self.head is None:
            self.head = new_node
            return
        last = self.head
        while last.next:
            last = last.next
        last.next = new_node

    def display(self):
        current = self.head
        while current:
            print(current.data, end=' -> ')
            current = current.next
        print('None')

# 创建链表实例并添加元素
linked_list = LinkedList()
linked_list.append(1)
linked_list.append(2)
linked_list.append(3)
linked_list.display()

栈与队列

栈（Stack）是一种只能在一端进行插入或删除操作的线性结构，遵循后进先出（LIFO）原则。而队列（Queue）是可以在一端插入元素，在另一端删除元素的线性结构，遵循先进先出（FIFO）原则。

# 栈示例
class Stack:
    def __init__(self):
        self.stack = []

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

    def pop(self):
        if len(self.stack) > 0:
            return self.stack.pop()
        return None

    def peek(self):
        if len(self.stack) > 0:
            return self.stack[-1]
        return None

    def is_empty(self):
        return len(self.stack) == 0

stack = Stack()
stack.push(1)
stack.push(2)
print(stack.pop())  # 输出 2
print(stack.peek())  # 输出 1
print(stack.is_empty())  # 输出 False

# 队列示例
from collections import deque

queue = deque()
queue.append(1)
queue.append(2)
print(queue.popleft())  # 输出 1

树与图

树是一种非线性数据结构，具有根节点和分支节点，每个分支节点可以有子节点。图是由节点（顶点）和边（连接节点的线）组成的结构，可以表示更复杂的连接关系。

# 树示例
class TreeNode:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

# 创建树
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)

# 图示例
class Graph:
    def __init__(self):
        self.graph = {}

    def add_edge(self, vertex, edge):
        if vertex in self.graph:
            self.graph[vertex].append(edge)
        else:
            self.graph[vertex] = [edge]

graph = Graph()
graph.add_edge(0, 1)
graph.add_edge(0, 2)
graph.add_edge(1, 2)
graph.add_edge(2, 0)
graph.add_edge(2, 3)
graph.add_edge(3, 3)
print(graph.graph)

哈希表与集合

哈希表（Hash Table）是通过哈希函数将键映射到数组索引的数据结构，提供快速的插入、删除和查找操作。集合（Set）是一种不允许重复元素的数据结构，通常使用哈希表实现。

# 哈希表示例
hash_table = {}
hash_table['key1'] = 'value1'
hash_table['key2'] = 'value2'
print(hash_table['key1'])  # 输出 value1

# 集合示例
set1 = set([1, 2, 3, 4, 5])
set2 = set([4, 5, 6, 7])
print("交集:", set1.intersection(set2))  # 输出交集 {4, 5}
print("并集:", set1.union(set2))  # 输出并集 {1, 2, 3, 4, 5, 6, 7}

基础算法示例

搜索算法（如二分查找）

二分查找是一种高效的搜索算法，适用于有序数组。它通过不断缩小搜索范围来查找目标值。

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

# 示例
arr = [1, 2, 3, 4, 5]
index = binary_search(arr, 4)
print("目标值的索引:", index)

排序算法（如冒泡排序、快速排序）

冒泡排序通过比较相邻元素并交换位置来完成排序。快速排序通过分治法将数组分成两个子数组，并递归地排序这些子数组。

# 冒泡排序示例
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 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)

arr = [64, 34, 25, 12, 22, 11, 90]
print("冒泡排序:", bubble_sort(arr))
print("快速排序:", quick_sort(arr))

动态规划算法简介

动态规划是一种解决优化问题的方法，通过将问题分解为子问题，并将子问题的解保存起来，以避免重复计算。

# 动态规划示例：背包问题
def knapsack(capacity, weights, values, n):
    if n == 0 or capacity == 0:
        return 0
    if weights[n-1] > capacity:
        return knapsack(capacity, weights, values, n-1)
    else:
        return max(values[n-1] + knapsack(capacity-weights[n-1], weights, values, n-1), knapsack(capacity, weights, values, n-1))

# 示例
weights = [1, 2, 3]
values = [6, 10, 12]
capacity = 5
print("背包问题的最大价值:", knapsack(capacity, weights, values, len(weights)))

# 动态规划示例：最长公共子序列
def lcs(X, Y, m, n):
    L = [[None] * (n + 1) for i in range(m + 1)]
    for i in range(m + 1):
        for j in range(n + 1):
            if i == 0 or j == 0:
                L[i][j] = 0
            elif X[i - 1] == Y[j - 1]:
                L[i][j] = L[i - 1][j - 1] + 1
            else:
                L[i][j] = max(L[i - 1][j], L[i][j - 1])
    return L[m][n]

# 示例
X = "AGGTAB"
Y = "GXTXAYB"
print("最长公共子序列的长度:", lcs(X, Y, len(X), len(Y)))

数据结构的选择与应用

不同数据结构的适用场景

  • 数组：适用于需要快速随机访问的场景。
  • 链表：适用于需要频繁插入或删除元素的场景。
  • 栈：适用于需要后进先出的场景，如解析表达式。
  • 队列：适用于需要先进先出的场景，如任务调度。
  • 树：适用于需要层次结构的场景，如文件系统。
  • 图：适用于需要表示复杂连接关系的场景，如社交网络。
  • 哈希表：适用于需要高效查找、插入和删除的场景。
  • 集合：适用于需要去重的场景。

如何根据需求选择合适的数据结构

选择合适的数据结构主要依据实际需求。例如，如果需要快速查找，可以选择哈希表；如果需要动态插入和删除节点，可以选择链表或树；如果需要层次结构，可以选择树或图。

数据结构在实际问题中的应用案例

  • 计算机网络中的路由表：路由表通常使用哈希表实现高效的路由查找。

    # 路由表示例
routing_table = {}
routing_table['192.168.1.0'] = '192.168.1.1'  # 路由到192.168.1.0的下一跳是192.168.1.1
print("路由表:", routing_table)

  • 操作系统中的任务调度：任务调度通常使用队列实现先进先出的任务调度。

    # 任务调度示例
from collections import deque

task_queue = deque()
task_queue.append("任务1")
task_queue.append("任务2")
print(task_queue.popleft())  # 输出 "任务1"
print(task_queue.popleft())  # 输出 "任务2"

算法与数据结构的实现

如何使用编程语言实现算法与数据结构

使用编程语言实现算法和数据结构通常涉及定义数据结构类和实现相应的操作方法。例如，使用Python实现链表可以定义Node类和LinkedList类。

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

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

    def append(self, data):
        new_node = Node(data)
        if self.head is None:
            self.head = new_node
            return
        last = self.head
        while last.next:
            last = last.next
        last.next = new_node

    def display(self):
        current = self.head
        while current:
            print(current.data, end=' -> ')
            current = current.next
        print('None')

# 创建链表实例并添加元素
linked_list = LinkedList()
linked_list.append(1)
linked_list.append(2)
linked_list.append(3)
linked_list.display()

常见编程语言中的数据结构支持

大多数编程语言都内置了常见的数据结构支持，如Python的list, dict, set, deque等。这些内置类型提供了高效的数据结构实现。

# Python内置数据结构示例
from collections import deque

stack = deque()
stack.append(1)
stack.append(2)
print(stack.pop())  # 输出 2
print(stack.pop())  # 输出 1

queue = deque()
queue.append(1)
queue.append(2)
print(queue.popleft())  # 输出 1
print(queue.popleft())  # 输出 2

练习与实践

经典算法与数据结构问题集锦

  • 排序算法：冒泡排序、插入排序、选择排序、归并排序、快速排序。
  • 搜索算法：二分查找、深度优先搜索（DFS）、广度优先搜索（BFS）。
  • 动态规划算法：斐波那契数列、背包问题、最长公共子序列。
  • 图算法：最短路径（Dijkstra算法）、最小生成树（Prim算法）。

在线编程平台推荐

  • LeetCode：提供大量的算法和数据结构题目，有助于提高编程能力。
  • CodeForces：专注于算法竞赛，涵盖多种编程语言。
  • HackerRank：提供从新手到高级的编程挑战，涵盖多种编程语言。

实践项目建议与参考资料

  • LeetCode Daily Coding Challenge: 每天解决一个编程问题，逐步提高算法能力。
  • 数据结构与算法题目集: 参考LeetCode、CodeForces等平台的题目集，进行系统性的练习。
  • 书籍推荐：《算法导论》、《编程珠玑》、《编程之美》等。

通过实际编程项目和在线编程挑战，可以更好地理解和应用算法与数据结构。

打开App，阅读手记
相关标签
算法与数据结构
0人推荐
发表评论
随时随地看视频慕课网APP

相关课程

算法与数据结构（C++版） 面试/评级的算法复习技能包

¥166 初级 11202

剑指Java面试-Offer直通车 百度资深面试官授课

¥299 中级 8438

玩转算法面试-- Leetcode真题分门别类讲解

¥266 初级 7430

Javascript实现二叉树算法

免费 中级 46969

个性化推荐算法实战入门必修课

免费 中级 23532

算法大师之路

¥1899 61