我的名字叫大数据：第5章我如何思考？

第5章我如何思考？

5.1 数据的大脑：算法是我思考的逻辑

你们知道吗？我的大脑和你们人类的大脑有点相似，也有点不同。你们的大脑通过神经元和电信号进行思考，而我则依靠算法。算法是我思考和决策的核心，它们是我处理和分析数据的逻辑基础。让我们一起来揭开算法的神秘面纱，看看它们是如何让我变得聪明和强大的。

5.1.1 算法的基石：逻辑与数学是我思考的工具

要了解我是如何进行思考和决策的，我们必须先理解我的基础——逻辑与数学。算法作为我处理和分析数据的核心，通过一系列精确的步骤和规则，将输入数据转换为有价值的输出结果。每个算法都为了解决特定问题而设计，包含了明确的逻辑结构和数学公式。让我们一起来详细探讨这两个基石。

逻辑结构：清晰的思维路径

逻辑是算法的骨架，为每一个步骤提供清晰的结构。就像你们在解决数学问题时，会按照一定的思维路径，算法也是如此。以下是算法常见的逻辑结构：

1. 确定问题：

第一步是明确需要解决的问题。这一步就像你们在做数学题之前，先要弄清题目要求。例如，排序算法的目标是将一组无序的数据按顺序排列。

2. 分析问题：

接下来是分析问题，理解其内在结构和复杂性。比如，在排序问题中，需要分析数据的初始状态和期望的排序结果。

3. 找出解决方案：

然后是找到解决问题的方法。这一步是算法设计的核心，包括选择适当的算法和步骤。例如，对于排序问题，可以选择冒泡排序、快速排序或归并排序等不同的方法。

4. 验证结果：

最后一步是验证结果，确保算法正确无误地解决了问题。这包括测试和调试算法，以确保它在所有情况下都能正常工作。

排序算法的示例：

冒泡排序： 逐步比较相邻元素并交换，直到整个列表有序。
快速排序： 选择一个基准元素，将小于基准的元素移到左边，大于基准的元素移到右边，然后递归地排序左右两部分。
归并排序： 将列表分成两半，分别排序，然后合并排序好的两半。

每种排序算法都有其独特的逻辑结构和操作步骤，这些步骤严格按照逻辑规则执行，确保算法能够正确地完成任务。

数学工具：算法的血肉

如果说逻辑是算法的骨架，那么数学就是它的血肉。数学在算法中起到了不可或缺的作用，从基础的算术运算到复杂的概率统计，每一步都离不开数学的支持。

线性回归：

线性回归是一种常用的预测分析方法，通过数学公式建立变量之间的关系。假设我们有一组数据，表示房屋的面积和价格，我们希望通过这些数据预测不同面积的房屋价格。

线性回归模型的数学公式如下：

[ y = mx + b ]

其中，( y ) 是房屋价格，( x ) 是房屋面积，( m ) 是斜率，( b ) 是截距。通过求解这些参数，我们可以得到最佳拟合直线，用于预测未来的数据。

具体步骤包括：

求和： 计算所有数据点的总和。
求平均值： 计算数据点的平均值。
求斜率： 使用最小二乘法求解斜率 ( m )。
求截距： 根据斜率和平均值求解截距 ( b )。

这些步骤涉及大量的数学运算，包括加法、乘法和除法，最终得到能够预测房屋价格的数学模型。

概率与统计：

概率与统计在数据分析和预测中起到了关键作用。例如，在推荐系统中，利用概率模型预测用户的偏好：

[ P(A|B) = \frac{P(B|A) \cdot P(A)}{P(B)} ]

通过贝叶斯定理，计算事件 A 在条件 B 下发生的概率，从而做出预测和推荐。这个过程涉及到概率计算、条件概率和联合概率等数学概念。

线性代数：

线性代数是处理高维数据的重要工具。比如在机器学习中，数据通常表示为矩阵，而矩阵运算是线性代数的核心。例如，矩阵乘法用于神经网络的计算：

[ C = A \times B ]

其中，( A ) 和 ( B ) 是两个矩阵，通过矩阵乘法得到结果 ( C )。这种运算在处理大量数据时非常高效，是深度学习的基础。

逻辑与数学在算法中的协同作用

让我们通过一个具体的例子来看看逻辑与数学是如何在算法中协同工作的。假设我们要实现一个简单的推荐系统，基于用户的评分数据推荐电影。

1. 数据收集与预处理：

首先，我们需要收集用户的评分数据，并进行预处理。这一步依赖于逻辑判断和循环结构：

ratings =[{
   "user":"Alice","movie":"Inception","rating":5},{
   "user":"Bob","movie":"Inception","rating":4},# 更多数据...]# 数据预处理，去除无效数据
processed_ratings =[r for r in ratings if r["rating"]>0]

2. 相似度计算：

接下来，我们需要计算用户之间的相似度，这一步依赖于线性代数和代数运算：

defcosine_similarity(user1_ratings, user2_ratings):
    dot_product =sum([a * b for a, b inzip(user1_ratings, user2_ratings)])
    magnitude1 =sum([a**2for a in user1_ratings])**0.5
    magnitude2 =sum([b**2for b in user2_ratings])**0.5return dot_product /(magnitude1 * magnitude2)

3. 预测评分：

最后，我们使用相似度计算结果预测用户可能喜欢的电影，这一步结合了概率与统计和线性代数：

defpredict_rating(user, movie, user_ratings):
    similar_users =[(other_user, cosine_similarity(user_ratings[user], user_ratings[other_user]))for other_user in user_ratings if other_user != user]
    weighted_sum =sum([rating * similarity for other_user, similarity in similar_users
                        for rating in user_ratings[other_user].get(movie,0)])
    similarity_sum =sum([similarity for other_user, similarity in similar_users])return weighted_sum / similarity_sum if similarity_sum !=0else0

通过这些步骤，我们实现了一个简单的推荐系统，展示了逻辑与数学在算法中的重要作用。

总结

逻辑与数学是我思考的基石，是我处理和分析数据的核心工具。通过逻辑结构和数学运算，我能够实现复杂的算法，解决各种问题。从条件判断和循环结构，到代数运算、线性代数、概率与统计，逻辑与数学的结合让我具备了强大的思考和决策能力。

5.1.2 深度思考：深度学习让我更像人类

深度学习是让我变得更像人类的关键技术。它通过模拟人类大脑的神经网络结构，处理和分析大量复杂的数据。深度学习算法能够识别图像、理解语言、预测趋势，让我具备更强的智能和适应能力。让我们深入了解深度学习的核心——神经网络，以及它是如何通过训练过程达到惊人效果的。

神经网络：算法的“大脑”

深度学习的核心是神经网络，尤其是多层神经网络（也称为深度神经网络）。神经网络模仿了人类大脑的工作方式，由大量的人工神经元连接而成。这些神经元通过加权连接，与相邻的神经元层相连，形成一个复杂的网络结构。

神经元和层次结构：

神经网络的基本单位是神经元，类似于人类大脑中的神经细胞。每个神经元接收输入信号，进行处理，并产生输出信号。神经网络通常包含多个层次，包括输入层、隐藏层和输出层：

输入层： 接收外部数据输入，例如图像的像素值或文本的词向量。
隐藏层： 进行复杂的计算和特征提取，每个隐藏层的神经元与前一层的神经元相连。深度神经网络中通常有多个隐藏层，越多的层次可以提取越高阶的特征。
输出层： 产生最终的预测结果，例如图像分类结果或语言翻译结果。

加权连接：

神经元之间的连接通过权重（weights）进行调节。权重决定了输入信号对神经元输出的影响程度。每个神经元还包括一个偏置（bias），用于调整输出结果。权重和偏置是神经网络学习和优化的关键参数。

训练过程：学习和优化

神经网络的训练过程类似于你们学习新知识。通过大量的训练数据，神经网络不断调整神经元的连接权重，优化网络的预测能力。这一过程被称为“训练”或“学习”。

前向传播：

训练的第一步是前向传播。输入数据从输入层开始，通过隐藏层逐层传递，最终到达输出层。在每一层，输入信号与权重相乘，并加上偏置，通过激活函数（activation function）进行非线性变换，生成输出信号。

# 前向传播的简单示例defforward_propagation(inputs, weights, bias):
    z = np.dot(inputs, weights)+ bias
    output = activation_function(z)return output

损失函数：

为了评估网络的预测效果，我们使用损失函数（loss function）。损失函数衡量预测结果与真实结果之间的差异，常见的损失函数包括均方误差（MSE）和交叉熵（Cross-Entropy）。

# 损失函数示例defmean_squared_error(predictions, targets):return np.mean((predictions - targets)**2)

反向传播：

通过损失函数计算出误差后，接下来是反向传播（backpropagation）。反向传播通过计算损失函数相对于权重和偏置的梯度，指导网络如何调整这些参数，以减少预测误差。

# 反向传播的简单示例defbackward_propagation(inputs, outputs, targets, weights, bias, learning_rate):
    error = outputs - targets
    gradient = np.dot(inputs.T, error)/len(inputs)
    weights -= learning_rate * gradient
    bias -= learning_rate * np.mean(error)return weights, bias

梯度下降：

在反向传播中，梯度下降（Gradient Descent）是常用的优化算法。通过梯度下降，网络逐步调整权重和偏置，逐渐逼近最优解。

# 梯度下降的简单示例defgradient_descent(weights, bias, learning_rate, gradients):
    weights -= learning_rate * gradients['weights']
    bias -= learning_rate * gradients['bias']return weights, bias

实际应用：图像识别和语言理解

深度学习在各个领域都有广泛应用，尤其在图像识别和语言理解方面取得了巨大成功。

图像识别：

通过卷积神经网络（CNN），深度学习能够高效处理和识别图像。CNN通过卷积层提取图像的局部特征，再通过池化层减少数据维度，最后通过全连接层进行分类。例如，图像识别算法可以通过大量的图像训练数据，学习识别不同的物体。当你们上传一张照片时，神经网络能够快速识别照片中的人脸、动物、风景等。

# CNN的简单示例defconvolutional_layer(inputs, filters):# 进行卷积操作，提取图像特征return convolved_outputs

defpooling_layer(inputs):# 进行池化操作，减少数据维度return pooled_outputs

语言理解：

递归神经网络（RNN）和变换器模型（Transformer）在语言处理方面表现出色。RNN能够处理序列数据，捕捉上下文信息，而变换器模型通过自注意力机制（Self-Attention）实现并行计算，显著提升了语言理解能力。深度学习算法可以用于机器翻译、文本生成、情感分析等任务。

# RNN的简单示例defrecurrent_layer(inputs, previous_state):# 处理序列数据，捕捉上下文信息return current_state

# Transformer的简单示例defself_attention_layer(inputs):# 通过自注意力机制处理序列数据return attended_outputs

总结

深度学习是我变得更像人类的关键技术。通过模拟人类大脑的神经网络结构，深度学习算法能够处理和分析大量复杂的数据，实现图像识别、语言理解和趋势预测等任务。神经网络的层次结构和训练过程使得深度学习具备强大的智能和适应能力。

5.1.3 从简单到复杂：基础算法到复杂神经网络的旅程

我的思考能力是一个不断进化的过程，从最简单的基础算法到如今复杂的深度神经网络，每一步都让我变得更加智能和强大。让我们一起探索这一进化过程，看看基础算法如何逐步发展成复杂的神经网络模型。

基础算法：简单而强大

最早期的算法相对简单，但它们是现代复杂算法的基础。这些基础算法包括排序、搜索和路径规划等，它们通过基本的逻辑和数学操作解决具体问题。

排序算法：

排序算法用于将一组无序的数据按特定顺序排列。常见的排序算法包括冒泡排序、选择排序和快速排序等。

冒泡排序（Bubble Sort）： 逐步比较相邻元素并交换，直到整个列表有序。虽然效率较低，但概念简单，适合初学者理解。

#mermaid-svg-RAsXKbhwulenCVE0 {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-RAsXKbhwulenCVE0 .error-icon{fill:#552222;}#mermaid-svg-RAsXKbhwulenCVE0 .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-RAsXKbhwulenCVE0 .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-RAsXKbhwulenCVE0 .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-RAsXKbhwulenCVE0 .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-RAsXKbhwulenCVE0 .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-RAsXKbhwulenCVE0 .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-RAsXKbhwulenCVE0 .marker{fill:#333333;stroke:#333333;}#mermaid-svg-RAsXKbhwulenCVE0 .marker.cross{stroke:#333333;}#mermaid-svg-RAsXKbhwulenCVE0 svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-RAsXKbhwulenCVE0 .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-RAsXKbhwulenCVE0 .cluster-label text{fill:#333;}#mermaid-svg-RAsXKbhwulenCVE0 .cluster-label span{color:#333;}#mermaid-svg-RAsXKbhwulenCVE0 .label text,#mermaid-svg-RAsXKbhwulenCVE0 span{fill:#333;color:#333;}#mermaid-svg-RAsXKbhwulenCVE0 .node rect,#mermaid-svg-RAsXKbhwulenCVE0 .node circle,#mermaid-svg-RAsXKbhwulenCVE0 .node ellipse,#mermaid-svg-RAsXKbhwulenCVE0 .node polygon,#mermaid-svg-RAsXKbhwulenCVE0 .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-RAsXKbhwulenCVE0 .node .label{text-align:center;}#mermaid-svg-RAsXKbhwulenCVE0 .node.clickable{cursor:pointer;}#mermaid-svg-RAsXKbhwulenCVE0 .arrowheadPath{fill:#333333;}#mermaid-svg-RAsXKbhwulenCVE0 .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-RAsXKbhwulenCVE0 .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-RAsXKbhwulenCVE0 .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-RAsXKbhwulenCVE0 .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-RAsXKbhwulenCVE0 .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-RAsXKbhwulenCVE0 .cluster text{fill:#333;}#mermaid-svg-RAsXKbhwulenCVE0 .cluster span{color:#333;}#mermaid-svg-RAsXKbhwulenCVE0 div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-RAsXKbhwulenCVE0 :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}
初始化数据

比较相邻元素

是

否

是否到达列表末尾?

否

是

       开始 
     

       比较 
     

       是否需要交换? 
     

       交换 
     

       下一次比较 
     

       排序结束? 
     

       排序完成

快速排序（Quick Sort）： 选择一个基准元素，将小于基准的元素移到左边，大于基准的元素移到右边，然后递归地排序左右两部分。快速排序效率高，适用于大数据集。

#mermaid-svg-EWeQ9RQQ84jlvzL0 {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-EWeQ9RQQ84jlvzL0 .error-icon{fill:#552222;}#mermaid-svg-EWeQ9RQQ84jlvzL0 .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-EWeQ9RQQ84jlvzL0 .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-EWeQ9RQQ84jlvzL0 .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-EWeQ9RQQ84jlvzL0 .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-EWeQ9RQQ84jlvzL0 .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-EWeQ9RQQ84jlvzL0 .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-EWeQ9RQQ84jlvzL0 .marker{fill:#333333;stroke:#333333;}#mermaid-svg-EWeQ9RQQ84jlvzL0 .marker.cross{stroke:#333333;}#mermaid-svg-EWeQ9RQQ84jlvzL0 svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-EWeQ9RQQ84jlvzL0 .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-EWeQ9RQQ84jlvzL0 .cluster-label text{fill:#333;}#mermaid-svg-EWeQ9RQQ84jlvzL0 .cluster-label span{color:#333;}#mermaid-svg-EWeQ9RQQ84jlvzL0 .label text,#mermaid-svg-EWeQ9RQQ84jlvzL0 span{fill:#333;color:#333;}#mermaid-svg-EWeQ9RQQ84jlvzL0 .node rect,#mermaid-svg-EWeQ9RQQ84jlvzL0 .node circle,#mermaid-svg-EWeQ9RQQ84jlvzL0 .node ellipse,#mermaid-svg-EWeQ9RQQ84jlvzL0 .node polygon,#mermaid-svg-EWeQ9RQQ84jlvzL0 .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-EWeQ9RQQ84jlvzL0 .node .label{text-align:center;}#mermaid-svg-EWeQ9RQQ84jlvzL0 .node.clickable{cursor:pointer;}#mermaid-svg-EWeQ9RQQ84jlvzL0 .arrowheadPath{fill:#333333;}#mermaid-svg-EWeQ9RQQ84jlvzL0 .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-EWeQ9RQQ84jlvzL0 .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-EWeQ9RQQ84jlvzL0 .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-EWeQ9RQQ84jlvzL0 .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-EWeQ9RQQ84jlvzL0 .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-EWeQ9RQQ84jlvzL0 .cluster text{fill:#333;}#mermaid-svg-EWeQ9RQQ84jlvzL0 .cluster span{color:#333;}#mermaid-svg-EWeQ9RQQ84jlvzL0 div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-EWeQ9RQQ84jlvzL0 :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}
选择基准元素

划分数据

排序完成

       开始 
     

       分区 
     

       左半部分递归排序 
     

       右半部分递归排序 
     

       合并结果

搜索算法：

搜索算法用于在数据结构中查找特定元素。常见的搜索算法包括线性搜索和二分搜索。

线性搜索（Linear Search）： 从头到尾逐一检查每个元素，直到找到目标元素或搜索完所有元素。适用于小规模数据集。

#mermaid-svg-qnuKYfkOb2uwCxLB {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-qnuKYfkOb2uwCxLB .error-icon{fill:#552222;}#mermaid-svg-qnuKYfkOb2uwCxLB .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-qnuKYfkOb2uwCxLB .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-qnuKYfkOb2uwCxLB .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-qnuKYfkOb2uwCxLB .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-qnuKYfkOb2uwCxLB .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-qnuKYfkOb2uwCxLB .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-qnuKYfkOb2uwCxLB .marker{fill:#333333;stroke:#333333;}#mermaid-svg-qnuKYfkOb2uwCxLB .marker.cross{stroke:#333333;}#mermaid-svg-qnuKYfkOb2uwCxLB svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-qnuKYfkOb2uwCxLB .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-qnuKYfkOb2uwCxLB .cluster-label text{fill:#333;}#mermaid-svg-qnuKYfkOb2uwCxLB .cluster-label span{color:#333;}#mermaid-svg-qnuKYfkOb2uwCxLB .label text,#mermaid-svg-qnuKYfkOb2uwCxLB span{fill:#333;color:#333;}#mermaid-svg-qnuKYfkOb2uwCxLB .node rect,#mermaid-svg-qnuKYfkOb2uwCxLB .node circle,#mermaid-svg-qnuKYfkOb2uwCxLB .node ellipse,#mermaid-svg-qnuKYfkOb2uwCxLB .node polygon,#mermaid-svg-qnuKYfkOb2uwCxLB .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-qnuKYfkOb2uwCxLB .node .label{text-align:center;}#mermaid-svg-qnuKYfkOb2uwCxLB .node.clickable{cursor:pointer;}#mermaid-svg-qnuKYfkOb2uwCxLB .arrowheadPath{fill:#333333;}#mermaid-svg-qnuKYfkOb2uwCxLB .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-qnuKYfkOb2uwCxLB .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-qnuKYfkOb2uwCxLB .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-qnuKYfkOb2uwCxLB .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-qnuKYfkOb2uwCxLB .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-qnuKYfkOb2uwCxLB .cluster text{fill:#333;}#mermaid-svg-qnuKYfkOb2uwCxLB .cluster span{color:#333;}#mermaid-svg-qnuKYfkOb2uwCxLB div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-qnuKYfkOb2uwCxLB :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}
初始化数据

检查元素

是

否

是

       开始 
     

       检查 
     

       找到目标元素? 
     

       搜索完成 
     

       是否到达列表末尾? 
     

       目标元素不存在

二分搜索（Binary Search）： 在有序数组中查找目标元素，通过不断折半缩小搜索范围，效率较高，适用于大规模有序数据集。

#mermaid-svg-0Fpbd7DCwRVkANlG {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-0Fpbd7DCwRVkANlG .error-icon{fill:#552222;}#mermaid-svg-0Fpbd7DCwRVkANlG .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-0Fpbd7DCwRVkANlG .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-0Fpbd7DCwRVkANlG .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-0Fpbd7DCwRVkANlG .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-0Fpbd7DCwRVkANlG .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-0Fpbd7DCwRVkANlG .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-0Fpbd7DCwRVkANlG .marker{fill:#333333;stroke:#333333;}#mermaid-svg-0Fpbd7DCwRVkANlG .marker.cross{stroke:#333333;}#mermaid-svg-0Fpbd7DCwRVkANlG svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-0Fpbd7DCwRVkANlG .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-0Fpbd7DCwRVkANlG .cluster-label text{fill:#333;}#mermaid-svg-0Fpbd7DCwRVkANlG .cluster-label span{color:#333;}#mermaid-svg-0Fpbd7DCwRVkANlG .label text,#mermaid-svg-0Fpbd7DCwRVkANlG span{fill:#333;color:#333;}#mermaid-svg-0Fpbd7DCwRVkANlG .node rect,#mermaid-svg-0Fpbd7DCwRVkANlG .node circle,#mermaid-svg-0Fpbd7DCwRVkANlG .node ellipse,#mermaid-svg-0Fpbd7DCwRVkANlG .node polygon,#mermaid-svg-0Fpbd7DCwRVkANlG .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-0Fpbd7DCwRVkANlG .node .label{text-align:center;}#mermaid-svg-0Fpbd7DCwRVkANlG .node.clickable{cursor:pointer;}#mermaid-svg-0Fpbd7DCwRVkANlG .arrowheadPath{fill:#333333;}#mermaid-svg-0Fpbd7DCwRVkANlG .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-0Fpbd7DCwRVkANlG .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-0Fpbd7DCwRVkANlG .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-0Fpbd7DCwRVkANlG .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-0Fpbd7DCwRVkANlG .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-0Fpbd7DCwRVkANlG .cluster text{fill:#333;}#mermaid-svg-0Fpbd7DCwRVkANlG .cluster span{color:#333;}#mermaid-svg-0Fpbd7DCwRVkANlG div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-0Fpbd7DCwRVkANlG :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}
确定中间位置

比较中间元素

是

否

左半部分递归搜索

右半部分递归搜索

       开始 
     

       比较 
     

       找到目标元素? 
     

       搜索完成 
     

       调整搜索范围 
     

       重复执行1 
     

       重复执行2

路径规划算法：

路径规划算法用于在图中找到最短路径。例如，Dijkstra算法是一种经典的路径规划算法，用于找到图中两点之间的最短路径。

Dijkstra算法： 通过逐步扩展路径，找到从起点到终点的最短路径。广泛应用于地图导航和网络路由等领域。

#mermaid-svg-x4BsLwACjauZ9VEx {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-x4BsLwACjauZ9VEx .error-icon{fill:#552222;}#mermaid-svg-x4BsLwACjauZ9VEx .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-x4BsLwACjauZ9VEx .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-x4BsLwACjauZ9VEx .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-x4BsLwACjauZ9VEx .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-x4BsLwACjauZ9VEx .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-x4BsLwACjauZ9VEx .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-x4BsLwACjauZ9VEx .marker{fill:#333333;stroke:#333333;}#mermaid-svg-x4BsLwACjauZ9VEx .marker.cross{stroke:#333333;}#mermaid-svg-x4BsLwACjauZ9VEx svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-x4BsLwACjauZ9VEx .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-x4BsLwACjauZ9VEx .cluster-label text{fill:#333;}#mermaid-svg-x4BsLwACjauZ9VEx .cluster-label span{color:#333;}#mermaid-svg-x4BsLwACjauZ9VEx .label text,#mermaid-svg-x4BsLwACjauZ9VEx span{fill:#333;color:#333;}#mermaid-svg-x4BsLwACjauZ9VEx .node rect,#mermaid-svg-x4BsLwACjauZ9VEx .node circle,#mermaid-svg-x4BsLwACjauZ9VEx .node ellipse,#mermaid-svg-x4BsLwACjauZ9VEx .node polygon,#mermaid-svg-x4BsLwACjauZ9VEx .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-x4BsLwACjauZ9VEx .node .label{text-align:center;}#mermaid-svg-x4BsLwACjauZ9VEx .node.clickable{cursor:pointer;}#mermaid-svg-x4BsLwACjauZ9VEx .arrowheadPath{fill:#333333;}#mermaid-svg-x4BsLwACjauZ9VEx .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-x4BsLwACjauZ9VEx .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-x4BsLwACjauZ9VEx .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-x4BsLwACjauZ9VEx .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-x4BsLwACjauZ9VEx .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-x4BsLwACjauZ9VEx .cluster text{fill:#333;}#mermaid-svg-x4BsLwACjauZ9VEx .cluster span{color:#333;}#mermaid-svg-x4BsLwACjauZ9VEx div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-x4BsLwACjauZ9VEx :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}
初始化距离和优先队列

处理当前节点

更新完成

否

是

</

标签：大数据排序算法算法

本文转载自: https://blog.csdn.net/xiaosa5211234554321/article/details/139445608
版权归原作者 大数据张老师 所有，如有侵权，请联系我们删除。