08.图算法C++（笔记）

已于 2025-04-14 09:22:33 修改
阅读量2.1k 收藏 29
点赞数 47
CC 4.0 BY-SA版权
分类专栏： C++与算法 文章标签： 笔记 c++ 算法
于 2024-11-24 20:14:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/springvil/article/details/144012473

文章目录

1.图的基本概念

图是由顶点集合及顶点间的关系组成的一种数据结构。

表示为 G = (V， E)。V代表的是顶点集合，E代表边集合

树也是一种特殊的图，这个图无环。

树关注的时节点存的值，图更关注的是顶点及边的权值。

权值：边中的附带的数据信息。

顶点和边：图中结点称为顶点，第i个顶点记作vi。两个顶点vi和vj相关联称作顶点vi和顶点vj之间有一条边，图中的第k条边记作ek，ek = (vi，vj)或<vi，vj>.

有向图和无向图

有向图 ：顶点对<x, y>是有序的，顶点对<x，y>称为顶点x到顶点y的一条边(弧)，<x, y>和<y, x>是两条不同的边。

在这里插入图片描述

无向图 ：顶点对(x, y)是无序的，顶点对(x,y)称为顶点x和顶点y相关联的一条边，这条边没有特定方向，(x, y)和(y，x)是同一条边。

在这里插入图片描述

完全图

在有n个顶点的无向图中，若有n * (n-1)/2条边，即任意两个顶点之间有且仅有一条边，则称此图为无向完全图；

在n个顶点的有向图中，若有n * (n-1)条边，即任意两个顶点之间有两条边，且仅这两条边方向相反，则称此图为有向完全图。

邻接顶点

无向图中：两个顶点U、V有一条边连接。成为U、V互为临界顶点。

有向图中：两个顶点U、V。若是U指向V，则称为U邻接到V，V邻接自顶点U。并称这条边与顶点U、V相关联。

顶点的度

顶点V的度指的是与它相关联的边的条数

特殊：

  1. 对于有向图，顶点的度等于该顶点的入度+出度。
    出度：从顶点出去的边的条数。
    入度：指向这个顶点的边数。
  2. 对于无向图：入度=出度=顶点的度

路径

从顶点U到顶点V的一组边称为路径。路径不止一条。

路径长度：对于不带权图为路径的边个数。带权图为路径所有边权值的和

最短路径：所有路径，路径长度最小的路径。

简单路径与回路：

  • 简单路径：路径上经过顶点不重复。
  • 回路：路径上经过的顶点有重复。

子图、连通图、强连通图

两张图A、B，若A的顶点时B的部分顶点，A的边是B的部分边，则称为A是B的子图。

连通图：无向图中，若顶点A、B存在路径，称为A、B连通。若图中的任意两点都是连通的，则称此图为连通图。

强连通图：有向图中，若图中的任意两点都是连通的（A指向B,且B指向A），则称此图为连通图。

生成树

无向图中一个连通图的最小连通子图称为生成树。（用最少的边把所有顶点连接起来）。n个顶点的连通图的生成树有n-1条边。

最小生成树：所有生成树中，路径长度最小的生成树。

2.图的存储结构

因为图中既有节点，又有边(节点与节点之间的关系)，因此，在图的存储中，只需要保存：节点和边的关系即可。

节点通过数组保存，边的关系通过下面的方式保存。

图的创建

可以通过输入的方式来创建，或者是通过文件的方式来读取。

这里采用手动添加边来创建图，方便测试。

邻接矩阵

邻接矩阵(二维数组)即是：先用一个数组将定点保存，然后采用矩阵来表示节点与节点之间的关系。

在这里插入图片描述

如果矩阵位置为0代表无关，位置为1代表连接。A对应的下标为0，D对应的下标为3。这里采用map映射的方式来建立顶点与顶点下标的关系。

容易得出：无向图为对称矩阵。

此外：如果这个图是带权图，则矩阵内的数据为所带权值。

邻接矩阵的存储方式的优点：

  1. 非常适合边比较多的情况。
  2. O(1)判断两个节点的连接关系。

不足：

  1. O(N)查找一个节点连接的所有边（N为节点个数）。
C++邻接矩阵创建图
#pragma once

#include <vector>
#include <map>
#include <iostream>

// v:顶点 w:权值 max_w:最大权值 Direction:判断图是有向图还是无向图

namespace matrix{
    //邻接矩阵保存边关系
    template<class v,class w,w max_w = INT_MAX,bool bDirection = false>
    class Graph{
    private:
        std::vector<v> m_vertexs;               // 顶点集合
        std::map<v,int> m_mapIndex;             // 顶点与下标的映射
        std::vector<std::vector<w>> m_matrix;   // 邻接矩阵
        //获取顶点下标
        size_t GetPointIndex(const v& point) const{
            typename std::map<v,int>::const_iterator ptr = m_mapIndex.find(point);
            if(ptr!= m_mapIndex.end())
                return ptr->second;
            else{
                throw std::invalid_argument("point not found");
                return -1;
            }
        }
    public:
        // 图的创建
        Graph(const std::vector<v>& points){
            m_vertexs.resize(points.size());
            for(size_t i = 0; i < points.size(); ++i){
                m_vertexs[i] = points[i];
                m_mapIndex[points[i]] = i;
            }

            m_matrix.resize(points.size());
            // 邻接矩阵
            for(int i = 0; i < m_matrix.size(); ++i){
                m_matrix[i].resize(points.size(),max_w);
            }
        }

        //添加边关系，输入两个点，以及这两个点连线边的权值
        void AddEdge(const v& src, const v& dest, const w& weight){
            size_t posSrc = GetPointIndex(src);
            size_t posDest = GetPointIndex(dest);
            //区分有向图和无向图
            m_matrix[posSrc][posDest] = weight;
            if(!bDirection){
                //无向图，添加两条边关系
                m_matrix[posDest][posSrc] = weight;
            }
        }
        
        void Print(){
            //打印顶点对应坐标
            for(size_t i = 0; i < m_vertexs.size(); ++i){
                std::cout << "[" << i << "]->" << m_vertexs[i] << std::endl;
                std::cout << std::endl;
            }

            //打印边
            std::cout << "  ";
            for(size_t i = 0; i < m_vertexs.size(); ++i){
                std::cout << m_vertexs[i] << " ";
            }
            std::cout << std::endl;

            //打印矩阵
            for(size_t i = 0; i < m_matrix.size(); ++i){
                std::cout << m_vertexs[i] << " ";
                for(size_t j = 0; j < m_matrix[i].size(); ++j){
                    if(m_matrix[i][j] == max_w){
                        std::cout << "*" << " ";
                    }
                    else{
                        std::cout << m_matrix[i][j] << " ";
                    }
                }
                std::cout << std::endl;
            }
        }
    };
}

#include "Graph.hpp"

using namespace std;

void TestGraph(){
    vector<char>points = {'A','B','C','D'};
    matrix::Graph<char,int,INT_MAX,true> graph(points);
    graph.AddEdge('A','B',1);
    graph.AddEdge('A','D',4);
    graph.AddEdge('B','D',2);
    graph.AddEdge('B','C',9);
    graph.AddEdge('C','D',8);
    graph.AddEdge('C','B',5);
    graph.AddEdge('C','A',3);
    graph.AddEdge('D','C',6);
    graph.Print();
}

int main(){
    TestGraph();
    return 0;
}

在这里插入图片描述

邻接表

使用数组表示顶点的集合，使用链表表示边的关系。

创建指针数组，自己连接的顶点挂在下面。同样的，对节点进行编号。

在这里插入图片描述

邻接表的优点：

  1. 适合保存稀疏的边关系。
  2. 适合查找一个顶点连接出的边

不足：

  1. 不适合确定两个顶点是否相连，判断权值。

注意：如果图是有向图，则如果使用邻接表存储边的关系，需要保存出边表和入边表。

C++邻接表创建图
#pragma once

#include <vector>
#include <map>
#include <iostream>

// v:顶点 w:权值 max_w:最大权值 Direction:判断图是有向图还是无向图

// 邻接表保存边关系
namespace link_table{
    template<class w>
    struct Edge{
        int detPos;
        int srcPos;
        w weight;
        Edge<w> *next;
        Edge(int _srcPos, int _detPos, const w& _weight)
            :detPos(_detPos),srcPos(_srcPos),weight(_weight),next(nullptr)
        {}
    };

    template<class v,class w,bool Direction = false>
    class Graph{
        typedef Edge<w> Edge;
    private:
        std::vector<v> m_vertexs;      // 顶点集合
        std::map<v,int> m_mapIndex;    // 顶点与下标的映射
        std::vector<Edge*> m_tables;    // 领接表
        // 获取顶点下标
        size_t GetPointIndex(const v& point) const{
            typename std::map<v,int>::const_iterator ptr = m_mapIndex.find(point);
            if(ptr!= m_mapIndex.end())
                return ptr->second;
            else{
                throw std::invalid_argument("point not found");
                return -1;
            }
        }
    public:
        //图的创建
        Graph(const std::vector<v>& points){
            m_vertexs.resize(points.size());
            for(size_t i = 0; i < points.size(); ++i){
                m_vertexs[i] = points[i];
                m_mapIndex[points[i]] = i;
            }
            m_tables.resize(points.size());
        }

        //添加边关系，输入两个点，以及这两个点连线边的权值
        void AddEdge(const v& src, const v& dest, const w& weight){
            size_t posSrc = GetPointIndex(src);
            size_t posDest = GetPointIndex(dest);

            Edge* pEdge = new Edge(posSrc,posDest,weight);
            //头插
            pEdge->next = m_tables[posSrc];
            m_tables[posSrc] = pEdge;

            if(!Direction){
                //无向图，添加两条边关系
                Edge* pEdge = new Edge(posDest,posSrc,weight);
                //头插
                pEdge->next = m_tables[posDest];
                m_tables[posDest] = pEdge;
            }
        }

        void Print(){
            //打印顶点对应坐标
            for(size_t i = 0; i < m_vertexs.size(); ++i){
                std::cout << "[" << i << "]->" << m_vertexs[i] << std::endl;
                std::cout << std::endl;
            }

            for(size_t i = 0; i < m_tables.size(); ++i){
                std::cout << m_vertexs[i] << "[" << i << "]:";
                Edge* pNode = m_tables[i];
                while(pNode!= nullptr){
                    std::cout << m_vertexs[pNode->detPos]
                    << "[" << pNode->detPos << "]"
                    << "(" << pNode->weight << ")" << " ";
                    pNode = pNode->next;
                }
                std::cout << "nullptr" << std::endl;
            }
        }
    };
}

void TestGraph2(){
    vector<char>points = {'A','B','C','D'};
    link_table::Graph<char,int,true> graph(points);
    graph.AddEdge('A','B',1);
    graph.AddEdge('A','D',4);
    graph.AddEdge('B','D',2);
    graph.AddEdge('B','C',9);
    graph.AddEdge('C','D',8);
    graph.AddEdge('C','B',5);
    graph.AddEdge('C','A',3);
    graph.AddEdge('D','C',6);
    graph.Print();
}

int main(){
    //TestGraph();
    TestGraph2();
    return 0;
}

在这里插入图片描述

3.图的遍历

广度优先遍历 BFS

广度优先队列：以某个顶点为起点，一层一层进行遍历。需要借助队列。

在这里插入图片描述

具体遍历方式与二叉树的层序遍历方式类似，不同的是要通过标记的方式防止节点的重复遍历。

namespace matrix{
    //邻接矩阵保存边关系
    template<class v,class w,w max_w = INT_MAX,bool Direction = false>
    class Graph{
    public:
        // 图的创建
        Graph(const std::vector<v>& points){
            m_vertexs.resize(points.size());
            for(size_t i = 0; i < points.size(); ++i){
                m_vertexs[i] = points[i];
                m_mapIndex[points[i]] = i;
            }

            m_matrix.resize(points.size());
            // 邻接矩阵
            for(int i = 0; i < m_matrix.size(); ++i){
                m_matrix[i].resize(points.size(),max_w);
            }
        }

        //添加边关系，输入两个点，以及这两个点连线边的权值
        void AddEdge(const v& src, const v& dest, const w& weight){
            size_t posSrc = GetPointIndex(src);
            size_t posDet = GetPointIndex(dest);
            //区分有向图和无向图
            m_matrix[posSrc][posDet] = weight;
            if(!Direction){
                //无向图，添加两条边关系
                m_matrix[posDet][posSrc] = weight;
            }
        }
        
        void Print(){
            //打印顶点对应坐标
            for(size_t i = 0; i < m_vertexs.size(); ++i){
                std::cout << "[" << i << "]->" << m_vertexs[i] << std::endl;
                std::cout << std::endl;
            }

            //打印边
            std::cout << "  ";
            for(size_t i = 0; i < m_vertexs.size(); ++i){
                std::cout << m_vertexs[i] << " ";
            }
            std::cout << std::endl;

            //打印矩阵
            for(size_t i = 0; i < m_matrix.size(); ++i){
                std::cout << m_vertexs[i] << " ";
                for(size_t j = 0; j < m_matrix[i].size(); ++j){
                    if(m_matrix[i][j] == max_w){
                        std::cout << "*" << " ";
                    }
                    else{
                        std::cout << m_matrix[i][j] << " ";
                    }
                }
                std::cout << std::endl;
            }
        }
        
        void BFS(const v& src){//传入起点
            size_t srcPos = GetPointIndex(src);
            std::queue<size_t> q;
            q.push(srcPos);
            //标记数组
            std::vector<bool> visited(m_vertexs.size(),false);
            visited[srcPos] = true;     //入队列标记
            int iLevelSize = 1;         //每层节点个数
            int iLevel = 1;             //层数
            while(!q.empty()){
                for(int i = 0; i < iLevelSize; ++i){
                    int iFront = q.front();
                    std::cout << iFront << ":" << m_vertexs[iFront] << " ";
                    q.pop();
                    //这个节点周围的节点入队
                    for(size_t i = 0; i < m_vertexs.size(); i++){
                        if(m_matrix[iFront][i]!= max_w && !visited[i])
                        {
                            // 入队时，标记已访问节点
                            q.push(i);
                            visited[i] = true;
                        }
                    }
                }
                iLevelSize = q.size();
                std::cout << "第" << iLevel++ << "层" << std::endl;
            }
            std::cout << std::endl;
        }
     private:
        std::vector<v> m_vertexs;               // 顶点集合
        std::map<v,int> m_mapIndex;             // 顶点与下标的映射
        std::vector<std::vector<w>> m_matrix;   // 邻接矩阵
        //获取顶点下标
        size_t GetPointIndex(const v& point) const{
            typename std::map<v,int>::const_iterator ptr = m_mapIndex.find(point);
            if(ptr!= m_mapIndex.end())
                return ptr->second;
            else{
                throw std::invalid_argument("point not found");
                return -1;
            }
        }
    };
}

// 邻接表保存边关系
namespace link_table{
    template<class w>
    struct Edge{
        int detPos;
        int srcPos;
        w weight;
        Edge<w> *next;
        Edge(int _srcPos, int _detPos, const w& _weight)
            :detPos(_detPos),srcPos(_srcPos),weight(_weight),next(nullptr)
        {}
    };

    template<class v,class w,bool Direction = false>
    class Graph{
        typedef Edge<w> Edge;
    public:
        //图的创建
        Graph(const std::vector<v>& points){
            m_vertexs.resize(points.size());
            for(size_t i = 0; i < points.size(); ++i){
                m_vertexs[i] = points[i];
                m_mapIndex[points[i]] = i;
            }
            m_tables.resize(points.size());
        }

        //添加边关系，输入两个点，以及这两个点连线边的权值
        void AddEdge(const v& src, const v& dest, const w& weight){
            size_t posSrc = GetPointIndex(src);
            size_t posDest = GetPointIndex(dest);

            Edge* pEdge = new Edge(posSrc,posDest,weight);
            //头插
            pEdge->next = m_tables[posSrc];
            m_tables[posSrc] = pEdge;

            if(!Direction){
                //无向图，添加两条边关系
                Edge* pEdge = new Edge(posDest,posSrc,weight);
                //头插
                pEdge->next = m_tables[posDest];
                m_tables[posDest] = pEdge;
            }
        }

        void Print(){
            //打印顶点对应坐标
            for(size_t i = 0; i < m_vertexs.size(); ++i){
                std::cout << "[" << i << "]->" << m_vertexs[i] << std::endl;
                std::cout << std::endl;
            }

            for(size_t i = 0; i < m_tables.size(); ++i){
                std::cout << m_vertexs[i] << "[" << i << "]:";
                Edge* pNode = m_tables[i];
最低0.47元/天 解锁文章

200万优质内容无限畅学
计算机流程图代表判断的是什么意思,算法流程图符号含义有哪些？用奇偶数判断算法流程图理解...
weixin_39990660的博客
07-26 6602
算法流程图是流程图的其中一种类型，指将解题方案完整而又正确的描述，并将其算法流程在以图示的形式表现。通常流程图中不同符号所代表的含义会有所区别， 因此制作算法流程图时对于流程图各图形符号含义的理解及运用至关重要。那么算法流程图符号含义有哪些？一、算法流程图有什么作用？算法流程图将具体的算法流程体现到流程图示中，使之更加直观清晰地表现出来，可以用来验证算法流程的逻辑性，并对其进行优化处理(增加必须且...
l流程图平行四边形_流程图里的形状符号的代表意义
weixin_32349577的博客
02-01 2万+
Axure里的流程图形状组件面板对于画流程图，是我们经常会遇到的问题。我们和程序工程师沟通，用再多的口水，也无法挑明的事情，画一张简明的流程图，就能很直白的说明关键问题。有时候你可能会懊恼，因为程序员的思维犹如计算机，你告诉他为什么没有用，你就告诉他该怎么做，是左是右，是0是1就好了。这个时候，产品经理需要的是理性思维，清晰的思路，如果你不清晰，工程师大多数会跟着你的思路乱做一团。所以多画几个流程...
【PTA】【数据结构与算法】图的基本概念
葑鈊丶
05-17 1万+
这里是从PTA平台整理的【图的基本概念】题目集
软件工程（名词解释2）
qq_46120670的博客
10-08 517
30　增量模型：增量模型是软件工程中的一种开发方法，它将系统划分为多个增量或阶段，每个增量都是通过完整的软件生命周期来完成的。每个增量都包含了部分的功能，并且在之后的增量中逐步完善和扩展，最终形成完整的系统。采用工程的概念、原理、技术和方法来开发与维护软件，把经过实践考验而证明正确的管理技术和当前能够得到的最好的技术方法结合起来，以经济地开发出高质量的软件并有效地维护它。32　快速原型模型：快速原型是快速建立起来的可以在计算机上运行的程序，它所能完成的功能往往是最终产品能完成的功能的一个子集。
11-通信图建模测试
代码欢乐豆
11-15 1324
我的答案:C正确答案:C知识点：1.0分我的答案:D正确答案:D知识点：1.0分我的答案:A正确答案:A知识点：1.0分我的答案:A正确答案:A知识点：1.0分我的答案:A正确答案:A知识点：1.0分我的答案:B正确答案:B知识点：1.0分我的答案:BCD正确答案:BCD知识点：2.0分我的答案:ABD正确答案:ABD知识点：2.0分我的答案:ABD正确答案:ABD知识点：2.0分我的答案:ABD正确答案:
20241014软考架构-------软考231-235答案解析
weixin_42678822的博客
10-14 603
解析：半监督学习介于监督学习与无监督学习之间，可以利用少量的标注样本和大量的未标识样本进行训练和分类，从而达到减少标注代价、提高学习能力的目的。半监督学习的应用场景包括分类和回归，算法包括一些常用监督学习算法的延伸，这些算法首先试图对未标识数据进行建模，在此基础上再对标识的数据进行预测。解析：按学习模式不同分为监督学习（需提供标注的样本集）、无监督学习（不需提供标注的样本集）、半监督学习（需提供少量标注的样本集）、强化学习（需反馈机制）。C．机器学习的常见算法还包括迁移学习、被动学习和演化学习。
C语言和C++Builder学习笔记.rar_C++笔记_c++学习笔记_c/C++_学习笔记_编程语言
09-20
【C语言和C++Builder学习笔记】 C语言和C++是两种广泛使用的编程语言，它们在软件开发领域占据着重要地位。C语言以其简洁、高效和底层操作能力著称，而C++则在C的基础上引入了面向对象编程，极大地扩展了其应用范围...
C++笔记.zip_C++_笔记
07-13
本资料"**C++笔记.zip**"提供了全面的C++学习资料，特别是针对C++初学者和进阶者的一份宝贵的资源集合。 **C++基础** C++的基础部分包括语法、变量、数据类型、运算符、流程控制等。C++支持基本的数据类型如int、...
蓝桥杯算法学习笔记C++B组
07-06
蓝桥杯算法学习笔记C++B组蓝桥杯算法学习笔记C++B组蓝桥杯算法学习笔记C++B组蓝桥杯算法学习笔记C++B组蓝桥杯算法学习笔记C++B组蓝桥杯算法学习笔记C++B组蓝桥杯算法学习笔记C++B组蓝桥杯算法学习笔记C++B组蓝桥杯...
千锋C++笔记.zip
08-18
《千锋C++笔记》是一份综合性的学习资料，涵盖了C++编程语言的基础到高级概念。这份笔记由知名教育机构“千锋”提供，旨在帮助初学者和有一定基础的程序员深入理解和掌握C++这一强大的系统级编程语言。下面将详细...
c++算法刷题笔记.pdf
11-24
C++算法刷题笔记 本资源摘要信息将对C++算法刷题笔记中提到的知识点进行总结和解释。 1. 动态规划（Dynamic Programming） 动态规划是一种解决复杂问题的方法，通过将原问题分解为相对简单的子问题，来解决原问题...
数据结构-图基础
06-18 947
判断题 1.用邻接矩阵法存储图，占用的存储空间数只与图中结点个数有关，而与边数无关。 T F 2.在任一有向图中，所有顶点的入度之和等于所有顶点的出度之和。 T F 3.无论是有向图还是无向图，其邻接矩阵表示都是唯一的。 T ...
第七章--图--基本概念-计算机17级（期末复习带详解版）
markconca的博客
11-16 2514
解析在下面，有问题欢迎各位大佬指正         解析： p1-1： 在顶点数n≥3的完全无向图中，没有度为1的节点 p1-2：  要记住 用邻接矩阵法存储图，占用的存储空间数只与图中结点个数有关，而与边数无关。 (1分) 用邻接表法存储图，占用的存储空间数既与图中结点个数有关，又与边数有关。 (1...
流程图-ChatGPT4o作答
最新发布
qq_46215223的博客
12-09 732
流程图是一种有效的工具，用于表示和传达过程、算法和系统的工作原理。通过标准化的符号，流程图使得复杂的系统或步骤更加清晰和易于理解。无论是在编程、项目管理、业务流程分析还是教育领域，流程图都起到了重要的作用。
数据结构-图
m0_63654706的博客
11-10 1万+
图
流程图里的形状符号的代表意义
Snail丶heart
07-31 9401
流程图里的形状符号的代表意义 有时候做件事情想要缕清思路，流程图是个不错的选择，因此我们需要知道一些关于流程图符号的标准意义 1. 流程图标准符号的意义2. 推荐使用的在线画图平台https://www.draw.io 因为是网页版，因此也无需关心跨平台的问题~
用流程图描述算法
热门推荐
从小白到架构师
07-18 5万+
课程导言 【前面了解了程序和算法的关系，知道了算法是解决问题的具体方法和步骤，也学会了用文字去描述算法。哪还有没有其它描述算法的方式呢？毕竟文字看起来比较费劲。流程图就是一种描述算法的图形化描述，用流程图可以清晰地描述出算法的思路和过程。通过本篇的学习，你将了解到如何用流程图来描述算法。】   流程图是算法的图形化描述。俗话说：一张图胜过千言万语，用流程图可以清晰地描述出算法的思路和过程。 ...
第七章-图-作业1-基本概念
qq_43839907的博客
12-05 8801
判断题 1-1 无向连通图至少有一个顶点的度为1。F 一个三角形的连通图，顶点的度数都为2. 1-2 用邻接表法存储图，占用的存储空间数只与图中结点个数有关，而与边数无关。F 邻接矩阵的空间复杂度为O(n2)，与边的个数无关。邻接表的空间复杂度为O(n+e)，与图中结点个数和边的个数都有关。 1-3 用邻接矩阵法存储图，占用的存储空间数只与图中结点个数有关，而与边数无关。T 同1-2 ...
高中信息技术《算法与程序设计VB（选修）》知识要点
weixin_30858241的博客
12-13 2023
原博主： http://blog.sina.com.cn/buyanshibai 【转载】 （一）算法 1.定义 相关题解： 1算法：就是解决问题的方法和步骤。算法是程序设计的“灵魂”，算法+数据结构＝程序。 单选题 1、运用计算机程序解决实际问题时，合理的步骤是（B）。 A、设计算法→分析问题→编写程序→调试程序 B、分析问题→设计算法→编写程序→调试程序 C、分析问题→编...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值