圖的基本運算及智能交通中的最佳路徑問題

本實驗代碼已更新，因改動本文內容較大未上傳，若是須要相關代碼，記得私信博主或下方評論哦~

實驗一：已知圖的鄰接矩陣結構定義，編寫程序完成鄰接矩陣的初始化、撤銷、邊的搜索、邊的插入、刪除等操做。

借鑑：https://blog.csdn.net/qq_37360631/article/details/80482044

鄰接矩陣.h

#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct{
    ElemType **a;   //鄰接矩陣 
    int n;      //圖的頂點數 
    int e;      //圖當前的邊數 
    ElemType noEdge;    //兩頂點無邊時的值 
}mGraph;
//初始化,nSize頂點數,noEdgeValue無邊的值 
int Init(mGraph *mg,int nSize,ElemType noEdgeValue); 
//撤銷操做，撤銷的時候順序不能變，先釋放指針數組就會找不到數組指針啦 
int Destory(mGraph *mg);
//邊的搜索操做，判斷邊在不在圖中 
int Exist(mGraph *mg,int u,int v) ;
//邊的插入
int Insert(mGraph *mg,int u,int v,ElemType w);
//邊的刪除
int Remove(mGraph *mg,int u,int v);

鄰接矩陣.cpp

#include"鄰接矩陣.h"
#include<iostream.h>
//初始化,nSize頂點數,noEdgeValue無邊的值 
int Init(mGraph *mg,int nSize,ElemType noEdgeValue){
    int i,j;
    mg->n=nSize;
    mg->e=0;        //初始化沒有邊 
    mg->noEdge=noEdgeValue;
    mg->a=(ElemType**)malloc(nSize*sizeof(ElemType*));  //生成長度爲n的一維數組指針
    if(!mg->a) return 0;
    for(i=0;i<mg->n;i++){
        mg->a[i]=(ElemType*)malloc(nSize*sizeof(ElemType));
        for(j=0;j<mg->n;j++) mg->a[i][j]=mg->noEdge;
        mg->a[i][i]=0;                                  //自迴路設置爲0 
    } 
    return 1;
} 
//撤銷操做
int Destory(mGraph *mg){
    int i;
    for(i=0;i<mg->n;i++) free(mg->a[i]);    //釋放n個一維數組存儲空間 
    free(mg->a);                                //釋放n個一維指針數組的存儲空間 
    return 1;
} 
//邊的搜索操做，判斷邊在不在圖中 
int Exist(mGraph *mg,int u,int v){
    if(u<0||v<0||u>mg->n-1||v>mg->n-1||u==v||mg->a[u][v]==mg->noEdge){
        cout<<"這條邊不存在."<<endl;
        return 0;
    }
    cout<<"這條邊存在."<<endl; 
    cout<<"這條邊的長度爲:"<<mg->a[u][v]<<endl;
    return 1;
} 
//邊的插入
int Insert(mGraph *mg,int u,int v,ElemType w){
    if(u<0||v<0||u>mg->n-1||v>mg->n-1||u==v) return 0;
    if(mg->a[u][v]!=mg->noEdge) {
        cout<<"該邊已存在."<<endl;
        return 0; 
    }
    mg->a[u][v]=w;
    mg->e++;
    return 1;
} 

//邊的刪除
int Remove(mGraph *mg,int u,int v){
    if(u<0||v<0||u>mg->n-1||v>mg->n-1||u==v)
    return 0;
    if(mg->a[u][v]==mg->noEdge) return 0;   //刪除的邊不存在
    mg->a[u][v]=mg->noEdge;
    mg->e--;
    return 1; 
} 

int main(){
    mGraph mg;
    int n,n1,u,v,w,a,b;
//  fangxin();
//  fx();
    cout<<"請輸入頂點的個數："<<endl;
    cin>>n;         
    Init(&mg,n,0);
    cout<<"請輸入插入邊的個數:"<<endl;
    cin>>n1;
    cout<<"請輸入插入邊的起點(頂點計算從0開始)、終點和邊權:"<<endl;
    for(int i=0;i<n;i++){
        cout<<"第"<<i+1<<"條"<<endl;
        cin>>u>>v>>w;
        Insert(&mg,u,v,w);
    }
    cout<<"請輸入查找的邊的兩個端點:"<<endl;
    cin>>a>>b;
    Exist(&mg,a,b);
    Destory(&mg);
    Remove(&mg,0,1);
    return 0;
} 

分析：    1.首先這些代碼建立的是一個帶權的有向圖；

　　　　2.插入邊的時候，是以邊帶點的建立；

　　　　3.查詢後，程序會死掉。

將實驗1、2、3、四結合起來：

實驗二：編寫程序，實現圖的深度和寬度優先遍歷。

實驗三：編寫程序完成鄰接表的的初始化、撤銷、邊的搜索、插入、刪除等操做。

實驗四：編寫程序，實現圖的深度和寬度優先遍歷。

#include<iostream.h>
const int INFTY=2147483640;
enum Result{Underflow,Duplicate,ERROR,OK,NotPresent};//枚舉了全部可能的結果

template<class T>
class Graph               //定義抽象類
{
    public:
        virtual Result Insert(int u,int v,T &w)=0;//建立邊
        virtual Result Remove(int u,int v)=0;//刪除邊
        virtual bool Exist(int u,int v)const=0;//判斷邊是否存在
    protected:
        int n;
        int e;
};

template<class T>
class SeqQueue
{
    public:
        SeqQueue(int mSize);
        ~SeqQueue()
        {
            delete []q;
        }
        bool isEmpty() const{return rear==front;}
        bool isFull() const{return (rear+1)%maxSize==front;}
        bool Front(T &x)const;
        bool EnQueue(T x);
        bool DeQueue();
        void Clear(){front=rear=0;}
    private:
        int front,rear;
        int maxSize;
        T *q;
};
template<class T>
SeqQueue<T>::SeqQueue(int mSize)  //構造函數
{
    maxSize=mSize;
    q=new T[maxSize];
    front=rear=0;
}
template<class T>
bool SeqQueue<T>::Front(T &x)const   //取出隊首元素
{
    if(isEmpty())
    {
        cout<<"是空的"<<endl;
        return false;
    }
    x=q[(front+1)%maxSize];
    return true;
}
template<class T>
bool SeqQueue<T>::EnQueue(T x)     //在隊尾插入元素x
{
    if(isFull())
    {
        cout<<"已經滿了哦"<<endl;
        return false;
    }
    q[rear=(rear+1)%maxSize]=x;
    return true;
}
template<class T>
bool SeqQueue<T>::DeQueue() //刪除隊首元素
{
    if(isEmpty())
    {
        cout<<"Underflow"<<endl;

        return false;
    }
    front=(front+1)%maxSize;
    return true;
}

template<class T>
class mGraph:public Graph<T>    //鄰接矩陣類
{
    public:
        mGraph();
        mGraph(int mSize,const T& noedg);
        ~mGraph();
        Result Insert(int u,int v,T &w);//建立邊
        Result Remove(int u,int v);//刪除邊
        bool Exist(int u,int v)const;//判斷邊是否存在
        void DFS();//深度優先遍歷
        void BFS();//寬度優先遍歷
    private:
        T **a;
        T noEdge;
        void DFS(int v,bool *visited);
        void BFS(int v,bool *visited);
};

template<class T>
mGraph<T>::mGraph(int mSize,const T& noedg)   //鄰接矩陣的構造函數
{
    n=mSize;
    e=0;
    noEdge=noedg;
    a=new T*[n];
    for(int i=0;i<n;i++)
    {
        a[i]=new T[n];
        for(int j=0;j<n;j++)
            a[i][j]=noEdge;
        a[i][j]=0;
    }
}
template<class T>
mGraph<T>::~mGraph()                        //鄰接矩陣的析構函數
{
    for(int i=0;i<n;i++)   
        delete []a[i];
    delete []a;
}
template<class T>
Result mGraph<T>::Insert(int u,int v,T &w)  //插入
{
    if(u<0||v<0||u>n-1||u==v)
        return ERROR;
    if(a[u][v]!=noEdge)
        return Duplicate;
    a[u][v]=w;
    e++;
    return OK;
}
template<class T>
Result mGraph<T>::Remove(int u,int v)       //刪除
{
    if(u<0||v<0||u>n-1||u==v)
        return ERROR;
    if(a[u][v]==noEdge)
        return NotPresent;
    a[u][v]=noEdge;
    e--;
    return OK;
}
template<class T>
bool mGraph<T>::Exist(int u,int v)const      //判斷邊是否存在
{
    if(u<0||v<0||u>n-1||u==v||a[u][v]==noEdge)
        return false;
    return true;
}
template<class T>
void mGraph<T>::DFS()
{
    bool *visited=new bool[n];
    for(int i=0;i<n;i++)
        visited[i]=false;                  //預設全部結點均未被訪問過
    for(i=0;i<n;i++)
        if(!visited[i])
            DFS(i,visited);
    delete []visited;
}
template<class T>
void mGraph<T>::DFS(int v,bool *visited)
{
    visited[v]=true;
    cout<<" "<<v;
    for(int i=0;i<n;i++)
        if(a[v][i]!=noEdge&&a[v][i]!=0&&!visited[i])
            DFS(i,visited);
}
template<class T>
void mGraph<T>::BFS()
{
    bool *visited=new bool[n];
    for(int i=0;i<n;i++)
        visited[i]=false;                  //預設全部結點均未被訪問過
    for(i=0;i<n;i++)
        if(!visited[i])
            BFS(i,visited);
    delete []visited;
}
template<class T>
void mGraph<T>::BFS(int v,bool *visited)
{
    SeqQueue<int>q(n);
    visited[v]=true;
    cout<<" "<<v;
    q.EnQueue(v);
    while(!q.isEmpty())
    {
        q.Front(v);
        q.DeQueue();
        for(int i=0;i<n;i++)
            if(a[v][i]!=noEdge&&a[v][i]!=0&&!visited[i])
            {
                visited[i]=true;
                cout<<" "<<i;
                q.EnQueue(i);
            }
    }
}
template<class T>    //結點類
class ENode
{
    public:
        ENode(){nextArc==NULL;}
        ENode *nextArc;
        ENode(int v,T wei,ENode *next)
        {
            adjVex=v;
            w=wei;
            nextArc=next;
        }
        int adjVex;
        T w;
        
};
template<class T>
class LGraph:public Graph<T>       //鄰接表類
{
    public:
        LGraph(int mSize);
        ~LGraph();
        Result Insert(int u,int v,T &w);//建立邊
        Result Remove(int u,int v);//刪除邊
        bool Exist(int u,int v)const;//判斷邊是否存在
    protected:
        ENode<T>**a;
};
template<class T>
LGraph<T>::LGraph(int mSize)  //鄰接表的構造函數
{
    n=mSize;
    e=0;
    a=new ENode<T> *[n];
    for(int i=0;i<n;i++)
        a[i]=NULL;
}

template<class T>
LGraph<T>::~LGraph()                        //鄰接表的析構函數
{
    ENode<T>*p,*q;
    for(int i=0;i<n;i++)   
    {
        p=a[i];
        q=p;
        while(p)
        {
            p=p->nextArc;
            delete q;
            q=p;
        }
    }
    delete []a;
}
template<class T>
bool LGraph<T>::Exist(int u,int v)const      //判斷邊是否存在
{
    if(u<0||v<0||u>n-1||u==v)
        return false;
    ENode<T>*p=a[u];
    while(p&&p->adjVex!=v)
        p=p->nextArc;
    if(!p)
        return false;
    else return true;
}
template<class T>
Result LGraph<T>::Insert(int u,int v,T&w)       //插入
{
    if(u<0||v<0||u>n-1||u==v)
        return ERROR;
    if(Exist(u,v))
        return Duplicate;
    ENode<T>*p=new ENode<T>(v,w,a[u]);
    a[u]=p;
    e++;
    return OK;
}

template<class T>
Result LGraph<T>::Remove(int u,int v)       //刪除
{
    if(u<0||v<0||u>n-1||u==v)
        return ERROR;
    ENode<T>*p=a[u],*q;
    q=NULL;
    while(p&&p->adjVex!=v)
    {
        q=p;
        p=p->nextArc;
    }
    if(!p)
        return NotPresent;
    if(q)
        q->nextArc=p->nextArc;
    else
        a[u]=p->nextArc;
    delete p;
    e--;
    return OK;
}
 int main()  //主函數
 {
     int n,g;
     cout<<"請輸入元素的個數:";
     cin>>n;
     mGraph<int>A(n,INFTY);
     LGraph<int>B(n); 
     cout<<"請輸入邊的條數:";
     cin>>g;
     int *a=new int[g];
     int *b=new int[g];
     int *w=new int[g];
     for(int i=0;i<g;i++)
     {
         cout<< "請輸入邊及權值:";
         cin>>a[i]>>b[i]>>w[i];
         A.Insert(a[i],b[i],w[i]);
         B.Insert(a[i],b[i],w[i]);
     }
     cout<<"該圖的深度優先遍歷爲:"<<endl;
     A.DFS();
     cout<<endl;
     cout<<"該圖的寬度優先遍歷爲:"<<endl;
     A.BFS();
     cout<<endl;
     cout<<"請輸入要搜索的邊:";
     int c,d;
     cin>> c>>d;
     if(A.Exist(c,d))
         cout<<"鄰接矩陣中該邊存在!"<<endl;
     else
         cout<<"鄰接矩陣中該邊不存在!"<<endl;
     if(B.Exist(c,d))
         cout<<"鄰接表中該邊存在!"<<endl;
     else
         cout<<"鄰接表中該邊不存在!"<<endl;
     cout<<"請輸入要刪除的邊:";
     int e,f;
     cin>>e>>f;
     if(A.Remove(e,f)==OK)
         cout<<"鄰接矩陣中刪除該邊成功!"<<endl;
     else if(A.Remove(e,f)==NotPresent)
         cout<<"鄰接矩陣中該邊不存在!"<<endl;
     else
         cout<<"輸入錯誤!"<<endl;
     if(B.Remove(e,f)==OK)
         cout<<"鄰接表中刪除該邊成功!"<<endl;
     else if(B.Remove(e,f)==NotPresent)
         cout<<"鄰接表中該邊不存在!"<<endl;
     else
         cout<<"鄰接表中輸入錯誤!"<<endl;
     cout<<"刪除該邊後該圖的深度優先遍歷爲:"<<endl;
     A.DFS();
     cout<<endl;
     cout<<"刪除該邊後該圖的寬度優先遍歷爲:"<<endl;
     A.BFS();
     cout<<endl;
     return 0;
 }

注：代碼同時使用了鄰接矩陣和鄰接表，產生必定的錯誤。能夠分開。

實驗五：編寫程序，實現智能交通中的最佳路徑選擇問題：設有n個地點，編號爲0→n-1，m條路徑的起點、終點和代價由用戶輸入提供，使用鄰接表爲存儲結構，尋找最佳路徑方案（如花費時間最少，路徑長度最短，交通費用最少等問題任選其一便可）

#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>
using namespace std;
#define INF 0xfffff    //權值上限
#define maxn 110  //最大頂點個數
int n;       //頂點個數

struct arcnode  //邊結點
{
    int vertex;     //與表頭結點相鄰的頂點編號
    int weight;     //鏈接兩頂點的邊的權值
    arcnode * next; //指向下一相鄰接點
    arcnode() {}
    arcnode(int v,int w):vertex(v),weight(w),next(NULL) {}
};

struct vernode      //頂點結點，爲每一條鄰接表的表頭結點
{
    int vex;    //當前定點編號
    arcnode * firarc;   //與該頂點相連的第一個頂點組成的邊
}Ver[maxn];

void Init()  //創建圖的鄰接表須要先初始化，創建頂點結點
{
    for(int i = 1; i <= n; i++)
    {
        Ver[i].vex = i;
        Ver[i].firarc = NULL;
    }
}

void Insert(int a, int b, int w)  //尾插法，插入以a爲起點，b爲終點，權爲w的邊，效率不如頭插，可是能夠去重邊
{
    arcnode * q = new arcnode(b, w);
    if(Ver[a].firarc == NULL)
        Ver[a].firarc = q;
    else
    {
        arcnode * p = Ver[a].firarc;
        if(p->vertex == b)
        {
            if(p->weight > w)
                p->weight = w;
            return ;
        }
        while(p->next != NULL)
        {
            if(p->next->vertex == b)
            {
                if(p->next->weight > w)
                    p->next->weight = w;
                return ;
            }
            p = p->next;
        }
        p->next = q;
    }
}
void Insert2(int a, int b, int w)   //頭插法，效率更高，但不能去重邊
{
    arcnode * q = new arcnode(b, w);
    if(Ver[a].firarc == NULL)
        Ver[a].firarc = q;
    else
    {
        arcnode * p = Ver[a].firarc;
        q->next = p;
        Ver[a].firarc = q;
    }
}
struct node     //頂點節點，保存id和到源頂點的估算距離，優先隊列須要的類型
{
    int id;     //源頂點id和估算距離
    int w;
    friend bool operator<(node a, node b)   //因要實現最小堆，按升序排列，於是須要重載運算符，重定義優先級，以小爲先
    {
        return a.w > b.w;
    }
};

int parent[maxn];   //每一個頂點的父親節點，能夠用於還原最短路徑樹
bool visited[maxn]; //用於判斷頂點是否已經在最短路徑樹中，或者說是否已找到最短路徑
node d[maxn];      //源點到每一個頂點估算距離，最後結果爲源點到全部頂點的最短路。
priority_queue<node> q; //優先隊列stl實現
void Dijkstra(int s)    //Dijkstra算法，傳入源頂點
{
    for(int i = 1; i <= n; i++) //初始化
    {
        d[i].id = i;
        d[i].w = INF;           //估算距離置INF
        parent[i] = -1;         //每一個頂點都無父親節點
        visited[i] = false;     //都未找到最短路
    }
    d[s].w = 0;                 //源點到源點最短路權值爲0
    q.push(d[s]);               //壓入隊列中
    while(!q.empty())           //算法的核心，隊列空說明完成了操做
    {
        node cd = q.top();      //取最小估算距離頂點
        q.pop();
        int u = cd.id;
        if(visited[u])   
            continue;
        visited[u] = true;
        arcnode * p = Ver[u].firarc;
        //鬆弛操做
        while(p != NULL)    //找全部與他相鄰的頂點，進行鬆弛操做，更新估算距離，壓入隊列。
        {
            int v = p->vertex;
            if(!visited[v] && d[v].w > d[u].w+p->weight)
            {
                d[v].w = d[u].w+p->weight;
                parent[v] = u;
                q.push(d[v]);
            }
            p = p->next;
        }
    }
}

int main()
{
    int m, a, b, c, st, ed;
    printf("請輸入地點數和路徑數：\n");
    scanf("%d%d", &n, &m);
    printf("請輸入路徑以及路徑長度（a, b, c)\n");
    Init();     //計算前必須初始化
    while(m--)
    {
        scanf("%d%d%d", &a, &b, &c);
        Insert2(a, b, c);   //無向圖注意存儲兩條邊
        Insert2(b, a, c);
    }
    printf("請輸入起點和終點：\n");
    scanf("%d%d", &st, &ed);
    Dijkstra(st);
    if(d[ed].w != INF)
        printf("%d到%d最短路徑長度爲：%d\n", st,ed,d[ed].w);
    else
        printf("不存在從地點%d到地點%d的最短路徑。\n", st, ed);
    return 0;
}