C++ dijkstra 最短路径算法、top排序、DFS、BFS 示例 C++11

最新推荐文章于 2024-07-18 20:38:17 发布
最新推荐文章于 2024-07-18 20:38:17 发布
阅读量941 收藏 1
点赞数
分类专栏： 数据结构 c++探究
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MaloryVer9/article/details/78168759
版权

好一段时间前写的了。。。正好现在在复习数据结构，重构了一下代码

首先先是 图、点Vertex和边AdjACent的定义

class JpGraph
    {
    public:

        class Vertex;
        class AdjAcent
        {
        public:
            int cost;
            Vertex* ptr;

            explicit AdjAcent(int newCost = 0,Vertex* newPtr = nullptr):cost(newCost),ptr(newPtr){}
        };


        class Vertex
        {
        public:
            int index;
            int inDegree;
            vector<AdjAcent>degree;


            Vertex(int data, int in_degree)
                : index(data),
                  inDegree(in_degree)                 
            {
            }
        };


        JpGraph(){}

        void lowestCost(const Vertex& v);

        void buildGraph(vector<Vertex> vertexs);
        void BFS(int index);
        void DFS(int index);
        void topSort();
    private:
        vector<Vertex>vertexs;
    };

下面是最短路径的实现，也就是dijkstra算法的实现
inline void JpGraph::lowestCost(const Vertex& v) //形参既是从哪个点开始算
    {
        vector<pair<bool, int>> status;
        for (int i = 0; i < vertexs.size(); ++i)
        {
            status.push_back(pair<bool, int>(false, INT32_MAX));
        }
        //建立与相应点集对应的集合。
        status[v.index].second = 0;
        auto findMin = [&]() //lambda表达式，反正我就这个函数用就没单独写个私有函数
                             //目的是找到当前权重最小的点的下标
        {
            int min = INT32_MAX;
            int minIndx = 0;
            for (int i = 0; i < status.size(); ++i)
                if (status[i].second < min && status[i].first == false)
                {
                    min = status[i].second;
                    minIndx = i;
                }
            return minIndx;
        };
        auto isAllTrue = [&]() //检查所有的点是不是都已标记为true
        {
            for (const auto& i : status)
            {
                if (i.first == false)
                    return false;
            }
            return true;
        };
        //以前写的实现，这次重构发现完全没必要全部遍历。。dijkstra算法的思想可不就是贪心么。。不知道以前咋想的
        //for (;;)
        //{
        //  status[findMin()].first = true; //每次都将未知的点集中的最小值设为已知
        //  for (int i = 0; i < status.size(); ++i)
        //  {
        //      if (status[i].first == true)
        //      {
        //          for (const auto& adj : vertexs[i].degree)
        //          {
        //              auto desV = (*(adj.ptr)).index;
        //              if (status[i].second + adj.cost < status[desV].second) //对与已知点相连接的点的cost进行更新
        //                  status[desV].second = status[i].second + adj.cost;
        //          }
        //      }
        //  }
        //  if (isAllTrue()) //如果所有点都已知，则退出循环
        //      break;
        //}
        while(!isAllTrue())
        {
            auto minIndex = findMin();
            status[minIndex].first = true; //每次都将未知的点集中的最小值设为已知

                    for (const auto& adj : vertexs[minIndex].degree)
                    {
                        auto desV = (*(adj.ptr)).index;
                        if (status[minIndex].second + adj.cost < status[desV].second) //对与已知点相连接的点的cost进行更新
                            status[desV].second = status[minIndex].second + adj.cost;
                    }


        }

        for (int i = 0; i < status.size(); ++i)
        {
            cout << "vertexIndex :" << i << "   cost: " << status[i].second << endl;
        }
    }

以下为测试代码

    inline void testDijkstra()
    {
        std::cout << "testDijkstra :" << std::endl;
        vector<int>vec;
        //sort(vec.begin(), vec.end(), less<int>());
        typedef JpGraph::Vertex  vertex;
        typedef JpGraph::AdjAcent adj;
        vertex v0(0, 0);
        vertex v1(1, 1);
        vertex v2(2, 1);
        vertex v3(3, 2);
        vertex v4(4, 2);
        vertex v5(5, 3);
        vertex v6(6, 2);
        v0.degree = vector<adj>{ adj(1,&v3),adj{ 2,&v1 } };
        v1.degree = vector<adj>{ adj{ 3,&v3 },adj{ 2,&v4 } };
        v2.degree = vector<adj>{ adj{ 5,&v5 },adj{ 4,&v0 } };
        v3.degree = vector<adj>{ adj{ 8,&v5 },adj{ 2,&v2 },adj{ 2,&v4 },adj{ 4,&v6 } };
        v4.degree = vector<adj>{ adj{ 6,&v6 }, };
        v5.degree = vector<adj>();
        v6.degree = vector<adj>{ adj{ 1,&v5 } };
        JpGraph graph;
        graph.buildGraph(vector<vertex>{v0, v1, v2, v3, v4, v5, v6});
        graph.lowestCost(v0);


    }

以下为top排序，top排序的思想我也不说了，网上一搜都有，以下仅实现

    inline void JpGraph::topSort()
    {
        deque<Vertex>q;
        for(const Vertex& vertex : vertexs)
        {
            if (vertex.inDegree == 0)//将所有入度为0的点加入
                q.push_back(vertex);
        }
        while(q.size()!=0)//依次将与入度为0的点相连的点加入，并将入度0的点pop掉，此处既是一个DFS
        {
            auto i = q.front(); q.pop_front();
            cout<<i.index << " "; //通过简单的cout代表访问点
            for(auto& adj : i.degree) 
            {
                auto ptr = adj.ptr;
                --(ptr->inDegree);
                if (ptr->inDegree == 0)
                    q.push_back(*ptr);
            }


        }

    }

以下为测试代码

        inline void testTopSort()
    {
        vector<int>vec;
        //sort(vec.begin(), vec.end(), less<int>());
        typedef JpGraph::Vertex  vertex;
        typedef JpGraph::AdjAcent adj;
        vertex v0(0, 0);
        vertex v1(1, 1);
        vertex v2(2, 1);
        vertex v3(3, 2);
        vertex v4(4, 2);
        vertex v5(5, 3);
        vertex v6(6, 2);
        v0.degree = vector<adj>{ adj(1,&v3),adj{ 2,&v1 } };
        v1.degree = vector<adj>{ adj{ 3,&v3 },adj{ 2,&v4 } };
        v2.degree = vector<adj>{ adj{ 5,&v5 },adj{4,&v0} };
        v3.degree = vector<adj>{ adj{ 8,&v5 },adj{ 2,&v2 },adj{2,&v4},adj{ 4,&v6 } };
        v4.degree = vector<adj>{ adj{ 6,&v6 },};
        v5.degree = vector<adj>();
        v6.degree = vector<adj>{ adj{ 1,&v5 } };
        JpGraph graph;
        graph.buildGraph(vector<vertex>{v0, v1, v2, v3, v4, v5, v6});
        graph.topSort();
    }

DFS和BFS我也不说废话，直接上代码，DFS和BFS的思想网上随便找

inline void JpGraph::BFS(int index)
    {
        map<int, bool>hasVisited;
        deque<int>checkLine;
        for (int i = 0; i < vertexs.size(); ++i)
            hasVisited[i] = false;

        checkLine.push_back(index);
        while(!checkLine.empty())
        {
            int toTravel = checkLine.front();
            checkLine.pop_front();
            if (!hasVisited[toTravel])
            {
                hasVisited[toTravel] = true;
                cout << vertexs[toTravel].index + 1 << " ";

                for(const auto& i : vertexs[toTravel].degree)
                {
                    auto toPAt = *(i.ptr);
                    if(!hasVisited[toPAt.index])
                    {
                        checkLine.push_back(toPAt.index);

                    }
                }
            }
            else;


        }


    }


    inline void JpGraph::DFS(int index)
    {
        map<int, bool>hasVisited;
        for (int i = 0; i < vertexs.size(); ++i)
        {
            hasVisited[i] = false;
        }
        stack<int>stk;
        stk.push(index);
        while (!stk.empty())
        {
            int toTravel = stk.top();
            stk.pop();
            if (hasVisited[toTravel] == false) 
            {
                hasVisited[toTravel] = true;
                cout << vertexs[toTravel].index + 1 << " ";

                for (const auto& i : vertexs[toTravel].degree)
                {
                    auto toPAt = *(i.ptr);
                    if (!hasVisited[toPAt.index])
                    {
                        stk.push(toPAt.index);

                    }

                }

            }
            else;

        }
    }

测试代码

inline void testDFSAndBFS()
    {

        vector<int>vec;
        //sort(vec.begin(), vec.end(), less<int>());
        typedef JpGraph:: Vertex  vertex;
        typedef JpGraph:: AdjAcent adj;
        vertex v0(0, 0);
        vertex v1(1, 1);
        vertex v2(2, 1);
        vertex v3(3, 2);
        vertex v4(4, 2);
        vertex v5(5, 3);
        vertex v6(6, 2);
        v0.degree = vector<adj>{ adj(1,&v3),adj{ 2,&v1 } };
        v1.degree = vector<adj>{ adj{ 3,&v3 },adj{ 2,&v4 } };
        v2.degree = vector<adj>{ adj{ 5,&v5 },adj{ 4,&v0 } };
        v3.degree = vector<adj>{ adj{ 8,&v5 },adj{ 2,&v2 },adj{ 2,&v4 },adj{ 4,&v6 } };
        v4.degree = vector<adj>{ adj{ 6,&v6 }, };
        v5.degree = vector<adj>();
        v6.degree = vector<adj>{ adj{ 1,&v5 } };
        JpGraph graph;
        graph.buildGraph(vector<vertex>{v0, v1, v2, v3, v4, v5, v6});
        std::cout << "testDFS :" << std::endl;
        graph.DFS(0);
        cout << "test BFS" << endl;
        graph.BFS(0);
    }
MaloryVer9
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++ 实现迷宫最短路径
走向CTO的路上...
06-29 1424
接下来N行，每行输入M个字符，每个字符表示迷宫中的一个小方格。字符的含义如下： ‘S’：起点 ‘E’：终点 ‘-’：空地，可以通过 ‘#’：障碍，无法通过 输入数据保证有且仅有一个起点和终点。输出 对于每组输入，输出从起点到终点的最短路程，如果不存在从起点到终点的路，则输出-1。样例输入 复制 1 5 5 S-### ##--- E#--- ---## 样例输出 复制 9。，用于表示迷宫中的坐标点和到达该点的步数。通过广度优先搜索算法，在每一步移动时尝试四个方向，并使用队列来存储待探索的点。
邻接表（逆邻接表）创建
老6
08-29 2555
#include<cstdio> #include<iostream> #include<malloc.h> #define max_sum 30 using namespace std; typedef struct Arcnode{ int adjvex; struct Arcnode *nextarc; }Arcnode; typedef struct Vexnode{ char data; struct Arcnode *firstarc; }Vnod.
DFS 求最短路径 C++
一个懒惰的程序员
05-19 2426
假设 一张地图 N行M列 ,0表示通畅1表示障碍物,P,Q表示终点坐标.求点(0,0)到(P,Q)最短路径 #include<iostream> #include<stdio.h> int minS=999999;//最小路程minS 防止和iostresm 里面的min命名冲突 int map[51][51]={0};//地图 int book[51][51]=...
C++搜索算法（dfs）
Archie28的博客
07-18 1643
dfs算法介绍
数据结构-实现图的存储结构、dfs、bfs、dijkstra、拓扑排序等算法（c++）
weixin_48131355的博客
05-19 506
提示：注释详细，若有错误还请多多指教。 文章目录一、图的存储结构二、遍历算法1.DFS深度优先搜索2.BFS广度优先搜索三、最短路径问题（Dijkstra算法）四、拓扑排序总结
DFS算法C++
qq_46595907的博客
11-22 593
//#include<stdio.h> #include <iostream> using namespace std; int m,n,p,q; int Min=100; int a[100][100]; //1 空地，2障碍物 int v[100][100]; //0 未访问，1访问 int dx[4]={0,1,0,-1}; int dy[4]={1,0,-1,0}; void Dfs(int x,int y,int step) { if(x==p &a
基于BFS的最短路径搜索[C++]
FQT_CJ的博客
07-21 1048
基于C++实现BFS的最短路径搜索时，可以使用STL中的优先队列priority_queue，优先队列按照小顶堆，即路径短的优先取出。其中，起点为左上角，终点为右下角，障碍物通过值设置为9999，可以根据题目的要求设置为一个非常大的值。...
图形算法存储库的编码分钟课程示例 - Java-C++ - 下载.zip
09-15
图形算法涉及到图的表示（如邻接矩阵和邻接表）、遍历（深度优先搜索DFS和广度优先搜索BFS）以及图的基本操作，如查找路径、最小生成树（Kruskal's或Prim's算法）和最短路径问题（Dijkstra算法和Floyd-Warshall算法...
0基础学算法C++学习
06-19
5. **图论算法**：深度优先搜索（DFS）和广度优先搜索（BFS）是图算法的基础，还有最短路径算法（Dijkstra、Floyd-Warshall等）和最小生成树算法（Prim、Kruskal）。 6. **字符串处理**：字符串操作在很多算法中都...
C++各类算法代码
10-08
7. 图算法：Dijkstra最短路径算法、Floyd-Warshall所有最短路径算法、Prim最小生成树算法、Kruskal最小生成树算法等。 在“InterviewQuestions”这个压缩包中，你可以期待找到以上各种数据结构和算法的C++实现。...
数据结构与算法基础课程 C语言C++程序语言设计教程 1_0 课程简介 共7页.pptx
最新发布
07-20
- **最短路径算法**：介绍几种常见的最短路径算法，如Dijkstra算法和Floyd算法。 ##### 8.1 集合与查找（静态查找、哈希、二叉排序树、平衡二叉树） - **静态查找**：介绍静态查找的基本概念及其方法。 - **哈希表*...
迷宫最短路径算法（dfs）
02-26
这是一个求迷宫最短路径的算法，用的是dfs的思想～～～～～～～～～～～～～
PAT_甲级_1030 Travel Plan (30分) (C++)【Dijkstra/DFS】
&再见萤火虫&的博客
02-15 285
1，题目描述 Sample Input: 4 5 0 3 0 1 1 20 1 3 2 30 0 3 4 10 0 2 2 20 2 3 1 20 Sample Output: 0 2 3 3 40 2，思路 3，代码
广度优先遍历（BFS）的应用之单源最短路径问题（C++）
smart_jackli的博客
11-18 1213
广度优先遍历求解单源最短路径问题代码
C++PTA A1087(dijkstra+dfs)
执念斩长河
01-30 294
dijkstra算法+dfs
【算法-＞图】Dijkstra迪杰斯特拉算法 C++实现
小明2766的博客
11-18 1233
迪杰斯特拉算法，用于解决单源最短路径问题。 伪代码 //G为图，一般设成全局变量；数组d为源点到达各点的最短路径长度，s为起点 Dijstra(G, d[], s){ 初始化; for(循环n次){ u = 使d[u]最小的还未被访问的顶点的标号; 记u已被访问; for(从u出发能到达的所有顶点v){ if(v未被访问 && 以u为中介点使s到顶点v的最短距离d[v]最优){
c++ dfs算法 简单说-------------
热门推荐
bwloveforever的博客
03-23 2万+
百度的解释：深度优先搜索属于图算法的一种，英文缩写为DFS即Depth First Search.其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次.举例说明之：下图是一个无向图，如果我们从A点发起深度优先搜索（以下的访问次序并不是唯一的，第二个点既可以是B也可以是C,D），则我们可能得到如下的一个访问过程：A-&gt;B-&gt;E（没有路了！回溯到A)-&gt...
算法题2
开贰锤
11-09 893
1. 变态跳台阶 一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。 分析： f(n)=f(1)+f(2)+...+f(n−1)+1 f(n)=f(1)+f(2)+...+f(n-1)+1 f(n)=f(1)+f(2)+...+f(n−1)+1 2. 矩形覆盖 我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形...
C++编程：数据结构与算法解析
- **图算法**：如深度优先搜索（DFS）、广度优先搜索（BFS）、最短路径算法（Dijkstra、Floyd-Warshall）。 - **动态规划**：解决具有重叠子问题和最优子结构的问题，如背包问题、最长公共子序列等。 - **回溯法*...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值