数据结构与算法/图的应用

最新推荐文章于 2024-06-30 15:13:01 发布
最新推荐文章于 2024-06-30 15:13:01 发布
阅读量4.3k 收藏 4
点赞数
分类专栏： C/C++数据结构与算法学习阶段2017.9~2017.12 文章标签： CC 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/li99yangg/article/details/79100716
版权

//注：我这段代码预先输入好了值，图有机会贴上来

1、掌握图的各种存储结构的特点及适用范围。

2、掌握建立图的方法。（包括邻接矩阵、邻接表）

3、熟练掌握图的深度优先搜索算法和广度优先搜索算法，并能灵活运用这两个算法解决实际问题。

实现上述两个功能时要求图分别用邻接矩阵和邻接表表示。求简单路径问题，可利用图得深度优先搜索遍历算法实现，从顶点 i 出发，开始遍历，访问到顶点 j 时遍历结束。在遍历的过程中，需要将访问过的顶点压入栈，当在遍历过程中遇到一个访问过的顶点 k 时，需要依次删除栈中元素，直到栈顶为 k。遍历结束后，将栈中的顶点倒着输出即为顶点 i 到顶点 j 的简单路径。

 求最短路径问题，可利用图得广度优先搜索遍历算法实现，为实现图得广度优先搜索算法，需要用到队列。

#include <stdio.h>

#include <iostream>

#include <setjmp.h>

using namespace std;

#define MaxInt 32767//表示正无穷

#define MVNum 100//最大顶点数

#define OK 1

#define ERROR -1

#define OVERFLOW -2

jmp_buf j;

typedef int Status;

typedef char VerTexType;//假设顶点的数据类型为字符型

typedef int ArcType;//假设边的权值类型为整型

typedef int OtherInfo;

typedef struct QNode

{

    VerTexType data;

    struct QNode *next;

}QNode,*QueuePtr;

typedef struct

{

    QueuePtr front;

    QueuePtr rear;

}LinkQueue;

typedef struct

{

    VerTexType vexs[MVNum];//顶点表

    ArcType arcs[MVNum][MVNum];//邻接矩阵

    int vexnum,arcnum;//图的当前点数和边数

}AMGraph;

 

typedef struct stack

{

    VerTexType *base;

    VerTexType *top;

    int stacksize;

}SqStack;

typedef struct ArcNode

{

    int adjvex;//该边所指向的顶点的位置

    struct ArcNode *nextarc;//指向下一条边的指针

    OtherInfo info;//边的信息

}ArcNode;

typedef struct VNode

{

    VerTexType data;

    ArcNode *firstarc;//指向第一条依附该顶点的边的指针

}VNode,AdjList[MVNum];//表示邻接表类型

typedef struct

{

    AdjList vertices;//图的当前顶点数和边数

    int vexnum,arcnum;

}ALGraph;

int path[6][6];

bool isVisited[MaxInt];

SqStack S;

LinkQueue Q;

int D[6][6];

int anopath[6][6];

char PreChar[6]={'a','b','c','d','e','f'};

//void DFS_AM(AMGraph &G,VerTexType v1,VerTexType v2);

void InitQueue(LinkQueue &Q )//初始化队列

{

    Q.front = Q.rear = new QNode;

    Q.front->next = NULL;

    return;

}

 

void EnQueue( LinkQueue &Q, VerTexType x)//尾插法入队，将x存储在Q链表的尾部

{

    QNode *p = new QNode;    //申请新结点

    p->data=x; //将x存入p中的数据域

    p->next = NULL;

    Q.rear->next = p;

    Q.rear = p;

    return;

}

int DeQueue( LinkQueue &Q,VerTexType &x)//出队操作，将在最前面的元素出队

{

    if(Q.front == Q.rear)return 0;

    QNode *p=Q.front->next;//将Q的队列头元素地址赋给p

    //p 指向将要摘下的结点

    x=p->data; //保存结点中数据

    Q.front->next = p->next;//令p的下一节点指向第一个元素

    if (p==Q.rear)//如果队列为空

    {

        Q.rear = Q.front;//当队列中只有一个结点时，p 结点出队后， 要将队尾指针指向头结点

    }

    delete p;//释放被删结点

    return 1;

}

void ShowQueue(LinkQueue &Q)//显示所有元素

{

    if(Q.front->next == NULL)//如果队列中无元素

    {

        printf("无元素");

        return;

    }

    QNode* p=Q.front->next;//令p指针指向第一个元素

    do//当p遍历所有结点时

    {

        printf("%c ",p->data);//输出队列中所有元素

        p = p->next;//p指向下一元素

    }while(p!=Q.rear->next);

    getchar();

    return;

}

Status CreateUDN (AMGraph &G)//用邻接矩阵创建有向网P154 图6.10(a)

{

    G.vexnum = 6;

    G.arcnum = 10;

    cout<<"总点数为："<<G.vexnum<<endl;

    cout<<"总边数为："<<G.arcnum<<endl;

    cout<<"依次输入点的信息："<<endl;

    G.vexs[0] = 'a';//v1

    G.vexs[1] = 'b';//v2

    G.vexs[2] = 'c';//v3

    G.vexs[3] = 'd';//v4

    G.vexs[4] = 'e';//v5

    G.vexs[5] = 'f';//v6

    for(int i = 0;i<G.vexnum;i++)

        cout<<G.vexs[i]<<endl;

    for(int i = 0;i<G.vexnum;i++)//初始化邻接矩阵使边的权值均为MAXINT

        for(int j = 0;j<G.vexnum;j++)

            G.arcs[i][j] = MaxInt;

    G.arcs[0][1] = 5;G.arcs[0][3] = 7;

    G.arcs[1][2] = 4;G.arcs[2][0] = 8;

    G.arcs[2][5] = 9;G.arcs[3][2] = 5;

    G.arcs[3][5] = 6;G.arcs[4][3] = 5;

    G.arcs[5][0] = 3;G.arcs[5][4] = 1;

 

    for(int i =0;i<G.vexnum;i++)

    {

        for(int j = 0;j<G.vexnum;j++)

        {

            cout<<"\t"<<G.arcs[i][j];

        }

        cout<<endl;

    }

    return OK;

}

Status InitStack (SqStack &S)

{

    S.base = new VerTexType[100];

    if(!S.base)cout<<"ERROR";

    S.top = S.base;

    S.stacksize = 100;

    return OK;

}

Status Push(SqStack &S,VerTexType e)

{

    if(S.top - S.base == S.stacksize)return ERROR;

    *S.top++ = e;

    return OK;

}

Status Pop(SqStack &S,VerTexType &e)

{

    if(S.top == S.base)return 0;

    VerTexType *temp;

    temp = S.top;

    S.top--;

    delete temp;

    e = *S.top;

    return OK;

}

void ShowStack(SqStack &S)

{

    VerTexType *top = S.top;

    while(S.base != top)

    {

        cout<<*(--top)<<" ";

    }

    cout<<"over "<<endl;

}

int GetIndex(AMGraph &G,VerTexType v)

{

    int index = -1;

    for(int i=0;i<G.vexnum;i++)

    {

        if(v == G.vexs[i]){return i;}//获取v1下标

    }

    return index;

}

void DFS_AM(AMGraph &G,VerTexType v1,VerTexType v2)

{

    Push(S,v1);

    if(v1 == v2)

    {

        longjmp(j,1);

    }

    isVisited[GetIndex(G,v1)] = true;

    for(int w = 0;w<G.vexnum;w++)

    {

        if(G.arcs[GetIndex(G,v1)][w]!=MaxInt && (isVisited[w]==false))DFS_AM(G,G.vexs[w],v2);

    }

 

}

void CreateAdjList(ALGraph &G)

 {

     G.vexnum = 6;G.arcnum=10;

     for(int i =0;i<G.vexnum;i++)

     {

            G.vertices[i].data = PreChar[i];//输入顶点值

            G.vertices[i].firstarc = NULL;

            G.vertices[i].firstarc = new ArcNode;G.vertices[i].firstarc->nextarc = new ArcNode;G.vertices[i].firstarc->nextarc->nextarc = new ArcNode;G.vertices[i].firstarc->nextarc->nextarc->nextarc = new ArcNode;G.vertices[i].firstarc->nextarc->nextarc->nextarc->nextarc = new ArcNode;

     }

    G.vertices[0].firstarc->adjvex = 1;G.vertices[0].firstarc->info = 3;G.vertices[0].firstarc->nextarc->adjvex = 4;G.vertices[0].firstarc->nextarc->info = 4;G.vertices[0].firstarc->nextarc->nextarc = NULL;

    G.vertices[1].firstarc->adjvex = 0;G.vertices[1].firstarc->info = 3;G.vertices[1].firstarc->nextarc->adjvex = 4;G.vertices[1].firstarc->nextarc->info = 9;G.vertices[1].firstarc->nextarc->nextarc->adjvex = 5;G.vertices[1].firstarc->nextarc->nextarc->info = 5;G.vertices[1].firstarc->nextarc->nextarc->nextarc->adjvex = 2;G.vertices[1].firstarc->nextarc->nextarc->nextarc->info = 4;G.vertices[1].firstarc->nextarc->nextarc->nextarc->nextarc = NULL;

    G.vertices[2].firstarc->adjvex = 3;G.vertices[2].firstarc->info = 2;G.vertices[2].firstarc->nextarc->adjvex = 5;G.vertices[2].firstarc->nextarc->info = 7;G.vertices[2].firstarc->nextarc->nextarc->adjvex = 1;G.vertices[2].firstarc->nextarc->nextarc->info = 4;G.vertices[2].firstarc->nextarc->nextarc->nextarc = NULL;

    G.vertices[3].firstarc->adjvex = 2;G.vertices[3].firstarc->info = 2;G.vertices[3].firstarc->nextarc->adjvex = 5;G.vertices[3].firstarc->nextarc->info = 6;G.vertices[3].firstarc->nextarc->nextarc->adjvex = 4;G.vertices[3].firstarc->nextarc->nextarc->info = 2;G.vertices[3].firstarc->nextarc->nextarc->nextarc = NULL;

    G.vertices[4].firstarc->adjvex = 0;G.vertices[4].firstarc->info = 4;G.vertices[4].firstarc->nextarc->adjvex = 1;G.vertices[4].firstarc->nextarc->info = 9;G.vertices[4].firstarc->nextarc->nextarc->adjvex = 3;G.vertices[4].firstarc->nextarc->nextarc->info = 2;G.vertices[4].firstarc->nextarc->nextarc->nextarc->adjvex = 5;G.vertices[4].firstarc->nextarc->nextarc->nextarc->info = 2;G.vertices[4].firstarc->nextarc->nextarc->nextarc->nextarc = NULL;

    G.vertices[5].firstarc->adjvex = 1;G.vertices[5].firstarc->info = 5;G.vertices[5].firstarc->nextarc->adjvex = 2;G.vertices[5].firstarc->nextarc->info = 7;G.vertices[5].firstarc->nextarc->nextarc->adjvex = 3;G.vertices[5].firstarc->nextarc->nextarc->info = 6;G.vertices[5].firstarc->nextarc->nextarc->nextarc->adjvex = 4;G.vertices[5].firstarc->nextarc->nextarc->nextarc->info = 2;G.vertices[5].firstarc->nextarc->nextarc->nextarc->nextarc = NULL;

 

     for(int i = 0;i<G.vexnum;i++)

    {

        cout<<i<<"\t"<<G.vertices[i].data<<"\t->";

        ArcNode *p = G.vertices[i].firstarc;

        while(p!=NULL)

        {

            cout<<"\t"<<p->adjvex<<"\t"<<p->info<<"\t";

            p = p->nextarc;

 

        }

        cout<<endl;

    }

 

}

//a->e  最短4 最长3+9 = 12

int GetIndex1(ALGraph G,VerTexType v)

{

    for(int i = 0 ;i<G.vexnum;i++)

    {

        if(G.vertices[i].data == v)return i;

    }

    cout<<"wrong index";

}

Status CreateMatrix (ALGraph &G)

{

    for( int i = 0;i<G.vexnum;i++)

    {

        ArcNode *p = G.vertices[i].firstarc;

        while(p!=NULL)

        {

            int j = p->adjvex;

            path[i][j] = p->info;

//            cout<<"path"<<i<<j<<"="<<path[i][j];

            p = p->nextarc;

        }

 

    }

    cout<<endl;

 

 

}

 

void ShortertPath_Floyd(ALGraph &G)

{

for(int i = 0;i<G.vexnum;i++)

    {

        for(int j = 0;j<G.vexnum;j++)

            {

                if(i!=j&&path[i][j]==0)path[i][j]=100;

            }

        cout<<endl;

    }

    for(int  i =0;i<G.vexnum;i++)

        {

            for(int j=0;j<G.vexnum;j++)

            {

                D[i][j] = path[i][j];

                if(D[i][j]<100&&i!=j)anopath[i][j]= i;

                else anopath[i][j] = -1;

            }

        }

//    for(int i = 0;i<G.vexnum ;i++)

//    {

//        for(int j = 0;j<G.vexnum;j++)

//            cout<<anopath[i][j]<<"\t";

//            cout<<endl;

//    }

    for(int k = 0;k<G.vexnum;++k)

        {

            for(int i = 0;i<G.vexnum;++i)

            for(int j = 0;j<G.vexnum ;++j)

            {

                if(D[i][k]+D[k][j]<D[i][j])

                    {

//                        cout<<D[i][j];

                        D[i][j] = D[i][k]+D[k][j];

//                        cout<<D[i][j]<<endl;

                    anopath[i][j] = anopath[k][j];

                    }

            }

 

        }

 

}

 

 

 

int main()

{

    //邻接矩阵部分

    InitQueue (Q) ;

    AMGraph G;

    InitStack(S);

    CreateUDN(G);

 

    if(setjmp(j) == 0)

    {

        DFS_AM(G,G.vexs[1],G.vexs[0]);

    }

    else

    {

    }

    char ch[100];

    int flag = 0;

    cout<<"从"<<*S.base<<"到"<<*(S.top-1)<<"的路径为：";

    while(S.top!=S.base)

    {

        Pop(S,ch[flag]);

    //        cout<<ch[flag]<<" ";

        flag++;

    }

 

    for(int i = flag;i>=0;i--)

    {

        cout<<ch[i]<<" ";

    }

    cout<<endl;

    //邻接表部分

    for(int i = 0;i<10;i++)//初始化isvisited数组

    {

        isVisited[i]=false;

    }

    ALGraph GG;

    CreateAdjList(GG);

    for(int i = 0;i<GG.vexnum;i++)

    {

        cout<<i<<"\t"<<GG.vertices[i].data<<"\t->";

        ArcNode *p = GG.vertices[i].firstarc;

        while(p!=NULL)

        {

            cout<<"\t"<<p->adjvex<<"\t"<<p->info<<"\t";

            p = p->nextarc;

        }

        cout<<endl;

    }

    CreateMatrix(GG);

 

    ShortertPath_Floyd(GG);

                cout<<"D[i][j]图如下："<<endl;

    for(int i = 0;i<G.vexnum ;i++)

    {

        for(int j = 0;j<G.vexnum;j++)

            cout<<D[i][j]<<"\t";

            cout<<endl;

    }

    int i = 1,j = 5;

    cout<<"从"<<i+1<<"到"<<j+1<<"的最短路径长度为："<<D[i][j];

    return 0;

 

}



逐烟
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法必知基础知识
bigsai
01-06 1万+
原创公众号：bigsai 文章已收录在 全网都在关注的数据结构与算法学习仓库 欢迎star 前言 数据结构与算法是程序员内功体现的重要标准之一，且数据结构也应用在各个方面，业界更有程序=数据结构+算法这个等式存在。各个中间件开发者，架构师他们都在努力的优化中间件、项目结构以及算法提高运行效率和降低内存占用，在这里数据结构起到相当重要的作用。此外数据结构也蕴含一些面向对象的思想，故学好掌握数据结构对逻辑思维处理抽象能力有很大提升。 为什么学习数据结构与算法？如果你还是学生，那么这门课程是必修的，考研基本也.
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 33万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
数据结构与算法之图的应用
FriendshipTang的博客
12-28 2658
数据结构与算法学习笔记8：图图的定义和基本概念图的实现数组〈邻接矩阵〉邻接表图的遍历图的典型应用最小生成树最短路径拓扑排序关键路径 图的定义和基本概念 图的实现 数组〈邻接矩阵〉 邻接表 图的遍历 图的典型应用 最小生成树 最短路径 拓扑排序 关键路径 ...
【408考点之数据结构】图的应用
最新发布
gygkhd的博客
06-30 505
在社交网络中，图的节点表示用户，边表示用户之间的关系（如好友关系、关注关系）。例如，使用图的遍历算法可以找到某个用户的朋友及其朋友的朋友，进行推荐系统的设计。例如，在 GPS 导航中，通过图的最短路径算法（如 Dijkstra 算法），可以为用户规划最优的行车路线。网络模型是图应用的经典例子。在网络模型中，节点表示网络中的设备或计算机，边表示这些设备之间的通信连接。：使用 Dijkstra 算法求解，将交通网络表示为带权图，起点 A 作为源点，终点 B 作为目标，计算从 A 到 B 的最短路径。
数据结构与算法（总结）
weixin_45397053的博客
04-23 5万+
总结： 一、数据结构（Data Structure） 是数据的组织结构，用来组织、存储数据。算法（Algorithm） 就是解决问题的方法或者过程。 二、数据结构分为逻辑结构和物理结构。逻辑结构分为集合结构、线性结构、树形结构、图形结构；物理结构分为顺序存储结构、链式存储结构。 三、算法是一系列运算步骤。算法有5个基本特性，输入、输出、有穷性、确定性、可行性；算法最求5个目标，正确性、可读性、健壮性、运行时间少、内存空间小。 四、「数组」 是实现线性表的顺序结构存储的基础；「链表」 是实现线性表的链式存储结
数据结构与算法——知识点总结
记录知识，学习分享
06-02 2万+
本文包含数据结构与算法主要的基本知识点，便于知识的梳理和回顾。 如需详细了解具体知识点请自行结合课本或者网上查阅。 目录 1、概述 2、线性表 3、栈 4、队列 5、串 6、多维数组和广义表 7、树和二叉树 8、图 9、查找 10、排序 1、概述 从 2、线性表 3、栈 4、队列 5、串 6、多维数组和广义表 7、树和二叉树 8、图 9、查找 10、排序 ...
数据结构与算法（C++实现）
weixin_45216861的博客
03-06 5778
1.常见算法 1.最基础的算法-swap(交换) 1.1 swap语法： int main() { int a=1,b=10,temp; temp=a; a=b; b=temp; cout<<"a="<<a<<" b="<<b<<endl; system("pause"); return 0; } 1.2 值传递方式（不成功）： void swap1(int x,int y); int main() { int a,b;
数据结构与算法（java版）
Y2483490891的博客
12-25 1367
数据结构是指在计算机中组织和存储数据的方式。它关注数据的逻辑关系、操作和存储方式，以及如何有效地访问和修改数据。常见的数据结构包括数组、链表、栈、队列、树、图等。算法是解决问题的一系列步骤或规则。它描述了如何通过输入数据来产生所需的输出结果。算法可以用来执行各种计算任务，如排序、搜索、图形处理等。好的算法应该具有正确性、可读性、高效性和健壮性。数据结构和算法之间存在密切的关系。选择合适的数据结构可以提高算法的效率，而好的算法可以更好地利用数据结构的优势。
【超全汇总】学习数据结构与算法，计算机基础知识，看这篇就够了
帅地
01-18 10万+
由于文章有点多，并且发的文章也不是一个系列一个系列发的，不过我的文章大部分都是围绕着 数据结构 + 算法 + 计算机网络 + 操作系统 + Linux + 数据库 这几个方面发的，为了方便大家阅读，我整理了一波。不过公众号可以说是不支持修改文章，因为我决定每两三个月就整理一次，会非常详细着按照类别整理出来哦，并且也给出了目录哦。大家记得多看看哦，好多文章都是面试中常问滴 文章目录一、经验/经历/所...
数据结构中算法的应用
萌兔兔MMQ！！
05-01 1038
数据结构中最基本的算法有：查找、排序、快速排序，堆排序，归并排序，，二分搜索算法 等等。 1、用的最多也是最简单的数据结构是线性表。 2、有前途的又难数据结构是图 。 3、常用的80％算法是排序和查找。 排序常用的算法有：插入算法（直接插入算法、折半插入算法、希尔算法）、选择算法（简单选择算法、堆排序算法）、快速算法(冒泡排序、快速排序算法) 以下程序给出了各种算法的实现，其接口为void sort(int *array,int len),每个文件实现一个算法， 最后和main.c文件编译实现。 1、直接插
数据结构与算法：发展、应用与未来趋势
禅与计算机程序设计艺术
04-28 1万+
数据结构与算法是计算机科学的基石，它们参与并支持着计算机系统日复一日的工作。本文概述了数据结构与算法的基本概念，关系，现状，应用，以及未来发展趋势，从而提供一个全面了解这门学科的机会。
java数据结构与算法.pdf
01-04
在编程领域，数据结构与算法是核心组成部分，它们直接影响到程序的效率和性能。Java作为广泛应用的编程语言，其在实现数据结构和算法时有着丰富的库支持和优秀的可读性。下面将对标题和描述中提到的一些关键知识点...
C++/数据结构与算法/企业管理/啾咪
01-06
在这个“C++/数据结构与算法/企业管理/啾咪”项目中，我们可能涉及到如何使用C++来实现各种数据结构和算法，并将这些技术应用到企业管理的实际场景中。 数据结构是指组织和存储数据的方式，包括数组、链表、栈、...
数据结构与算法分析--C语言描述_数据结构与算法_
10-01
数据结构与算法是计算机科学的基础，对于理解和设计高效的软件至关重要。C语言因其高效、底层特性，常被用于实现数据结构和算法，使得程序更接近硬件，性能更优。本资源"数据结构与算法分析--C语言描述"是针对数据...
JS数据结构与算法.pdf
11-01
JS 数据结构与算法.pdf 本书主要介绍了 JavaScript 语言的基础知识，包括数据结构和算法。以下是该书的详细知识点： 一、JavaScript 基础知识 * 变量和数据类型 * 运算符和控制结构 * 函数和对象 * 数组和字符串 ...
数据结构和算法PDF文档
06-02
1000多页的算法题解，包含数据结构，排序，查找，递归，回溯算法，二叉树，动态规划，贪心算法，双指针，滑动窗口，前缀和等。
数据结构与算法/哈夫曼编码译码器
li99yangg的博客
01-18 3896
（1）输入一个需要压缩的文本文件名，统计该文件中各字符的个数作为权值，生成赫夫树。（2）将文本文件利用赫夫曼树为每个字符进行编码，生成编码文件（文件扩展名为.cod）。（3）输入一个待解压缩的压缩文件名，并利用相应的赫夫曼树将编码序列译码（解码）。（4）显示指定的编码文件和文本文件。（5）把赫夫曼编码用二进制位紧缩到一个变量中，利用位运算进行真正的数据压缩，并求压缩比。#include#inclu
C/C++数据结构通过顺序栈实现括号()匹配算法
li99yangg的博客
10-08 3669
#include #include #include #include #include #define OK 1 #define ERROR 0 #define MAXSIZE 100 typedef char ElemType; typedef int Status; typedef struct stack//创建顺序栈 {     ElemType  *b
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值