python 数据结构与算法

最新推荐文章于 2024-08-31 21:39:38 发布
最新推荐文章于 2024-08-31 21:39:38 发布
阅读量4.6k 收藏 14
点赞数 29
文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74972192/article/details/140712059
版权

在这篇博客中，我们将探讨一些高级的 Python 编程示例，包括快速排序、归并排序、堆排序、深度优先搜索、广度优先搜索、最短路径算法、最小生成树、拓扑排序、Trie 树和动态规划。

示例 1：快速排序

步骤

  1. 定义一个函数 quick_sort，对一个列表进行快速排序。
  2. 选择一个基准元素，将列表分为小于、等于和大于基准元素的三个部分。
  3. 递归地对左右部分进行排序，并合并结果。

代码

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)

# Example usage
arr = [3, 6, 8, 10, 1, 2, 1]
print("Quick Sort:", quick_sort(arr))

 

代码解析

  1. def quick_sort(arr)：定义快速排序函数。
  2. pivot = arr[len(arr) // 2]：选择基准元素。
  3. left, middle, right：将列表分为小于、等于和大于基准元素的三个部分。
  4. return quick_sort(left) + middle + quick_sort(right)：递归地对左右部分进行排序，并合并结果。

运行结果

Quick Sort: [1, 1, 2, 3, 6, 8, 10]

示例 2：归并排序

步骤

  1. 定义一个函数 merge_sort，对一个列表进行归并排序。
  2. 将列表分为左右两部分，递归地对左右部分进行排序。
  3. 定义一个函数 merge，合并两个有序列表。

代码

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 = []
    i = j = 0
    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.extend(left[i:])
    result.extend(right[j:])
    return result

# Example usage
arr = [3, 6, 8, 10, 1, 2, 1]
print("Merge Sort:", merge_sort(arr))

代码解析

  1. def merge_sort(arr)：定义归并排序函数。
  2. mid = len(arr) // 2：将列表分为左右两部分。
  3. left = merge_sort(arr[:mid])：递归地对左部分进行排序。
  4. right = merge_sort(arr[mid:])：递归地对右部分进行排序。
  5. return merge(left, right)：合并两个有序列表。

运行结果

Merge Sort: [1, 1, 2, 3, 6, 8, 10]

 

示例 3：堆排序

步骤

  1. 定义一个函数 heapify，将列表调整为堆。
  2. 定义一个函数 heap_sort，对一个列表进行堆排序。
  3. 构建最大堆，并将最大元素移到末尾，重复此过程。

代码

 

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 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)

# Example usage
arr = [3, 6, 8, 10, 1, 2, 1]
heap_sort(arr)
print("Heap Sort:", arr)

 

代码解析

  1. def heapify(arr, n, i)：定义堆调整函数。
  2. def heap_sort(arr)：定义堆排序函数。
  3. for i in range(n // 2 - 1, -1, -1)：构建最大堆。
  4. for i in range(n - 1, 0, -1)：将最大元素移到末尾，重复此过程。

运行结果

Heap Sort: [1, 1, 2, 3, 6, 8, 10]

示例 4：深度优先搜索

步骤

  1. 定义一个函数 dfs，实现图的深度优先搜索算法。
  2. 使用递归遍历图的节点。

代码

def dfs(graph, start, visited=None):
    if visited is None:
        visited = set()
    visited.add(start)
    print(start, end=' ')
    for neighbor in graph[start] - visited:
        dfs(graph, neighbor, visited)

# Example usage
graph = {
    'A': {'B', 'C'},
    'B': {'A', 'D', 'E'},
    'C': {'A', 'F'},
    'D': {'B'},
    'E': {'B', 'F'},
    'F': {'C', 'E'}
}
print("DFS:", end=' ')
dfs(graph, 'A')

 

代码解析

  1. def dfs(graph, start, visited=None)：定义深度优先搜索函数。
  2. visited.add(start)：将当前节点标记为已访问。
  3. for neighbor in graph[start] - visited：遍历未访问的邻居节点。
  4. dfs(graph, neighbor, visited)：递归地进行深度优先搜索。

运行结果

DFS: A B D E F C

示例 5：广度优先搜索

步骤

  1. 导入 deque 模块。
  2. 定义一个函数 bfs，实现图的广度优先搜索算法。
  3. 使用队列遍历图的节点。

代码

from collections import deque

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

# Example usage
graph = {
    'A': {'B', 'C'},
    'B': {'A', 'D', 'E'},
    'C': {'A', 'F'},
    'D': {'B'},
    'E': {'B', 'F'},
    'F': {'C', 'E'}
}
print("\nBFS:", end=' ')
bfs(graph, 'A')

 

代码解析

  1. from collections import deque：导入 deque 模块。
  2. def bfs(graph, start)：定义广度优先搜索函数。
  3. queue = deque([start])：初始化队列。
  4. while queue：遍历队列中的节点。
  5. for neighbor in graph[vertex] - visited：遍历未访问的邻居节点。

运行结果

BFS: A B C D E F

 

示例 6：最短路径算法

步骤

  1. 导入 heapq 模块。
  2. 定义一个函数 dijkstra，实现 Dijkstra 算法计算图的最短路径。
  3. 使用优先队列维护最短路径。

代码

import heapq

def dijkstra(graph, start):
    distances = {vertex: float('infinity') for vertex in graph}
    distances[start] = 0
    pq = [(0, start)]

    while pq:
        current_distance, current_vertex = heapq.heappop(pq)

        if current_distance > distances[current_vertex]:
            continue

        for neighbor, weight in graph[current_vertex].items():
            distance = current_distance + weight

            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(pq, (distance, neighbor))

    return distances

# Example usage
graph = {
    'A': {'B': 1, 'C': 4},
    'B': {'A': 1, 'D': 2, 'E': 7},
    'C': {'A': 4, 'F': 5},
    'D': {'B': 2},
    'E': {'B': 7, 'F': 3},
    'F': {'C': 5, 'E': 3}
}
print("Dijkstra Shortest Path:", dijkstra(graph, 'A'))

代码解析

  1. import heapq：导入 heapq 模块。
  2. def dijkstra(graph, start)：定义 Dijkstra 算法函数。
  3. distances = {vertex: float(‘infinity’) for vertex in graph}：初始化所有节点的距离为无穷大。
  4. distances[start] = 0：设置起始节点的距离为 0。
  5. pq = [(0, start)]：初始化优先队列。
  6. while pq：遍历优先队列中的节点。
  7. current_distance, current_vertex = heapq.heappop(pq)：弹出优先队列中的最小距离节点。
  8. for neighbor, weight in graph[current_vertex].items()：遍历当前节点的邻居节点。
  9. distance = current_distance + weight：计算邻居节点的距离。
  10. if distance < distances[neighbor]：如果计算的距离小于已知的最短距离，更新距离并将邻居节点加入优先队列。

 

运行结果

# Example usage
graph = {
    'A': {'B': 1, 'C': 4},
    'B': {'A': 1, 'D': 2, 'E': 7},
    'C': {'A': 4, 'F': 5},
    'D': {'B': 2},
    'E': {'B': 7, 'F': 3},
    'F': {'C': 5, 'E': 3}
}
print("Dijkstra Shortest Path:", dijkstra(graph, 'A'))


Dijkstra Shortest Path: {'A': 0, 'B': 1, 'C': 4, 'D': 3, 'E': 8, 'F': 7}

示例 7：最小生成树

步骤

  1. 导入 heapq 模块。
  2. 定义一个函数 prim，实现 Prim 算法计算图的最小生成树。
  3. 使用优先队列维护最小生成树的边。

代码

 

import heapq

def prim(graph, start):
    mst = []
    visited = set()
    edges = [(cost, start, to) for to, cost in graph[start].items()]
    heapq.heapify(edges)
    visited.add(start)

    while edges:
        cost, frm, to = heapq.heappop(edges)
        if to not in visited:
            visited.add(to)
            mst.append((frm, to, cost))
            for neighbor, cost in graph[to].items():
                if neighbor not in visited:
                    heapq.heappush(edges, (cost, to, neighbor))

    return mst

# Example usage
graph = {
    'A': {'B': 1, 'C': 4},
    'B': {'A': 1, 'D': 2, 'E': 7},
    'C': {'A': 4, 'F': 5},
    'D': {'B': 2},
    'E': {'B': 7, 'F': 3},
    'F': {'C': 5, 'E': 3}
}
print("Prim's Minimum Spanning Tree:", prim(graph, 'A'))

代码解析

  1. import heapq：导入 heapq 模块。
  2. def prim(graph, start)：定义 Prim 算法函数。
  3. mst = []：初始化最小生成树的边列表。
  4. visited = set()：初始化已访问节点集合。
  5. edges = [(cost, start, to) for to, cost in graph[start].items()]：初始化优先队列。
  6. heapq.heapify(edges)：将边列表转换为优先队列。
  7. while edges：遍历优先队列中的边。
  8. cost, frm, to = heapq.heappop(edges)：弹出优先队列中的最小边。
  9. if to not in visited：如果目标节点未访问，加入最小生成树并更新优先队列。

运行结果

Prim's Minimum Spanning Tree: [('A', 'B', 1), ('B', 'D', 2), ('A', 'C', 4), ('C', 'F', 5), ('F', 'E', 3)]

示例 8：拓扑排序

步骤

  1. 导入 defaultdict 和 deque 模块。
  2. 定义一个函数 topological_sort，实现拓扑排序算法。
  3. 使用队列维护入度为 0 的节点。

代码

from collections import defaultdict, deque

def topological_sort(graph):
    indegree = {node: 0 for node in graph}
    for node in graph:
        for neighbor in graph[node]:
            indegree[neighbor] += 1

    zero_indegree_queue = deque([node for node in indegree if indegree[node] == 0])
    topo_order = []

    while zero_indegree_queue:
        node = zero_indegree_queue.popleft()
        topo_order.append(node)
        for neighbor in graph[node]:
            indegree[neighbor] -= 1
            if indegree[neighbor] == 0:
                zero_indegree_queue.append(neighbor)

    if len(topo_order) == len(graph):
        return topo_order
    else:
        return []

# Example usage
graph = {
    'A': ['B', 'C'],
    'B': ['D'],
    'C': ['D', 'E'],
    'D': ['E'],
    'E': []
}
print("Topological Order:", topological_sort(graph))

 

 

代码解析

  1. from collections import defaultdict, deque：导入 defaultdict 和 deque 模块。
  2. def topological_sort(graph)：定义拓扑排序函数。
  3. indegree = {node: 0 for node in graph}：初始化所有节点的入度为 0。
  4. for node in graph：遍历图中的节点，计算每个节点的入度。
  5. zero_indegree_queue = deque([node for node in indegree if indegree[node] == 0])：初始化入度为 0 的节点队列。
  6. while zero_indegree_queue：遍历队列中的节点。
  7. node = zero_indegree_queue.popleft()：弹出队列中的节点。
  8. for neighbor in graph[node]：遍历当前节点的邻居节点，更新入度。

运行结果

Topological Order: ['A', 'B', 'C', 'D', 'E']

示例 9：Trie 树

步骤

  1. 定义 Trie 树节点类 TrieNode。
  2. 定义 Trie 树类 Trie，实现插入和搜索操作。

代码

class TrieNode:
    def __init__(self):
        self.children = {}
        self.is_end_of_word = False

class Trie:
    def __init__(self):
        self.root = TrieNode()

    def insert(self, word):
        current_node = self.root
        for char in word:
            if char not in current_node.children:
                current_node.children[char] = TrieNode()
            current_node = current_node.children[char]
        current_node.is_end_of_word = True

    def search(self, word):
        current_node = self.root
        for char in word:
            if char not in current_node.children:
                return False
            current_node = current_node.children[char]
        return current_node.is_end_of_word

# Example usage
trie = Trie()
trie.insert("apple")
trie.insert("app")
print("Search 'apple':", trie.search("apple"))  # 输出True
print("Search 'app':", trie.search("app"))      # 输出True
print("Search 'banana':", trie.search("banana"))  # 输出False

 

代码解析

  1. class TrieNode：定义 Trie 树节点类。
  2. class Trie：定义 Trie 树类。
  3. def insert(self, word)：定义插入单词的方法。
  4. def search(self, word)：定义搜索单词的方法。

运行结果

Search 'apple': True
Search 'app': True
Search 'banana': False

示例 10：动态规划

步骤

  1. 定义一个函数 knapsack，使用动态规划解决背包问题。
  2. 初始化动态规划表 dp。
  3. 递归地计算每个子问题的最优解。

代码

def knapsack(weights, values, capacity):
    n = len(weights)
    dp = [[0] * (capacity + 1) for _ in range(n + 1)]
    
    for i in range(1, n + 1):
        for w in range(1, capacity + 1):
            if weights[i - 1] > w:
                dp[i][w] = dp[i - 1][w]
            else:
                dp[i][w] = max(dp[i - 1][w], values[i - 1] + dp[i - 1][w - weights[i - 1]])
    
    return dp[n][capacity]

# Example usage
weights = [1, 2, 3, 4, 5]
values = [10, 20, 30, 40, 50]
capacity = 7
print("Maximum value in knapsack:", knapsack(weights, values, capacity))

 

代码解析

  1. def knapsack(weights, values, capacity)：定义背包问题的动态规划函数。
  2. n = len(weights)：获取物品数量。
  3. dp = [[0] * (capacity + 1) for _ in range(n + 1)]：初始化动态规划表 dp。
  4. for i in range(1, n + 1)：遍历所有物品。
  5. for w in range(1, capacity + 1)：遍历所有可能的容量。
  6. if weights[i - 1] > w：如果当前物品的重量大于当前容量，不能选择该物品。
  7. dp[i][w] = dp[i - 1][w]：不选择当前物品，继承上一个状态的值。
  8. else：如果当前物品的重量小于等于当前容量，可以选择该物品。
  9. dp[i][w] = max(dp[i - 1][w], values[i - 1] + dp[i - 1][w - weights[i - 1]])：选择当前物品，更新动态规划表。

运行结果

# Example usage
weights = [1, 2, 3, 4, 5]
values = [10, 20, 30, 40, 50]
capacity = 7
print("Maximum value in knapsack:", knapsack(weights, values, capacity))
Maximum value in knapsack: 90

总结

通过这篇博客文章，你学会了如何使用 Python 实现一些高级的编程示例，包括快速排序、归并排序、堆排序、深度优先搜索、广度优先搜索、最短路径算法、最小生成树、拓扑排序、Trie 树和动态规划。我们逐步讲解了代码的实现，包括步骤、代码解析和运行结果。你可以根据需要修改和扩展这些示例，以实现更多的功能。

其他文章推荐

相关类型推荐

  • 深入理解 Python 数据结构与算法
  • Python 高级编程技巧
  • Python 算法与数据结构实战

希望这个详细的讲解对你有所帮助！如果你有任何问题或需要进一步的帮助，请随时告诉我。

 

LIY若依
关注
  • 29
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
Python数据结构与算法（1.7）——算法分析
盼小辉丶的博客
12-26 2万+
我们已经知道算法是具有有限步骤的过程，其最终的目的是为了解决问题，而根据我们的经验，同一个问题的解决方法通常并非唯一。这就产生一个有趣的问题：如何对比用于解决同一问题的不同算法？为了以合理的方式提高程序效率，我们应该知道如何准确评估一个算法的性能。本节学习首先介绍算法分析的重要性，并讲解了分析算法的时间复杂度和空间复杂度分析方法，最后介绍了Python列表和字典常见操作的时间复杂度。
Python数据结构与算法（2.2）——顺序表
热门推荐
盼小辉丶的博客
01-07 2万+
线性表的顺序存储是把线性表的数据元素按逻辑次序依次存放在一组连续的存储单元中，即逻辑结构上相邻的两个数据元素存储在计算机内的物理存储位置也是相邻的，这种存储方法为整个线性表分配一整个内存块保存线性表的元素，借助数据元素在计算机内的物理位置表示线性表中数据元素之间的逻辑关系。采用顺序存储结构表示的线性表简称顺序表 (Sequential List)。本节将介绍顺序表的特点以及各种基本操作的实现。
Python 数据结构与算法
2401_84204413的博客
04-22 1056
Python 是一种强大且灵活的编程语言，非常适合用于实现各种数据结构和算法。数据结构和算法是计算机科学中的基础概念，对于解决实际问题、优化程序性能以及提高代码的可读性和可维护性至关重要。### 数据结构数据结构是计算机存储、组织和管理数据的方式。以下是一些在 Python 中常见的数据结构：1. **列表 (List)**: 有序的元素集合，允许重复。 2. **元组 (Tuple)**: 不可变的有序元素集合，允许重复。 3. **字典 (Dictionary)**: 无序的键值对集合，键唯一。 4.
python数据结构与算法
算法探索之路
12-03 1075
课程链接【点这里】 配套的全部课件源码 链接：https://pan.baidu.com/s/1DbNXI1W_i8gni1Fqz6CWbQ 提取码：p7mu 给我点个关注 就是对我最大的支持
【Python数据结构与算法】（一）基本概念和算法分析
阿里云专家博主、数据科学领域优质创作者、统计er在读
06-02 2253
✨本文收录于[《Python数据结构与算法》专栏，此专栏主要记录如何python学习数据结构与算法笔记以及练习题。 🌸个人主页：JoJo的数据分析历险记 📝个人介绍：小编大四统计在读，目前保研到统计学top3高校继续攻读统计研究生 💌如果文章对你有帮助，欢迎✌关注、👍点赞、✌收藏、👍订阅专栏 介绍数据结与算法基础概念、如何判断算法的时间复杂度，以及主项定理的介绍。...
Python 数据结构与算法,中文版请下载！
bigzql的博客
06-07 1156
数据结构作为计算机从业人员的必备基础，Java, c 之类的语言有很多这方面的书籍，Python 相对较少，其中比较著名的一本Python 数据结构与算法所以我在学习的过程中将其翻译了中文版，希望对大家有点帮助。地址github 地址:https://github.com/facert/python-data-structure-cngitbook 在线浏览:ht...
4.Python数据结构与算法分析课后习题(第二版)__chapter4
conan04260426的博客
10-13 4383
Python数据结构与算法分析课后习题第四章答案
python数据结构及算法
weixin_45841852的博客
02-13 2413
python数据结构及算法 一. 数据结构与算法 1. 算法的概念：算法是独立存在的一种解决问题的方法和思想 2. 算法的特征：输入，输出，有穷性，确定性，可行性 3. 时间复杂度是实现算法程序所需要的时间，即算法的优劣 4. 数据结构是指数据对象中数据元素之间的关系 5. 程序 = 数据结构 + 算法 6. 算法是为了解决实际问题而设计的，数据结构是算法需要处理的问题载体 二. 顺序表 1. 顺...
Python数据结构与算法分析（第二版）答案 - 第二章（仅供参考）
m0_62401440的博客
04-20 4843
import timeit #2.1 设计一个实验，证明列表的索引操作为常数阶。 #2.2 设计一个实验，证明字典的取值操作和赋值操作为常数阶。 if 1: for i in range(1000, 100001, 2000): t = timeit.Timer("random.randrange(%d) in x" % i, "from __main__ import random, x") x = list(range(i)) lidx_tim.
python数据结构之算法分析
柳小葱的博客
08-02 2041
????????奥运会看着真热血呀，但也不能忘记学习！在python的数据结构的章节中，我们上次学习到了python面向对象的思想，即我们想用程序来实现一个东西，我们需是用对象的特征来描述我们想构建的对象。感兴趣的小伙伴可以查看下面内容????: python数据类型: python数据结构之数据类型. python的输入输出: python数据结构之输入输出、控制和异常. python数据结构之面向对象: python数据结构之面向对象. ????今天我们来学习的内容是面试题中都避免不小了的问题，就是
Python数据结构与算法分析（第2版）1
08-03
【Python数据结构与算法分析（第2版）】是一本专为Python程序员设计的书籍，旨在帮助读者深入了解数据结构和算法在Python环境中的应用。作者布拉德利·米勒和戴维·拉努姆以其丰富的实战经验，清晰地阐述了如何高效...
python数据结构与算法-已转档.pdf
06-17
标题中的“Python数据结构与算法”指向了文档内容的核心主题，即通过Python语言来探索和实现数据结构与算法的相关知识。这部分内容主要涵盖Python编程语言中数据结构的实现方式、算法的设计技巧以及递归等编程概念的...
Python数据结构与算法分析.docx
09-13
Python 数据结构与算法分析 Python 数据结构与算法分析是计算机科学中的一门重要课程，涵盖了数据结构和算法两个方面的内容。在 Python 中，数据结构是指对数据的组织、存储和管理方式，而算法则是指解决问题或完成...
python12 中，No module named‘distutils‘错误
qq_43557600的博客
08-27 1万+
python12 “ No module named'distutils' ”,​ 安装 pip install setuptools ，解决 ​
centos7 安装 superset4.0.2 教程
m0_37759590的博客
08-27 1万+
centos7 安装 superset4.0.2 教程
python从入门到精通：数据可视化-图形开发
2401_83283514的博客
08-29 1067
• Json是一种轻量级的数据交互格式，可以按照Json指定的格式去组织和封装数据• Json本质上是一种带有特殊格式的字符串主要功能：json就是一种在各个编程语言中流通的数据格式，负责不同编程语言中的数据传递和交互，类似于：• 国际通用语言-英语• 中国不同名族的通用语言-中文（普通话）• 各种编程语言存储数据的容器不尽相同，在python中有字典dict这样的数据类型，而其它语言可能没有对应的字典。为了让不同的语言都能够相互通用的互相传递数据，Json就是一种非常良好的数据中转格式。
CSS解析:定位和层叠上下文
最新发布
晓风残月淡的博客
08-31 1160
许多开发人员对定位的理解很粗略，如果不完全了解定位，就很容易给自己挖坑。有时候可能会把错误的元素放在其他元素前面，要解决这个问题却没有那么简单。一般的布局方法是用各种操作来控制文档流的行为。定位则不同：它将元素彻底从文档流中移走。它允许你将元素放在屏幕的任意位置。还可以将一个元素放在另一个元素的前面或后面，彼此重叠。
【python】关于判断空值None、判断len()=0，和 if not 的区别
Meggie35的博客
08-28 5857
python的“空”与“无”之辩，关于None，和空数值。在程序中，判断里面没有值和判断东西是不是为空，也是不一样的东西，我们可以往下看看具体的区别。
使用 DrissionPage 和 2Captcha 处理 Turnstile 验证并获取 Faucet 签名
qq_41631913的博客
08-30 498
本教程介绍了两种获取 Cloudflare Turnstile 验证值并使用 faucet 签名 API 的方法。第一种方法通过 DrissionPage 模拟浏览器操作，手动获取验证码值。第二种方法则通过 2Captcha 服务，自动化解决验证码问题。
Python数据结构与算法实战
"Python数据结构与算法，北京大学某学院课程，涵盖了Python编程、数据结构和算法的详细讲解，包括算法分析、基本数据结构类型、递归等核心概念。" 本资源详细介绍了Python语言在数据结构与算法领域的应用，旨在帮助...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

LIY若依

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值