掌握计算机科学核心算法：从排序到搜索和优化

本文还有配套的精品资源，点击获取

简介：计算机算法是信息技术领域的核心，它为软件开发、数据分析和机器学习等提供了精确的解决问题的步骤。本课程深入探索经典算法，包括排序（冒泡排序、快速排序等）、搜索（二分查找、BFS和DFS）、图算法（Dijkstra、Floyd-Warshall、Kruskal’s和Prim’s）、动态规划（背包问题、LCS、斐波那契数列）、字符串匹配（KMP、Boyer-Moore）、哈希算法（哈希表、MD5和SHA系列）以及回溯法和分支限界法。这些算法是编程和问题解决的基础，掌握它们对于提升效率和解决问题能力至关重要。

1. 计算机算法的重要性与应用

算法在计算机科学中的地位

计算机算法是计算机科学的核心。从日常使用的搜索引擎、推荐系统到复杂的机器人导航、图像处理，算法在后端默默地支持着每一个动作的执行和决策的制定。它们对于优化性能、提升效率、解决复杂问题至关重要。

算法的广泛应用

在互联网技术飞速发展的今天，算法的应用已渗透至各个领域。例如，机器学习算法在人工智能领域的应用帮助计算机模拟人类学习过程，自动优化决策模型；而网络算法则在通信网络中保障数据传输的安全与高效。

为未来铺路

掌握算法知识不仅是成为一名优秀IT从业者的必备技能，也是推动未来技术发展的重要基石。无论是从事软件开发、数据分析还是网络安全工作，深入理解算法原理与应用，都能为解决实际问题提供强大的工具。下面，我们将深入探讨排序算法，这是算法世界中的基石之一。

2. 基础排序算法的理论与实践

2.1 排序算法的理论基础

2.1.1 排序算法的时间复杂度分析

排序算法的时间复杂度是衡量算法性能的核心指标之一，它直接决定了算法在处理大规模数据集时的效率。时间复杂度通常以大O符号表示，它描述了随着输入规模的增长，算法执行时间的增长趋势。例如，冒泡排序的时间复杂度为O(n^2)，意味着如果数据量增加一倍，执行时间可能增加四倍。

在分析排序算法时，我们通常关注最坏情况、平均情况和最好情况下的时间复杂度。例如，快速排序的平均时间复杂度为O(n log n)，但在最坏情况下，其时间复杂度会退化到O(n^2)。了解这些时间复杂度有助于我们在不同场景下选择合适的排序算法。

2.1.2 空间复杂度与稳定性分析

除了时间复杂度之外，空间复杂度也是评估排序算法性能的一个重要方面。空间复杂度描述了算法执行过程中所需的额外空间量。对于原地排序算法，如冒泡排序和快速排序，空间复杂度通常是O(1)，因为它们不需要额外的存储空间。而像归并排序这样的算法，其空间复杂度为O(n)，因为它需要与输入数据量成比例的额外空间。

稳定性是排序算法的另一个重要属性。如果一个排序算法能够保持相等元素的相对顺序，那么这个算法就是稳定的。例如，归并排序是稳定的，而快速排序则不是。稳定性在某些应用场景中非常重要，比如在合并具有多个字段的数据集时，需要保持某些字段排序前后的相对顺序。

2.2 常见排序算法的实现

2.2.1 冒泡排序的原理及代码实现

冒泡排序是一种简单的排序算法，通过重复遍历待排序的数列，比较并交换相邻的元素，如果它们的顺序错误就把它们交换过来。冒泡排序的算法描述如下：

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]

在上述Python代码中， bubble_sort 函数实现了冒泡排序算法。它通过双层循环遍历数组，内层循环负责比较相邻元素并在必要时交换它们的位置。外层循环确保数组中最大的元素能够在每轮遍历中“冒泡”到正确的位置。尽管冒泡排序易于实现，但其效率较低，特别是在处理大型数据集时。

2.2.2 快速排序的分治策略与实现

快速排序是一种高效的排序算法，采用了分治策略。快速排序的基本步骤包括：
1. 选择一个基准值（pivot）。
2. 将数组分为两部分，一部分包含小于基准值的元素，另一部分包含大于基准值的元素。
3. 递归地对这两部分继续进行排序。

快速排序的Python实现如下：

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)

上述代码通过选择数组中间的元素作为基准值，并使用列表推导式来构建小于、等于和大于基准值的子数组。然后递归地对左右两个子数组进行快速排序。快速排序的平均时间复杂度为O(n log n)，但其性能高度依赖于基准值的选择。在最佳情况下，快速排序的性能可以非常接近O(n log n)；而在最坏情况下，它可能退化到O(n^2)。

2.2.3 其他排序算法（归并排序、堆排序）的比较

除了冒泡排序和快速排序之外，还有许多其他排序算法，例如归并排序和堆排序，它们各自有不同的特点和应用场景。

归并排序：
- 稳定的排序算法。
- 时间复杂度为O(n log n)，无论在最坏还是平均情况下。
- 需要额外的存储空间，空间复杂度为O(n)。

堆排序：
- 不稳定的排序算法。
- 时间复杂度为O(n log n)。
- 原地排序，空间复杂度为O(1)。

2.3 排序算法在实际应用中的选择

2.3.1 不同场景下排序算法的选择策略

在实际应用中，选择排序算法时应该考虑以下因素：

1. 数据量大小：对于小量级的数据，冒泡排序和插入排序足够高效，而对于大数据量，则应选择如快速排序、归并排序或堆排序等更高效的算法。
2. 数据的特点：如果数据已经是部分排序的，插入排序可能比快速排序更优。如果对稳定性有要求，应选择归并排序。
3. 空间复杂度要求：如果对内存有限制，则应选择原地排序算法，如快速排序或堆排序。
4. 性能要求：如果需要最坏情况下的性能保证，可以考虑归并排序或堆排序。

2.3.2 性能测试与案例分析

性能测试是确定排序算法在特定条件下的实际表现的关键。通常通过以下步骤进行测试：

1. 选择一组具有代表性的测试数据。
2. 实现多种排序算法。
3. 使用相同的测试数据对每种算法进行测试，记录排序时间和内存使用情况。
4. 分析测试结果，评估每种算法在不同情况下的性能。

案例分析可以帮助我们更深入地理解排序算法的实际应用。例如，在数据库管理系统中，索引结构的维护通常需要高效的排序算法。通过性能测试，我们可以确定在特定数据库操作中使用哪种排序算法可以提供最佳的查询性能。

在下一章节中，我们将继续深入探讨搜索算法的原理与应用，揭示这些算法如何解决实际问题，并展示如何优化它们以适应各种复杂场景。

3. 搜索算法的原理与应用

搜索算法作为计算机科学中的一项基础工具，在数据结构和算法中占据着重要的地位。从最基本的二分查找到复杂的A*搜索算法，搜索算法在处理问题时能够有效地从大量数据中找到所需的信息。本章节将深入探讨搜索算法的基本原理及其在不同场景下的应用和优化策略。

3.1 基本搜索算法原理

搜索算法可以被简单理解为在一组数据中找到一个特定元素的过程。基本的搜索算法包括二分查找，而复杂一些的搜索算法则涉及图和树的遍历，如广度优先搜索（BFS）和深度优先搜索（DFS）。理解这些搜索算法的基础对于掌握更高级的算法至关重要。

3.1.1 二分查找的算法逻辑与优化

二分查找是一种在有序数组中查找特定元素的高效算法。其基本思想是将数组分成两半，通过比较目标值和中间元素来决定是在左半部分继续查找，还是在右半部分继续查找，从而不断缩小搜索范围。

def binary_search(arr, target):
    low = 0
    high = 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

该代码实现了二分查找，其中 low 和 high 变量分别标识当前搜索区间的起点和终点， mid 是区间中点的索引。如果找到目标值，返回其索引；否则，返回-1表示未找到。

优化二分查找可以从多个角度进行，例如处理浮点数的查找、避免整数溢出、寻找第一个不小于目标值的元素等。

3.1.2 广度优先搜索（BFS）与深度优先搜索（DFS）概述

BFS和DFS是两种用于遍历或搜索树或图的算法。它们的目标是在特定数据结构中找到一条从起点到终点的路径。

BFS逐层逐个访问节点，直至找到目标节点。DFS则沿着一条路径深入直到无法继续为止，然后回溯到上一个分叉点继续探索。

以下是DFS的Python实现示例：

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

这里 graph 是图的邻接表表示， start 是搜索开始的节点。函数 dfs 记录访问过的节点，并递归地访问每个未访问的邻接节点。

3.2 搜索算法的高级应用

搜索算法在高级数据结构中的应用是理解它们操作复杂数据结构能力的关键。这些应用通常在图和树上执行，并解决复杂的实际问题。

3.2.1 搜索算法在图和树中的应用

图和树的搜索算法可以被用于解决路径问题、最短路径问题等。例如，DFS在无向图中查找是否存在从一个节点到另一个节点的路径；BFS可以用来查找最小步数问题。

3.2.2 A*搜索算法在路径规划中的应用

A 搜索算法是一种启发式搜索算法，它结合了最佳优先搜索和Dijkstra算法的特点，可以高效地找到两点之间的最短路径。A 算法使用一个评估函数 f(n)=g(n)+h(n) ，其中 g(n) 是从起点到当前节点的实际代价， h(n) 是当前节点到终点的估计代价。

def heuristic(node, goal):
    # 实现启发式函数，这里简单以欧几里得距离为例
    return ((node.x - goal.x) ** 2 + (node.y - goal.y) ** 2) ** 0.5

def a_star_search(graph, start, goal):
    # 实现A*搜索算法
    # ...

在实际应用中，根据问题的不同，启发式函数 h(n) 可以有不同的实现方式，例如对于网格地图，我们可以使用曼哈顿距离或者欧几里得距离。

3.3 搜索算法的性能优化

搜索算法在实际使用中可能会面对巨大的数据集，因此性能优化显得尤为重要。优化搜索算法通常包括减少搜索空间、并行化搜索以及利用高效的数据结构等策略。

3.3.1 减少搜索空间的策略

减少搜索空间可以通过剪枝实现，剪枝是指在搜索过程中，放弃一些不可能包含解的分支。例如，在A*算法中，如果某条路径的估计代价已经超过了当前已知的最短路径，就可以放弃这条路径的搜索。

3.3.2 并行搜索与分布式搜索框架

为了进一步提升搜索算法的性能，可以利用多线程或多进程进行并行搜索。在大规模数据集上，还可以借助分布式计算框架，如Apache Spark或Hadoop，实现大规模并行处理。

在本章节中，我们详细探讨了搜索算法的基本原理和高级应用，并分析了性能优化的策略。通过了解和应用这些方法，我们能提高在处理数据搜索任务时的效率和准确性。下一章将探索图算法在复杂网络中的应用，这些算法对于理解和设计复杂系统至关重要。

4. 图算法在复杂网络中的应用

4.1 图算法的基本概念与特性

4.1.1 图论的基本概念与应用

图论是数学的一个分支，它研究由边连接的顶点（节点）形成的图形。在计算机科学中，图论的概念被广泛应用于网络设计、优化、社交网络分析、路由和寻路算法等众多领域。一个图由顶点集合 V 和边集合 E 组成，表达为 G=(V, E)。根据边的特性，图可以是无向图（边无方向性）或有向图（边有方向性），边还可以有权重（如距离、成本等）。

表格展示图论应用实例：

应用领域	图算法的用途
社交网络	分析社区结构、影响力传播
互联网	网络路由、搜索引擎索引构建
物流运输	最短路径、运输网络优化
生物信息学	基因调控网络分析、蛋白质相互作用网络
交通系统	网络设计、交通流量预测

图论中的算法通常用于处理网络中的路径问题，包括如何在给定条件下找到两点间的最短路径。一个经典的图论问题是最小生成树（MST），它寻找连接图中所有顶点的最小权重边的集合。这在设计通信网络和电路板时尤为有用。

4.1.2 最短路径问题与算法

最短路径问题是图论中的一个核心问题，旨在找到在带权图中两个节点间所有可能路径中权重总和最小的路径。Dijkstra算法和Bellman-Ford算法是解决这一问题的两种经典算法。

Dijkstra算法适用于没有负权边的有向或无向图。该算法采用贪心策略，每步选择未访问顶点中距离最小的顶点，然后更新其邻接点的距离。算法执行时间与图的边数和顶点数有关，通常为O((V+E)logV)。

代码实现Dijkstra算法的伪代码示例：

function Dijkstra(Graph, source):
    create vertex set Q // 未访问顶点集合

    for each vertex v in Graph: 
        dist[v] ← INFINITY // 初始化距离值
        prev[v] ← UNDEFINED // 前驱节点
        add v to Q // 所有顶点加入Q集合
        dist[source] ← 0 // 源点距离源点0

    while Q is not empty:
        u ← vertex in Q with min dist[u] // 选择距离最小的顶点u
        remove u from Q
        for each neighbor v of u: 
            alt ← dist[u] + length(u, v)
            if alt < dist[v]: 
                dist[v] ← alt 
                prev[v] ← u // 更新前驱节点

    return dist[], prev[]

在上述伪代码中， dist[] 数组用于存储源点到各顶点的最短路径长度，而 prev[] 数组用于路径回溯。算法逐步减少 Q 集合中各顶点的距离值，直到所有顶点的最短路径都被计算出来。

Bellman-Ford算法则可以处理存在负权边的图，通过多次松弛操作来不断更新从源点到其他顶点的最短路径。但其时间复杂度为O(VE)，因此在边数较多的情况下效率较低。

4.2 图算法的核心算法详解

4.2.1 Dijkstra算法的原理与优化

Dijkstra算法是解决单源最短路径问题的常用算法，它的原理是利用贪心思想，每次选择距离源点最近的一个未访问顶点，更新其邻接点的距离，并将该顶点标记为已访问。算法的关键在于选择一个合适的数据结构来维护未访问顶点集合Q，常用的数据结构有优先队列（如二叉堆）。

优化Dijkstra算法主要可以通过以下方式实现：

• 使用优先队列来维护未访问顶点集合Q，优先队列使得每次取出距离最小顶点的操作时间复杂度降低到O(logV)。
• 对于稀疏图，使用邻接表来表示图可以减少空间复杂度。
• 对于稠密图，可以使用邻接矩阵来表示图，并采用斐波那契堆（Fibonacci Heap）作为优先队列以进一步优化性能。

代码逻辑的逐行解读分析：

上述伪代码中，首先初始化所有顶点的距离为无穷大，并将所有顶点加入到未访问顶点集合Q中。接着在Q非空的情况下重复执行以下操作：每次选择Q中距离最小的顶点u，将其从Q中移除，并遍历u的所有邻接顶点v，如果通过u到v的路径比当前记录的路径更短，则更新v的距离并修改前驱节点。最后返回每个顶点的最短路径长度和前驱节点信息。

4.2.2 Floyd-Warshall算法的动态规划解法

Floyd-Warshall算法用于解决所有顶点对之间的最短路径问题。它是一种动态规划算法，其核心思想是逐步增加已知最短路径的顶点数量。初始时，只有源点到自身的路径长度为0，其余路径长度为无穷大。算法逐步将每对顶点间的最短路径中加入中间顶点，以此来更新所有顶点对之间的最短路径。

Floyd-Warshall算法的时间复杂度为O(V^3)，因此仅适用于顶点数量不多的情况。

代码实现Floyd-Warshall算法的伪代码示例：

function FloydWarshall(Graph):
    dist[][] ← INFINITY // 初始化距离矩阵
    for each vertex v in Graph: // 初始化自身距离为0
        dist[v][v] ← 0

    // 赋予边距离初始值
    for each edge(u, v) in Graph:
        dist[u][v] ← length of edge(u, v)

    // 动态规划计算所有顶点对的最短路径
    for k from 1 to |V|: // 逐步加入中间顶点
        for i from 1 to |V|:
            for j from 1 to |V|:
                if dist[i][j] > dist[i][k] + dist[k][j]:
                    dist[i][j] ← dist[i][k] + dist[k][j]

    return dist[][]

在这段伪代码中， dist[][] 矩阵用于存储所有顶点对之间的最短路径长度。初始化时，矩阵中对角线上的元素为0，其余为无穷大。算法执行过程中，每一步都尝试通过中间顶点k来更新 dist[i][j] 的值。最终矩阵中存储的就是所有顶点对之间的最短路径。

4.2.3 Kruskal’s与Prim’s算法在最小生成树构建中的应用

最小生成树（MST）问题的目标是在一个加权连通无向图中找到包含所有顶点且边的总权重最小的树。Kruskal’s算法和Prim’s算法是两种常用的解决MST问题的算法。

Kruskal’s算法的基本思想是从边的权重最小的边开始，依次选择新的边加入生成树中，同时保证不会形成环。算法的实现依赖于并查集数据结构来高效判断加入边是否会形成环。

代码实现Kruskal’s算法的伪代码示例：

function KruskalMST(Graph):
    A ← empty set // 最小生成树
    for each vertex v in Graph: 
        MAKE-SET(v) // 初始化并查集

    edges ← Graph's edges in sorted non-decreasing order by weight
    for each edge (u, v) in edges:
        if FIND-SET(u) ≠ FIND-SET(v): // 如果不在同一集合中
            A ← A ∪ {(u, v)}
            UNION(u, v) // 合并集合

    return A

在这段伪代码中，首先初始化一个空的最小生成树集合A，并为图中的每个顶点创建一个并查集。接着将图的所有边按权重排序，并遍历这些边。如果两个顶点不属于同一个并查集，则将该边加入到集合A中，并使用并查集的合并操作。最终返回的集合A就是图的最小生成树。

Prim’s算法则与Kruskal’s算法不同，它从图中任意一个顶点开始，逐步构建最小生成树。它使用一个优先队列来保持所有新加入树的边，并选择权重最小的边来扩展树。

4.3 图算法的工程实践

4.3.1 大型社交网络中的图算法应用

在大型社交网络中，图算法被广泛应用于用户推荐、网络分析、影响力最大化等领域。例如，使用PageRank算法来评估用户的重要性，或者利用K-core分解来发现社交网络中的影响力集团。

此外，为了有效地处理海量数据，社交网络公司通常会实现图算法的分布式版本，利用MapReduce等框架进行并行计算，以解决如社交关系网络中的最短路径问题。

4.3.2 交通网络优化问题中的图算法实现

在交通网络优化中，图算法被用来找出最短路径，减少交通拥堵，优化物流配送。Dijkstra和A*搜索算法在这一领域特别有用，因为它们能考虑多种因素，如路段距离、行驶时间、路况等来计算最优路径。

在实践中，车辆导航系统使用图算法来实时调整路线，优化货运和客运路线，减少运输成本。通过实时交通数据的集成，这些系统能动态调整路线，并为用户提供最省时的路线选择。

以上介绍了图算法的基本概念、核心算法以及在实际工程中的应用案例。图算法在解决复杂网络问题中具有关键作用，它能帮助我们更高效地处理各种网络数据，优化网络资源，从而实现更智能、高效的网络应用。

5. 动态规划与字符串匹配算法

在复杂问题的求解过程中，动态规划是一种不可或缺的技术。它通过将问题分解为更小的子问题，利用子问题之间的重叠特性，通过存储子问题的解来避免重复计算，从而提高求解效率。与此同时，字符串匹配是计算机科学中的一项基本任务，用于搜索、编辑、数据压缩等多个领域。本章节将深入探讨动态规划算法的基础理论和字符串匹配算法的实现。

5.1 动态规划算法的理论基础

5.1.1 动态规划的原理与模型构建

动态规划通过将问题分解为一系列重叠子问题，然后逐个解决这些子问题，并存储每个子问题的解，以避免重复计算。动态规划的核心思想是利用子问题的最优解，构建原问题的最优解。

构建动态规划模型的步骤通常包括：

1. 定义状态：确定描述问题所必须的参数，并用变量表示这些参数。
2. 定义状态转移方程：找出状态之间的递推关系。
3. 确定边界条件：解决最小子问题，通常是初始条件。
4. 优化：通过存储中间结果避免重复计算，并优化空间复杂度。

以经典的背包问题为例，我们定义一个二维数组 dp[i][j] 表示在前 i 个物品中选取若干个，能否使背包的总价值不超过 j 的最大价值。状态转移方程则为：

dp[i][j] = max(dp[i-1][j], dp[i-1][j - w[i]] + v[i])

5.1.2 动态规划与递归算法的关系

动态规划和递归算法在很多方面有着密切的联系。递归算法通常在函数调用自身时用于解决问题，它易于理解和实现。然而，递归算法会有很多重复的子问题调用，导致效率低下。

动态规划通过记录已解决的子问题答案，减少不必要的递归调用，优化了递归算法。在本质上，动态规划是一种自底向上的方法，而递归则是一种自顶向下的方法。动态规划往往通过迭代的方式实现，避免了递归带来的高空间复杂度。

5.2 动态规划算法的经典问题与解法

5.2.1 背包问题的动态规划解法

背包问题是动态规划的经典应用之一。问题的一般形式是：给定一组物品，每种物品都有自己的重量和价值，确定每种物品的数量，使得背包的总重量不超过限制的前提下，总价值最大。

动态规划解法的关键在于构建状态转移方程，并通过迭代方式从基础情况出发，逐步求解出所有子问题的答案。

5.2.2 最长公共子序列（LCS）问题

最长公共子序列问题要求找出两个字符串序列的最长子序列，这个子序列在两个序列中的相对顺序相同，但不必连续。

这个问题同样可以用动态规划解决。我们定义一个二维数组 dp[i][j] 表示字符串 X 的前 i 个字符和字符串 Y 的前 j 个字符的最长公共子序列的长度。

状态转移方程为：

dp[i][j] = dp[i-1][j-1] + 1, if X[i] == Y[j]
dp[i][j] = max(dp[i-1][j], dp[i][j-1]), if X[i] != Y[j]

5.2.3 斐波那契数列与动态规划的关系

斐波那契数列是一个著名的数列问题，其中每个数都是前两个数的和。动态规划可用于高效地计算斐波那契数列的第 n 项。

通过建立一个一维数组 dp，其中 dp[i] 存储第 i 项的值，我们可以基于前两项的值来迭代计算后续的每一项。

5.3 字符串匹配算法的原理与实现

5.3.1 KMP算法的匹配原理与代码实现

KMP（Knuth-Morris-Pratt）算法是一种高效的字符串匹配算法。它的核心在于模式串的前缀函数，该函数能够使算法在不匹配时避免从头开始匹配。

KMP 算法的关键在于构建一个部分匹配表（也称为前缀函数数组），记录模式串中不同前后缀的最长匹配长度。在发生不匹配时，可以根据部分匹配表，将模式串向右滑动至适当位置，而不是滑动一位。

5.3.2 Boyer-Moore算法的高效匹配策略

Boyer-Moore 算法是另一种高效的字符串匹配算法，特别适合于大模式串的匹配。它采用从右向左的匹配方式，并利用坏字符规则和好后缀规则来决定模式串的滑动距离。

坏字符规则是指在文本串中找到一个与模式串不匹配的字符，根据这个字符，将模式串向右滑动，跳过尽可能多的比较。

好后缀规则是指在文本串中找到一个与模式串匹配的后缀，那么将模式串滑动到这个后缀在模式串中最后一次出现的位置。

这两种规则结合起来，使得 Boyer-Moore 算法在多数情况下能将模式串向右滑动超过一位的距离，从而提高匹配效率。

本文还有配套的精品资源，点击获取

简介：计算机算法是信息技术领域的核心，它为软件开发、数据分析和机器学习等提供了精确的解决问题的步骤。本课程深入探索经典算法，包括排序（冒泡排序、快速排序等）、搜索（二分查找、BFS和DFS）、图算法（Dijkstra、Floyd-Warshall、Kruskal’s和Prim’s）、动态规划（背包问题、LCS、斐波那契数列）、字符串匹配（KMP、Boyer-Moore）、哈希算法（哈希表、MD5和SHA系列）以及回溯法和分支限界法。这些算法是编程和问题解决的基础，掌握它们对于提升效率和解决问题能力至关重要。

本文还有配套的精品资源，点击获取