c++数据结构之图篇

最新推荐文章于 2023-08-12 20:03:55 发布
最新推荐文章于 2023-08-12 20:03:55 发布
阅读量2.3w 收藏 230
点赞数 51
分类专栏： C++学习 个人笔记 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40420795/article/details/82632465
版权

c++数据结构之图篇

一、图的基本概念与原理

  1. 什么是图？

    有向图与无向图；

    顶点

    弧：弧尾和弧头

    度：出度和入度

    顶点

    边

    邻接点

    连通图

    完全图：边数=n(n-1)/2

    生成树：边数=n-1

  2. 图的表示法

  3. 图的遍历

  4. 最小生成树：注意最小生成树的应用

  5. 图的应用：

    • 路径规划
    • 工程规划
    • 战略规划

二、图的存储方式

对于无向图：存储顶点及边

对于有向图：存储顶点及弧

弧尾———-权值———狐尾

  1. 邻接矩阵

    顶点的表示方法：

    顶点索引 顶点数据

    弧的表示方法：

    邻接矩阵

    这里写图片描述

这里写图片描述

c++
struct Node
{
顶点索引;
顶点数据;
};

c++
struct Map
{
顶点数据;
邻接矩阵;
};

  1. 邻接表(链式存储)

    用于表示有向表

    顶点的表示方法：

    顶点索引 出弧链表头指针 顶点数据

    弧的表示方法：

    弧头顶点索引 下一条弧指针 弧数据

这里写图片描述

下面是上面链表表示法的具体体现：

这里写图片描述

最难理解的是出弧链表头指针及下一条弧指针

一个顶点发出多条弧时，第一条弧里带有下一条弧的指针；

弧数据相当于权重

c++
struct Node
{
顶点索引;
该顶点弧链表的头结点;
顶点数据;
};

c++
struct Arc
{
指向的顶点索引;
指向下一条弧的指针;
弧信息;
};

c++
struct Map
{
顶点数组;
};

  1. 十字链表

    也用于存储有向图；

顶点的表示方法
顶点索引顶点数据以该顶点为弧尾的弧节点指针以该顶点为弧头的弧节点指针
弧的表示方法
弧尾顶点索引弧头顶点索引弧尾相同的下一条弧的指针弧头相同的下一条弧的指针弧的数据

十字链表通过结构体存储的方式如下：

c++
struct Node
{
顶点索引;
顶点数据;
第一条入弧节点指针;
第一条出弧节点指针;
};

c++
struct Arc
{
弧尾顶点索引;
弧头顶点索引;
指向下一条弧头相同的弧的指针;
指向下一条弧尾相同的弧的指针;
弧信息;
};

c++
struct Map
{
顶点数组;
};

  1. 邻接多重表

    用于存储无向图；

顶点的表示方法
顶点索引连接该顶点的边顶点数据
边的表示方法
A顶点索引B顶点索引与A顶点相连接的下一条边的指针与B顶点相连接的下一条边的指针边数据

用结构体表示为：

c++
struct Node
{
顶点索引;
顶点数据;
第一条边节点指针;
};

c++
struct Egde
{
顶点A索引;
顶点B索引;
连接A的下一条边的指针;
连接B的下一条边的指针;
边信息;
};

c++
struct Map
{
顶点数组;
};

三、图的遍历

图的搜索按搜索方向分为：深度优先搜索和广度优先搜索；

深度优先搜索遵循二叉树搜索的“根左右”的原则，广度优先搜索是一层一层的节点进行搜索；

1、最小生成树

有普利姆算法，克鲁斯卡尔算法两种算法；普里姆是归并点；而克鲁斯卡尔是归并边；

  • 普利姆（prim）算法

    算法思想：

    • [ ] 任意选择一个顶点，将其放入点集合中；下图选的顶点为A;
    • [ ] 将与A顶点相连的边放入待选边集合中，如下图的A-B(6) A-F(1) A-E(5)所示；
    • [ ] 选择一个权值最小的边放入边集合中，下图中是A-F(1);将该边所连的顶点F放入点集合中;
    • [ ] 将与F点相连的边放入待选边集合中，如F-B(2) F-E(9) F-C(8) F-D(4)，重复上面2~3步的过程，直到所有的点都被包含在点集合中（图中的点集合少写了个E)
    • [ ] 普利姆算法适用于稠密的图，即边数较多的图，时间复杂度o(n^2);

这里写图片描述

  • 克鲁斯卡尔（Kruskal）算法

    算法思想：

    • [ ] 将所有边放入待选边集合中；
    • [ ] 取出当前待选边集合中权值最小的边放入已选边集合中，将边所连接的两个顶点放入已涉及点集合中
    • [ ] 重复步骤2，如果已涉及的点的集合中的点不处于同一棵树中，则继续重复步骤2，直到已涉及的点的集合包含所有的点且所有点都在同一棵树中，最小生成树也就随之产生了；
    • [ ] 克鲁斯卡尔算法适用于边数较少的稀疏图，算法复杂度为o(n^2);

这里写图片描述

四、图的编码实战

  1. 图的基本操作与遍历

    Node.h文件：

    
#ifndef NODE_H_


#define NODE_H_

class Node
{
public:
Node(char data = 0); //节点的构造函数
char m_cData;        //节点的数据域
bool m_bIsVisited;   //标记该节点是否被访问过
};

#endif

    Node.cpp文件：

    
#include "Node.h"

Node::Node(char data)
{
m_cData = data;
m_bIsVisited = false;    //默认为该节点没有被访问过
}

    CMap.h文件：

    
#ifndef CMAP_H_


#define CMAP_H_

//包含vector类模板，后面的函数breadthFirstTraverseImpl(vector<int> preVec)会用到

#include <vector>


#include "Node.h"

using namespace std;
class CMap
{
public:
CMap(int capacity);           //构造函数，创建图
~CMap();                      //析构函数，销毁图
bool addNode(Node *pNode);    //增加节点
void resetNode();             //重置节点的访问状态为未访问
   //给有向图的邻接矩阵的元素设置值
bool setValueToMatrixForDirectedGraph(int row,int col,int val = 1);  
   //给无向图的邻接矩阵的元素设置值
bool setValueToMatrixForUndirectedGraph(int row,int col,int val = 1);  

void printMartrix();          //打印邻接矩阵

void depthFirstTraverse(int nodeIndex);              //深度优先遍历
void breadthFirstTraverse(int nodeIndex);            //广度优先遍历

private:
bool getValueFromMatrix(int row,int col,int &val);   //获取邻接矩阵中元素的值
   //广度优先遍历的工具函数，用来存储某一层的元素
void breadthFirstTraverseImpl(vector<int> preVec);   

private:
int m_iCapacity;               //图的节点的容量                                
int m_iNodeCount;              //图当前的节点的数量
Node *m_pNodeArray;            //指向图中首节点的指针
int *m_pMatrix;                //指向邻接矩阵首元素的指针
};

#endif

    CMap.cpp文件：

    
#include "CMap.h"


#include <iostream>

using namespace std;
CMap::CMap(int capacity)  
{
m_iCapacity = capacity;
m_iNodeCount = 0;
m_pNodeArray = new Node[m_iCapacity];
m_pMatrix = new int[m_iCapacity*m_iCapacity];
//memset(m_pMatrix,0,m_iCapacity*m_iCapacity*sizeof(int)); 
//使用c++标准函数void *memset(void *s, int ch, size_t n)实现快速初始化
for(int i = 0;i < m_iCapacity*m_iCapacity;i++)     
{     
    m_pMatrix[i] = 0;
}
}

CMap::~CMap()
{
delete []m_pNodeArray;         //先释放节点所对应的内存
delete []m_pMatrix;            //再释放邻接矩阵所对应的内存
}

bool CMap::addNode(Node *pNode)    
{
if(pNode == NULL)              //表示无法添加一个空节点
{
    return false;
}
   //往节点矩阵中增加节点，新增加的节点的索引总是处于当前节点的末尾位置
m_pNodeArray[m_iNodeCount] = pNode->m_cData;  
m_iNodeCount++;                //这种设计刚好在Node类中避免了添加数据成员：节点的索引
return true;
}

void CMap::resetNode()
{
for(int i = 0;i < m_iNodeCount;i++)
{
    m_pNodeArray[i].m_bIsVisited = false;  
}
}
//给有向表的邻接矩阵中row行，col列的元素设置值,默认是1
bool CMap::setValueToMatrixForDirectedGraph(int row,int col,int val)  
{
if(row < 0 || row >= m_iCapacity)
{
    return false;
}
if(col < 0 || col >= m_iCapacity)
{
    return false;
}
m_pMatrix[row*m_iCapacity+col] = val;
return true;
}

//给无向表的邻接矩阵中row行，col列的元素设置值,默认是1
bool CMap::setValueToMatrixForUndirectedGraph(int row,int col,int val)
{
if(row < 0 || row >= m_iCapacity)
{
    return false;
}
if(col < 0 || col >= m_iCapacity)
{
    return false;
}
m_pMatrix[row*m_iCapacity+col] = val;//将二维数组按行展开为一维数组
m_pMatrix[col*m_iCapacity+row] = val;//将二维数组按列展开为一维数组
return true;
}

bool CMap::getValueFromMatrix(int row,int col,int &val) //获取邻接矩阵对应位置处的元素值
{
if(row < 0 || row >= m_iCapacity)
{
    return false;
}
if(col < 0 || col >= m_iCapacity)
{
    return false;
}
val = m_pMatrix[row*m_iCapacity+col];
return true;
}

void CMap::printMartrix()                    //打印邻接矩阵中每个元素的值
{
for(int i = 0;i < m_iCapacity;i++)
{
    for(int k = 0;k < m_iCapacity;k++)
    {
        cout << m_pMatrix[i*m_iCapacity+k] << " ";
    }
    cout << endl;                        //每打印m_iCapacity个元素换一行
}
}


//深度优先遍历     用到了递归
void CMap::depthFirstTraverse(int nodeIndex)        //既适用于无向图也适用于有向图
{
int value = 0;
cout << m_pNodeArray[nodeIndex].m_cData << " "; //打印节点的数据域的值
m_pNodeArray[nodeIndex].m_bIsVisited = true;    //将节点的访问状态置为访问了的状态

for(int i = 0; i < m_iCapacity;i++)
{
    getValueFromMatrix(nodeIndex,i,value);
    if(value != 0)            //表示nodeIndex这个索引的节点与索引为i的节点相连
    {
        if(m_pNodeArray[i].m_bIsVisited)//已经访问过的话就避免重复访问
        {
            continue;
        }
        else
        {
            depthFirstTraverse(i);      //使用到了递归          
        } 
    }
    else
    {
        continue;
    }
}
}
//广度优先遍历    这个遍历的算法实现起来最为麻烦，要使用到下面的函数breadthFirstTraverseImpl(vector<int> preVec)
void CMap::breadthFirstTraverse(int nodeIndex)
{
cout << m_pNodeArray[nodeIndex].m_cData << " ";
m_pNodeArray[nodeIndex].m_bIsVisited = true;
vector<int> curVec;
curVec.push_back(nodeIndex);
breadthFirstTraverseImpl(curVec);
}

void CMap::breadthFirstTraverseImpl(vector<int> preVec)//vector类其实就是一个封装的数组
{
int value = 0;
vector<int> curVec;
for(int j = 0;j < (int)preVec.size(); j++) 
{
    for(int i = 0;i < m_iCapacity;i++)
    {                                                 
        getValueFromMatrix(preVec[j],i,value);//查看上一层节点与当前层节点是否有连接的
        if(value != 0)
        {
            if(m_pNodeArray[i].m_bIsVisited)
            {
                continue;
            }
            else
            {
                cout << m_pNodeArray[i].m_cData << " ";
                m_pNodeArray[i].m_bIsVisited = true;

                curVec.push_back(i);                  //把这一层存入curVec数组中
            }
        }
    }
}
if(curVec.size() == 0)             //如果该层没有点，则直接返回函数调用处，且什么都不做
{
    return;

else                              //若该层有点，则递归执行当前的遍历操作
{
    breadthFirstTraverseImpl(curVec);
}
}

    演示代码demo.cpp:

    
#include <iostream>


#include "CMap.h"

using namespace std;
/*
      图的存储 与 图的遍历
*/
/*

         A
    /   \
   B      D
  / \    / \
 C   F  G — H
 \  /
  E

*/

/*

深度优先遍历：A B C E F D G H
广度优先遍历：A B D C F G F E


邻接矩阵：
  A  B  C  D  E  F  G  H
A     1     1    
B  1     1        1
C     1        1  1
D  1                 1  1
E        1
F     1  1
G           1           1
H           1        1

*/
/*Time:2018年9月9日11:48:48    */

int main(void)
{
CMap *pMap = new CMap(8);

Node *pNodeA = new Node('A');
Node *pNodeB = new Node('B');
Node *pNodeC = new Node('C');
Node *pNodeD = new Node('D');
Node *pNodeE = new Node('E');
Node *pNodeF = new Node('F');
Node *pNodeG = new Node('G');
Node *pNodeH = new Node('H');

pMap->addNode(pNodeA);
pMap->addNode(pNodeB);
pMap->addNode(pNodeC);
pMap->addNode(pNodeD);
pMap->addNode(pNodeE);
pMap->addNode(pNodeF);
pMap->addNode(pNodeG);
pMap->addNode(pNodeH);

pMap->setValueToMatrixForUndirectedGraph(0,1);
pMap->setValueToMatrixForUndirectedGraph(0,3);
pMap->setValueToMatrixForUndirectedGraph(1,2);
pMap->setValueToMatrixForUndirectedGraph(1,5);
pMap->setValueToMatrixForUndirectedGraph(3,6);
pMap->setValueToMatrixForUndirectedGraph(3,7);
pMap->setValueToMatrixForUndirectedGraph(6,7);
pMap->setValueToMatrixForUndirectedGraph(2,4);
pMap->setValueToMatrixForUndirectedGraph(4,5);


pMap->printMartrix();

cout << endl;

pMap->depthFirstTraverse(0);

cout << endl;

pMap->resetNode();

pMap->breadthFirstTraverse(0);
cin.get();
return 0;
}

    注意图的深度优先遍历算法及图的广度优先遍历算法的算法的具体描述过程：

    • 广度优先搜索（BFS）类似于二叉树的层序遍历算法，它的基本思想是：首先访问起始顶点v，然后由v出发，依次访问v的各个未被访问过的邻接顶点w1,w2,w3….wn，然后再依次访问w1，w2,…,wi的所有未被访问过的邻接顶点，再从这些访问过的顶点出发，再访问它们所有未被访问过的邻接顶点….

  2. 图的最小生成树算法

    • prim算法的代码演示如下：

      Node.h文件：

      
#ifndef NODE_H_


#define NODE_H_

class Node
{
public:
Node(char data = 0); //节点的构造函数
char m_cData;        //节点的数据域
bool m_bIsVisited;   //标记该节点是否被访问过
};

#endif

      Node.cpp文件：

      
#include "Node.h"

Node::Node(char data)
{
m_cData = data;
m_bIsVisited = false;    //默认为该节点没有被访问过
}

      Edge.h文件：

      
#ifndef EDGE_H_


#define EDGE_H_

class Edge
{
public:
Edge(int nodeIndexA = 0,int nodeIndexB = 0,int weightValue = 0);
int m_iNodeIndexA;
int m_iNodeIndexB;
int m_iWeightValue;
bool m_bSelected;
};

#endif

      Edge.cpp文件：

      
#include "Edge.h"

Edge::Edge(int nodeIndexA,int nodeIndexB,int weightValue)
{
m_iNodeIndexA = nodeIndexA;
m_iNodeIndexB = nodeIndexB;
m_iWeightValue = weightValue;
m_bSelected = false;
}

      CMap.h文件：

      
#ifndef CMAP_H_


#define CMAP_H_

//包含vector类模板，后面的函数breadthFirstTraverseImpl(vector<int> preVec)会用到

#include <vector>


#include "Node.h"


#include "Edge.h"

using namespace std;
class CMap
{
public:
CMap(int capacity);           //构造函数，创建图
~CMap();                      //析构函数，销毁图
bool addNode(Node *pNode);    //增加节点
void resetNode();             //重置节点的访问状态为未访问
//给有向图的邻接矩阵的元素设置值
bool setValueToMatrixForDirectedGraph(int row,int col,int val = 1);  
//给无向图的邻接矩阵的元素设置值
bool setValueToMatrixForUndirectedGraph(int row,int col,int val = 1);  

void printMartrix();          //打印邻接矩阵

void depthFirstTraverse(int nodeIndex);              //深度优先遍历
void breadthFirstTraverse(int nodeIndex);            //广度优先遍历

void primTree(int nodeIndex); //普利姆生成树

private:
bool getValueFromMatrix(int row,int col,int &val);   //获取邻接矩阵中元素的值
//广度优先遍历的工具函数，用来存储某一层的元素
void breadthFirstTraverseImpl(vector<int> preVec); 
int getMinEdge(vector<Edge> edgeVec);

private:
int m_iCapacity;               //图的节点的容量                                
int m_iNodeCount;              //图当前的节点的数量
Node *m_pNodeArray;            //指向图中首节点的指针
int *m_pMatrix;                //指向邻接矩阵首元素的指针

Edge *m_pEdge;                 //指向最小生成树边的指针
};

#endif

      CMap.cpp文件：

      
#include "CMap.h"


#include <iostream>

using namespace std;
CMap::CMap(int capacity)  
{
m_iCapacity = capacity;
m_iNodeCount = 0;
m_pNodeArray = new Node[m_iCapacity];
m_pMatrix = new int[m_iCapacity*m_iCapacity];
//memset(m_pMatrix,0,m_iCapacity*m_iCapacity*sizeof(int)); 
//使用c++标准函数void *memset(void *s, int ch, size_t n)实现快速初始化
for(int i = 0;i < m_iCapacity*m_iCapacity;i++)     
{     
    m_pMatrix[i] = 0;
}

m_pEdge = new Edge[m_iCapacity-1]; //为边对象申请一段内存
}

CMap::~CMap()
{
delete []m_pNodeArray;         //先释放节点所对应的内存
delete []m_pMatrix;            //再释放邻接矩阵所对应的内存
}

bool CMap::addNode(Node *pNode)    
{
if(pNode == NULL)              //表示无法添加一个空节点
{
    return false;
}
//往节点矩阵中增加节点，新增加的节点的索引总是处于当前节点的末尾位置
m_pNodeArray[m_iNodeCount] = pNode->m_cData;  
m_iNodeCount++;                //这种设计刚好在Node类中避免了添加数据成员：节点的索引
return true;
}

void CMap::resetNode()
{
for(int i = 0;i < m_iNodeCount;i++)
{
    m_pNodeArray[i].m_bIsVisited = false;  
}
}
//给有向表的邻接矩阵中row行，col列的元素设置值,默认是1
bool CMap::setValueToMatrixForDirectedGraph(int row,int col,int val)  
{
if(row < 0 || row >= m_iCapacity)
{
    return false;
}
if(col < 0 || col >= m_iCapacity)
{
    return false;
}
m_pMatrix[row*m_iCapacity+col] = val;
return true;
}

//给无向表的邻接矩阵中row行，col列的元素设置值,默认是1
bool CMap::setValueToMatrixForUndirectedGraph(int row,int col,int val)
{
if(row < 0 || row >= m_iCapacity)
{
    return false;
}
if(col < 0 || col >= m_iCapacity)
{
    return false;
}
m_pMatrix[row*m_iCapacity+col] = val;//将二维数组按行展开为一维数组
m_pMatrix[col*m_iCapacity+row] = val;//将二维数组按列展开为一维数组
return true;
}

bool CMap::getValueFromMatrix(int row,int col,int &val) //获取邻接矩阵对应位置处的元素值
{
if(row < 0 || row >= m_iCapacity)
{
    return false;
}
if(col < 0 || col >= m_iCapacity)
{
    return false;
}
val = m_pMatrix[row*m_iCapacity+col];
return true;
}

void CMap::printMartrix()                    //打印邻接矩阵中每个元素的值
{
for(int i = 0;i < m_iCapacity;i++)
{
    for(int k = 0;k < m_iCapacity;k++)
    {
        cout << m_pMatrix[i*m_iCapacity+k] << " ";
    }
    cout << endl;                        //每打印m_iCapacity个元素换一行
}
}
//深度优先遍历     用到了递归
void CMap::depthFirstTraverse(int nodeIndex)        //既适用于无向图也适用于有向图
{
int value = 0;
cout << m_pNodeArray[nodeIndex].m_cData << " "; //打印节点的数据域的值
m_pNodeArray[nodeIndex].m_bIsVisited = true;    //将节点的访问状态置为访问了的状态

for(int i = 0; i < m_iCapacity;i++)
{
    getValueFromMatrix(nodeIndex,i,value);
    if(value != 0)            //表示nodeIndex这个索引的节点与索引为i的节点相连
    {
        if(m_pNodeArray[i].m_bIsVisited)//已经访问过的话就避免重复访问
        {
            continue;
        }
        else
        {
            depthFirstTraverse(i);      //使用到了递归          
        } 
    }
    else
    {
        continue;
    }
}
}
//广度优先遍历    这个遍历的算法实现起来最为麻烦，要使用到下面的函数breadthFirstTraverseImpl(vector<int> preVec)
void CMap::breadthFirstTraverse(int nodeIndex)
{
cout << m_pNodeArray[nodeIndex].m_cData << " ";
m_pNodeArray[nodeIndex].m_bIsVisited = true;
vector<int> curVec;
curVec.push_back(nodeIndex);
breadthFirstTraverseImpl(curVec);
}

void CMap::breadthFirstTraverseImpl(vector<int> preVec)//vector类其实就是一个封装的数组
{
int value = 0;
vector<int> curVec;
for(int j = 0;j < (int)preVec.size(); j++) 
{
    for(int i = 0;i < m_iCapacity;i++)
    {                                                 
        getValueFromMatrix(preVec[j],i,value);//查看上一层节点与当前层节点是否有连接的
        if(value != 0)
        {
            if(m_pNodeArray[i].m_bIsVisited)
            {
                continue;
            }
            else
            {
                cout << m_pNodeArray[i].m_cData << " ";
                m_pNodeArray[i].m_bIsVisited = true;

                curVec.push_back(i);                  //把这一层存入curVec数组中
            }
        }
    }
}
if(curVec.size() == 0)             //如果该层没有点，则直接返回函数调用处，且什么都不做
{
    return;
}

else                              //若该层有点，则递归执行当前的遍历操作
{
    breadthFirstTraverseImpl(curVec);
}
}

void CMap::primTree(int nodeIndex)
{
int value = 0;
int edgeCount = 0;
vector<int> nodeVec;                       //点集合
vector<Edge> edgeVec;                      //待选表集合          

cout << m_pNodeArray[nodeIndex].m_cData << endl;

nodeVec.push_back(nodeIndex);
m_pNodeArray[nodeIndex].m_bIsVisited = true;

//先判断当前算法的终止条件
 while(edgeCount < m_iCapacity-1)           //待选边的最大数目等于
{
    int temp = nodeVec.back();     //取出nodeVec向量中末尾的元素
    for(int i = 0;i < m_iCapacity;i++)
    {
        getValueFromMatrix(temp,i,value);
        if(value != 0)
        {
            if(m_pNodeArray[i].m_bIsVisited)
            {
                continue;
            }
            else
            {
                Edge edge(temp,i,value);
                edgeVec.push_back(edge);    //待选边集合
            }
        }

    }
    //从可选边集合中找出最小的边
    int edgeIndex = getMinEdge(edgeVec);
    edgeVec[edgeIndex].m_bSelected = true;

    cout << edgeVec[edgeIndex].m_iNodeIndexA << "----" << edgeVec[edgeIndex].m_iNodeIndexB << " ";
    cout << edgeVec[edgeIndex].m_iWeightValue << endl;

    m_pEdge[edgeCount] = edgeVec[edgeIndex];        //把选择的最小的边放入最小生成树的边集合中
    edgeCount++;

    int nextNodeIndex = edgeVec[edgeIndex].m_iNodeIndexB;  //通过选择的最小生成树的边找到下一个点
    nodeVec.push_back(nextNodeIndex);               //把这个点放入点集合中
    m_pNodeArray[nextNodeIndex].m_bIsVisited = true;
    cout << m_pNodeArray[nextNodeIndex].m_cData << endl;
}
}

int CMap::getMinEdge(vector<Edge> edgeVec)             //取得最小边的函数
{
int edgeIndex = 0;
int minWeight = 0;
int i = 0;                                 
for(;i < edgeVec.size();i++)
{
    if(!edgeVec[i].m_bSelected)
    {
        minWeight = edgeVec[i].m_iWeightValue;
        edgeIndex = i;
        break;
    }
}

if(minWeight == 0)               //即minWeight没有改变，即上面那个if没被执行
{
    return -1;                   //返回-1，程序终止，下面的代码就不会执行了
}
for(;i < edgeVec.size();i++)
{
    if(edgeVec[i].m_bSelected)
    {
        continue;
    }
    else
    {
        if(minWeight > edgeVec[i].m_iWeightValue)
        {
            minWeight = edgeVec[i].m_iWeightValue;
            edgeIndex = i;
        }
    }
}
return edgeIndex;
}

      演示代码demo.cpp：

      
#include <iostream>


#include "CMap.h"

using namespace std;

/************************************************************/
/*Time:2018年9月11日11:25:29
/*

            A
           /    \
        B --- F -- E
         \  /  \  /
         C --- D

A B C D E F 
0 1 2 3 4 5 

A-B 6   A-E 5    A-F 1
B-C 3   B-F 2
C-F 8   C-D 7
D-F 4   D-E 2
E-F 9


*/
int main(void)
{
CMap *pMap = new CMap(6);

Node *pNodeA = new Node('A');
Node *pNodeB = new Node('B');
Node *pNodeC = new Node('C');
Node *pNodeD = new Node('D');
Node *pNodeE = new Node('E');
Node *pNodeF = new Node('F');

pMap->addNode(pNodeA);
pMap->addNode(pNodeB);
pMap->addNode(pNodeC);
pMap->addNode(pNodeD);
pMap->addNode(pNodeE);
pMap->addNode(pNodeF);


pMap->setValueToMatrixForUndirectedGraph(0,1,6);
pMap->setValueToMatrixForUndirectedGraph(0,4,5);
pMap->setValueToMatrixForUndirectedGraph(0,5,1);
pMap->setValueToMatrixForUndirectedGraph(1,2,3);
pMap->setValueToMatrixForUndirectedGraph(1,5,2);
pMap->setValueToMatrixForUndirectedGraph(2,5,8);
pMap->setValueToMatrixForUndirectedGraph(2,3,7);
pMap->setValueToMatrixForUndirectedGraph(3,5,4);
pMap->setValueToMatrixForUndirectedGraph(3,4,2);
pMap->setValueToMatrixForUndirectedGraph(4,5,9);


pMap->primTree(0);
cin.get();
return 0;
}

    • 克鲁斯卡尔算法代码演示：

      Node.h，Node.cpp，Edge.h，Edge.cpp文件与上面一致，下面来看CMap.h、CMap.cpp文件的内容

      CMap.h文件：

      
#ifndef CMAP_H_


#define CMAP_H_

//包含vector类模板，后面的函数breadthFirstTraverseImpl(vector<int> preVec)会用到

#include <vector>


#include "Node.h"


#include "Edge.h"

using namespace std;
class CMap
{
public:
CMap(int capacity);           //构造函数，创建图
~CMap();                      //析构函数，销毁图
bool addNode(Node *pNode);    //增加节点
void resetNode();             //重置节点的访问状态为未访问
//给有向图的邻接矩阵的元素设置值
bool setValueToMatrixForDirectedGraph(int row,int col,int val = 1);  
//给无向图的邻接矩阵的元素设置值
bool setValueToMatrixForUndirectedGraph(int row,int col,int val = 1);  

void printMartrix();          //打印邻接矩阵

void depthFirstTraverse(int nodeIndex);              //深度优先遍历
void breadthFirstTraverse(int nodeIndex);            //广度优先遍历

void primTree(int nodeIndex); //普利姆生成树
void KruskalTree();           //克鲁斯卡尔算法生成最小生成树

private:
bool getValueFromMatrix(int row,int col,int &val);   //获取邻接矩阵中元素的值
//广度优先遍历的工具函数，用来存储某一层的元素
void breadthFirstTraverseImpl(vector<int> preVec); 
int getMinEdge(vector<Edge> edgeVec);//获取最小边的函数
bool isInSet(vector<int> nodeSet,int target);//判断边是否处于同一通路
void mergeNodeSet(vector<int> &nodeSetA,vector<int> nodeSetB);

private:
int m_iCapacity;               //图的节点的容量                               
int m_iNodeCount;              //图当前的节点的数量
Node *m_pNodeArray;            //指向图中首节点的指针
int *m_pMatrix;                //指向邻接矩阵首元素的指针
Edge *m_pEdge;                 //指向最小生成树边的指针
};

#endif

      CMap.cpp文件：

      
#include "CMap.h"


#include <iostream>

using namespace std;
CMap::CMap(int capacity)  
{
m_iCapacity = capacity;
m_iNodeCount = 0;
m_pNodeArray = new Node[m_iCapacity];
m_pMatrix = new int[m_iCapacity*m_iCapacity];
//memset(m_pMatrix,0,m_iCapacity*m_iCapacity*sizeof(int)); 
//使用c++标准函数void *memset(void *s, int ch, size_t n)实现快速初始化
for(int i = 0;i < m_iCapacity*m_iCapacity;i++)     
{     
    m_pMatrix[i] = 0;
}

m_pEdge = new Edge[m_iCapacity-1]; //为边对象申请一段内存
}

CMap::~CMap()
{
delete []m_pNodeArray;         //先释放节点所对应的内存
delete []m_pMatrix;            //再释放邻接矩阵所对应的内存
delete []m_pEdge;              //释放边所占用的内存
}

bool CMap::addNode(Node *pNode)    
{
if(pNode == NULL)              //表示无法添加一个空节点
{
    return false;
}
//往节点矩阵中增加节点，新增加的节点的索引总是处于当前节点的末尾位置
m_pNodeArray[m_iNodeCount] = pNode->m_cData;  
m_iNodeCount++;                //这种设计刚好在Node类中避免了添加数据成员：节点的索引
return true;
}

void CMap::resetNode()
{
for(int i = 0;i < m_iNodeCount;i++)
{
    m_pNodeArray[i].m_bIsVisited = false;  
}
}
//给有向表的邻接矩阵中row行，col列的元素设置值,默认是1
bool CMap::setValueToMatrixForDirectedGraph(int row,int col,int val)  
{
if(row < 0 || row >= m_iCapacity)
{
    return false;
}
if(col < 0 || col >= m_iCapacity)
{
    return false;
}
m_pMatrix[row*m_iCapacity+col] = val;
return true;
}

//给无向表的邻接矩阵中row行，col列的元素设置值,默认是1
bool CMap::setValueToMatrixForUndirectedGraph(int row,int col,int val)
{
if(row < 0 || row >= m_iCapacity)
{
    return false;
}
if(col < 0 || col >= m_iCapacity)
{
    return false;
}
m_pMatrix[row*m_iCapacity+col] = val;//将二维数组按行展开为一维数组
m_pMatrix[col*m_iCapacity+row] = val;//将二维数组按列展开为一维数组
return true;
}

bool CMap::getValueFromMatrix(int row,int col,int &val) //获取邻接矩阵对应位置处的元素值
{
if(row < 0 || row >= m_iCapacity)
{
    return false;
}
if(col < 0 || col >= m_iCapacity)
{
    return false;
}
val = m_pMatrix[row*m_iCapacity+col];
return true;
}

void CMap::printMartrix()                    //打印邻接矩阵中每个元素的值
{
for(int i = 0;i < m_iCapacity;i++)
{
    for(int k = 0;k < m_iCapacity;k++)
    {
        cout << m_pMatrix[i*m_iCapacity+k] << " ";
    }
    cout << endl;                        //每打印m_iCapacity个元素换一行
}
}
//深度优先遍历     用到了递归
void CMap::depthFirstTraverse(int nodeIndex)        //既适用于无向图也适用于有向图
{
int value = 0;
cout << m_pNodeArray[nodeIndex].m_cData << " "; //打印节点的数据域的值
m_pNodeArray[nodeIndex].m_bIsVisited = true;    //将节点的访问状态置为访问了的状态

for(int i = 0; i < m_iCapacity;i++)
{
    getValueFromMatrix(nodeIndex,i,value);
    if(value != 0)            //表示nodeIndex这个索引的节点与索引为i的节点相连
    {
        if(m_pNodeArray[i].m_bIsVisited)//已经访问过的话就避免重复访问
        {
            continue;
        }
        else
        {
            depthFirstTraverse(i);      //使用到了递归          
        } 
    }
    else
    {
        continue;
    }
}
}
//广度优先遍历    这个遍历的算法实现起来最为麻烦，要使用到下面的函数breadthFirstTraverseImpl(vector<int> preVec)
void CMap::breadthFirstTraverse(int nodeIndex)
{
cout << m_pNodeArray[nodeIndex].m_cData << " ";
m_pNodeArray[nodeIndex].m_bIsVisited = true;
vector<int> curVec;
curVec.push_back(nodeIndex);
breadthFirstTraverseImpl(curVec);
}

void CMap::breadthFirstTraverseImpl(vector<int> preVec)//vector类其实就是一个封装的数组
{
int value = 0;
vector<int> curVec;
for(int j = 0;j < (int)preVec.size(); j++) 
{
    for(int i = 0;i < m_iCapacity;i++)
    {                                                 
        getValueFromMatrix(preVec[j],i,value);//查看上一层节点与当前层节点是否有连接的
        if(value != 0)
        {
            if(m_pNodeArray[i].m_bIsVisited)
            {
                continue;
            }
            else
            {
                cout << m_pNodeArray[i].m_cData << " ";
                m_pNodeArray[i].m_bIsVisited = true;

                curVec.push_back(i);                  //把这一层存入curVec数组中
            }
        }
    }
}
if(curVec.size() == 0)             //如果该层没有点，则直接返回函数调用处，且什么都不做
{
    return;
}

else                              //若该层有点，则递归执行当前的遍历操作
{
    breadthFirstTraverseImpl(curVec);
}
}

void CMap::primTree(int nodeIndex)
{
int value = 0;
int edgeCount = 0;
vector<int> nodeVec;                       //点集合
vector<Edge> edgeVec;                      //待选表集合          

cout << m_pNodeArray[nodeIndex].m_cData << endl;

nodeVec.push_back(nodeIndex);
m_pNodeArray[nodeIndex].m_bIsVisited = true;

//先判断当前算法的终止条件
while(edgeCount < m_iCapacity-1)           //待选边的最大数目等于
{
    int temp = nodeVec.back();     //取出nodeVec向量中末尾的元素
    for(int i = 0;i < m_iCapacity;i++)
    {
        getValueFromMatrix(temp,i,value);
        if(value != 0)
        {
            if(m_pNodeArray[i].m_bIsVisited)
            {
                continue;
            }
            else
            {
                Edge edge(temp,i,value);
                edgeVec.push_back(edge);    //待选边集合
            }
        }

    }
    //从可选边集合中找出最小的边
    int edgeIndex = getMinEdge(edgeVec);
    edgeVec[edgeIndex].m_bSelected = true;

    cout << edgeVec[edgeIndex].m_iNodeIndexA << "----" << edgeVec[edgeIndex].m_iNodeIndexB << " ";
    cout << edgeVec[edgeIndex].m_iWeightValue << endl;

    m_pEdge[edgeCount] = edgeVec[edgeIndex];        //把选择的最小的边放入最小生成树的边集合中
    edgeCount++;

    int nextNodeIndex = edgeVec[edgeIndex].m_iNodeIndexB;  //通过选择的最小生成树的边找到下一个点
    nodeVec.push_back(nextNodeIndex);               //把这个点放入点集合中
    m_pNodeArray[nextNodeIndex].m_bIsVisited = true;
    cout << m_pNodeArray[nextNodeIndex].m_cData << endl;
}
}
int CMap::getMinEdge(vector<Edge> edgeVec)             //取得最小边的函数
{
int edgeIndex = 0;
int minWeight = 0;
int i = 0;                                 
for(;i < (int)edgeVec.size();i++)
{
    if(!edgeVec[i].m_bSelected)
    {
        minWeight = edgeVec[i].m_iWeightValue;
        edgeIndex = i;
        break;
    }
}

if(minWeight == 0)               //即minWeight没有改变，即上面那个if没被执行
{
    return -1;                   //返回-1，程序终止，下面的代码就不会执行了
}
for(;i < (int)edgeVec.size();i++)
{
    if(edgeVec[i].m_bSelected)
    {
        continue;
    }
    else
    {
        if(minWeight > edgeVec[i].m_iWeightValue)
        {
            minWeight = edgeVec[i].m_iWeightValue;
            edgeIndex = i;
        }
    }
}
return edgeIndex;
}

//克鲁斯卡尔算法生成树
void CMap::KruskalTree()
{

int value = 0;
int edgeCount = 0;
//定义存放节点集合的数组
vector <vector <int>> nodeSets;

//第一步：取出所有边
vector <Edge> edgeVec;
for(int i = 0;i < m_iCapacity;i++)
{
    for(int k = i+1;k < m_iCapacity;k++)
    {
        getValueFromMatrix(i,k,value);
        if(value != 0)
        {
            Edge edge(i,k,value);
            edgeVec.push_back(edge);
        }
    }
}
//第二步：从所有边中取出组成最小生成树的边
//1.找到算法的结束条件
while(edgeCount < m_iCapacity-1)
{   
    //2.从边集合中找到最小边
    int minEdgeIndex = getMinEdge(edgeVec);
    edgeVec[minEdgeIndex].m_bSelected = true;

    //3.找出最小边连接的点
    int nodeAIndex = edgeVec[minEdgeIndex].m_iNodeIndexA;
    int nodeBIndex = edgeVec[minEdgeIndex].m_iNodeIndexB;

    bool nodeAIsInSet = false;
    bool nodeBIsInSet = false;

    int nodeAInSetLabel = -1;
    int nodeBInSetLabel = -1;
    //4.找出点所在的集合
    for(int i = 0;i < (int)nodeSets.size();i++)
    {
        nodeAIsInSet = isInSet(nodeSets[i],nodeAIndex);
        if(nodeAIsInSet)
        {
            nodeAInSetLabel = i;
        }
    }

    for(int i = 0;i < (int)nodeSets.size();i++)
    {
        nodeBIsInSet = isInSet(nodeSets[i],nodeBIndex);
        if(nodeBIsInSet)
        {
            nodeBInSetLabel = i;
        }
    }
    //5.根据点所在的集合的不同做出不同处理
    if(nodeAInSetLabel == -1 && nodeBInSetLabel == -1)
    {
        vector <int> vec;
        vec.push_back(nodeAIndex);
        vec.push_back(nodeBIndex);
        nodeSets.push_back(vec);
    }

    else if(nodeAInSetLabel == -1 && nodeAInSetLabel != -1)
    {
        nodeSets[nodeBInSetLabel].push_back(nodeAIndex);
    }
    else if(nodeAInSetLabel != -1 && nodeAInSetLabel == -1)
    {
        nodeSets[nodeAInSetLabel].push_back(nodeBIndex);
    }
    else if(nodeAInSetLabel != -1 && nodeAInSetLabel != -1 && nodeAInSetLabel != nodeBInSetLabel)
    {
        mergeNodeSet(nodeSets[nodeAInSetLabel],nodeSets[nodeBInSetLabel]);
        for(int k = nodeBInSetLabel;k < (int)nodeSets.size()-1;k++)
        {
            nodeSets[k] = nodeSets[k+1];
        }
    }

    else if(nodeAInSetLabel != -1 && nodeAInSetLabel != -1 && nodeAInSetLabel == nodeBInSetLabel)
    {
        continue;
    }

    m_pEdge[edgeCount] = edgeVec[minEdgeIndex];
    edgeCount++;

    cout << edgeVec[minEdgeIndex].m_iNodeIndexA << "--" << edgeVec[minEdgeIndex].m_iNodeIndexB << "   ";
    cout << edgeVec[minEdgeIndex].m_iWeightValue << endl;
}
}

bool CMap::isInSet(vector<int> nodeSet,int target)
{
for(int i = 0;i < (int)nodeSet.size();i++)
{
    if(nodeSet[i] == target)
    {
        return true;
    }
}
return false;
}

void CMap::mergeNodeSet(vector<int> &nodeSetA,vector<int> nodeSetB)
{
for(int i = 0;i < (int)nodeSetB.size();i++)
{
    nodeSetA.push_back(nodeSetB[i]);
}
}
CodeZeal
关注
  • 51
    点赞
  • 踩
  • 230
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 数据结构
weixin_54940900的博客
01-28 1292
C++中的数组存储相同类型数据项，而结构（struct）时一种用户自定的数据类型，允许用户存储不同类型数据项。 定义结构 struct 语句格式 struct type_name { member_type1 member_name1; member_type2 member_name2; member_type3 member_name3; . . } object_names; //例如 struct Books { char title[50]; char auther[50]; char s
基于C++的图书管理系统-数据结构课设
02-07
基于C++的图书管理系统 双击目录下的“Library.exe”即可运行。注意，本软件图片数据均从网络中获取，运行本软件应确保网络正常。 运行软件，首先进入选择数据源界面，如图所示，本软件共有三个数据源，分别是： ...
c++数据结构-图（详解附算法代码，一看就懂）
我的博客
01-20 6618
有向图：边上有箭头，只能从箭头的引出的结点到被指向的结点，不能逆着箭头走。无向图：边上无箭头，可以随便走。结点的度：无向图中与结点相连的边的数量。结点的入度：有向图中以结点为终点的边的数量。结点的出度：有向图中以结点为起点的边的数量。权值：可以理解为边的长度。连通：如果结点 U 和 V 之间通过若干个边和结点能从 U 到达 V，则称 U 和 V 连通。回路：起点和终点相同的路径。
数据结构-图(c++)
快乐小半半的博客
03-26 7260
图在数据结构中有重要作用
C++数据结构--图
m0_73443478的博客
02-09 1238
C++数据结构--图
数据结构-图详解（C++图基本概念、图的存储结构、图的遍历、最小生成树Kruskal、 Prim算法、最短路径问题-Dijkstra，Bellman-Ford，Floyd-Warshall算法 ）
dodamce的博客
07-14 1548
图是由顶点集合及顶点间的关系组成的一种数据结构. 表示为 G = (V， E)。V代表的是顶点集合，E代表边集合树也是一种特殊的图，这个图无环. 树关注的时节点存的值，图更关注的是顶点及边的权值。 权值：边中的附带的数据信息.顶点和边：图中结点称为顶点，第i个顶点记作vi。两个顶点vi和vj相关联称作顶点vi和顶点vj之间有一条边，图中的第k条边记作ek，ek = (vi，vj)或.有向图：顶点对是有序的，顶点对称为顶点x到顶点y的一条边(弧)，和.....................
到现在建图还是不熟练，请看这篇（C++）
chrischen1109的博客
08-09 1523
首先，我们要了解什么是图（知道可以跳过）图就是图。首先，图由两部分组成：1.结点2.边给一个图就知道了：其次，图大致分为两种：1.有向图：就是边是有方向的 2.无向图：就是边是无方向的 再其次，结点有三个属性：1.入度：就是指向这个结点的边的数量2.出度：就是指从这个结点出发指向别的结点的边的数量3.权值：就是这个结点的值（不是编号）（无向图中所有结点的入度都等于出度）（同时，边也有可能有权值属性） （刚开始用手写板，请谅解字不好看的问题）最后，在知道了这些后，我们图的类型有多了起来：1.简单图：不存在自
SPLIT.ZIP_数据结构_Visual_C++_
08-12
5. **执行文件**（SPLIT-~1.EXE和split-jpg.exe）：这可能是项目编译生成的可执行文件，SPLIT-~1.EXE可能是编译过程中的临时文件，split-jpg.exe可能是一个用于处理图片文件的工具，与数据结构的直接关系不大，但...
zxgihbs244.rar_数据结构_C/C++_
08-09
C/C++是两种广泛使用的编程语言，它们都提供了底层控制能力，使得对数据结构的实现更加灵活且性能高效。 在“zxgihbs244.rar”这个压缩包中，我们看到有两个关键文件：“htdfe测试图片”和“z8R源代码”。结合描述...
FastDFS5.02_Setup.rar_数据结构_C/C++_
08-11
**FastDFS概述** FastDFS是一个开源的高性能、轻量级的分布式文件系统，它对文件进行...通过理解其工作原理、安装部署步骤和数据结构，以及熟练使用C/C++ API，我们可以有效地利用FastDFS构建高效稳定的文件服务系统。
图像中文字提取的程序_C++实现图片文字提取_
09-30
在图像处理领域，文字提取（Optical Character Recognition, OCR）是一项关键的技术，它允许...为了进一步提升识别准确率，可以考虑增加更多训练数据、优化特征选择、改进模型结构，或者引入更先进的深度学习技术。
C++ 图基础知识总结
nightwizard2030的博客
05-01 1374
邻接矩阵 int matrix[MAX_VERTEX][MAX_VERTEX] 邻接表 struct Side{ int index; int weight; Side* next; } struct Vertex{ char data; Side* first; } typedef Vertex AdjList[MAX_VERTEX];
数据结构之C++实现图（Graph）（无主函数）
热门推荐
manonghouyiming的博客
03-11 1万+
图：由顶点的有穷非空集合和顶点之间边的集合组成，表示为G(V,E)，V表示为顶点的集合，E表示为边的集合。两种存储方式：邻接矩阵和邻接表邻接矩阵存储：1. 存储顶点：用一个连续的空间存储n个顶点，如有5个顶点{a,b,c,d,e}，可以存储为char VertexList[] = {‘a’,’b’,’c’,’d’,’e’};2. 存储顶点之间的边：将由n个顶点组成的边用一个n*n的矩阵来存储，如果...
C++ 图系列之基于有向无环图的拓扑排序算法
y6123236的专栏
04-12 1002
有向无环图，字面而言，指图中不存在环(回路)，意味着从任一顶点出发都不可能回到顶点本身。有向无环图也称为。有向无环图可用来描述顶点之间的依赖关系，依赖这个概念在面向对象编程中经常出现。如使用B组件时，需要先有A组件，或说B组件依赖A组件，通俗言之，有A才有B。可用如下图描述。在面向对象编程的场景中，组件之间的依赖关系链中不能出现环。如现有3个组件，C依赖BB依赖于A。正确的图解应该如下图。如果在A和C添加依赖，则会出现环，在面向对象中，称此种情况为循坏依赖，显然，会导致死锁，从而让程序崩溃。图示有C。
C++(数据结构与算法):54---图的总体概述、图的各种术语、特性
董哥的黑板报
02-23 1715
接下来的几篇文章会介绍如下的内容： 图的术语：顶点、边、邻接、关联、度、回路、路径、连通构件、生成树 图的类型：无向图、有向图、加权图 图的常用描述方法：邻接矩阵、矩阵邻接表、邻接链表 图的标准搜索方法：广度优先搜索、深度优先搜索 图的算法：寻找图的路径、寻找无向图的连通构件、寻找连通无向图的生成树 一、顶点、边、有向边、无向边、有向图、无向图 简单地说，图（Graph）是...
C++ 数据结构图（1）
cat_fish_rain的博客
07-02 197
如果边带有权值，并且两个节点之间是连通的，上图中的边的关系就用权值代替，如果两个。用邻接矩阵存储图的有点是能够快速知道两个顶点是否连通，缺陷是如果顶点比较多，边比。对应的邻接表所含结点的个数，就是该顶点的出度，也称出度表，要得到vi。顶点的入度，必须检测其他所有顶点对应的边链表，看有多少边顶点的dst。的一条单向通路，即 Path(x, y)是有方向的。成为系数矩阵，比较浪费空间，并且要求两个节点之间的路。因为节点与节点之间的关系就是连通与否，即为。邻接表：使用数组表示顶点的集合，节点与节点之间的关系。
c++图形结构
2301_76145087的博客
08-12 170
它从图中某个顶点v出发，访问此顶点，然后从v的未被访问的邻接点出发深度优先遍历图，直至图中所有和v 有路径相通的顶点都被访问到。如果说图的深度优先遍历类似树的前序遍历， 那么图的广度优先遍历就类似于树的层序遍历了。
数据结构--图（C++）
m0_49752107的博客
07-30 353
数据结构--图（C++）图的基本概念图结构的存储邻接矩阵邻接矩阵的存储结构创建一个邻接矩阵图邻接表邻接表的存储结构创建一个邻接表十字链表链接多重表图的遍历邻接矩阵的广度优先搜索邻接矩阵的深度优先搜索邻接表的广度优先搜索邻接表的深度优先搜索图的应用最小生成树1.Prim算法2.Kruskal算法最短路径1.Dijkstra算法2.Floyd算法拓扑排序关键路径 图的基本概念 图的定义，图由顶点集V和边集E组成，记为G=(V,E),其中V={v1,v2,v3,……，v（n）}，E={(u,v)|u∈V，v∈V}
数据结构c++ md
最新发布
01-29
数据结构C，MD（Markdown）是一种用于描述和编辑文本的轻量级标记语言。在数据结构中，C语言是一种常用的编程语言，用于实现各种数据结构和算法。 在数据结构中使用C语言编写代码可以提高程序的效率和性能。C语言有指针和内存管理的特性，可以更灵活地操作数据结构。同时，C语言也有丰富的标准库和丰富的数据类型，可以更方便地实现各种数据结构，如数组、链表、栈、队列、树、图等。 而MD（Markdown）是一种易于编写和阅读的标记语言，可以用于写作文档和笔记。MD语言使用简单的符号来标记文本的格式，如标题、段落、列表、链接、图片等。这种轻量级的标记语言非常适合用于记录数据结构的学习笔记和代码的文档。 总的来说，数据结构C，MD组合可以让我们更高效地学习数据结构，并且更好地实现和记录数据结构相关的代码。通过使用C语言来实现数据结构和算法，我们可以更深入地理解数据结构的原理和实现方式；通过使用MD语言来记录学习笔记和代码文档，我们可以更清晰地表达思路和分享代码。这种组合能够提高我们对数据结构的学习和应用水平。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值