图

最新推荐文章于 2024-04-22 16:32:05 发布

Y千年老妖

最新推荐文章于 2024-04-22 16:32:05 发布

阅读量541

点赞数

分类专栏： C编程案例文章标签： c c++

C编程案例专栏收录该内容

35 篇文章 0 订阅

订阅专栏

今天，我们一起来实践一下数据结构-图，具体实现代码如下：

Edge.h具体内容如下：

[cpp]view plaincopy 
   
 template<typename DistType> struct Edge{  
 public:  
     Edge(int dest, DistType cost) : m_ndest(dest), m_cost(cost), m_pnext(NULL){}  
   
 public:  
     int m_ndest;  
     DistType m_cost;  
     Edge<DistType> *m_pnext;  
   
 };  

Graph.h具体内容如下：

[cpp]view plaincopy 
   
 #include "Vertex.h"  
   
 template<typename NameType, typename DistType> class Graph{  
 public:  
     Graph(int size = m_nDefaultSize);   //create the Graph with the most vertex of size  
     ~Graph();  
     bool GraphEmpty() const{    //Is empty?  
         return 0 == m_nnumvertex;  
     }  
     bool GraphFull() const{     //Is full?  
         return m_nMaxNum == m_nnumvertex;  
     }  
     int NumberOfVertex() const{ //get the number of vertex  
         return m_nnumvertex;  
     }  
     int NumberOfEdge() const{   //get the number of edge  
         return m_nnumedges;  
     }  
     NameType GetValue(int v);   //get the value of the vth vertex  
     DistType GetWeight(int v1, int v2); //get the weight between v1 and v2  
     int GetFirst(int v);        //get the first neighbor vertex of v  
     int GetNext(int v1, int v2);//get the next neighbor vertex of v1 behind v2  
     bool InsertVertex(const NameType vertex);   //insert vertex with the name of vertex  
     bool Removevertex(int v);   //remove the vth vertex  
   
     //insert the edge between v1 and v2  
     bool InsertEdge(int v1, int v2, DistType weight = m_Infinity);  
   
     bool RemoveEdge(int v1, int v2);    //delete the edge between v1 and v2  
     void Print();   //print the graph  
   
     Edge<DistType> *GetMin(int v, int *visited);    //get the min weight of the neighbor vertex of v  
     void Prim(Graph<NameType, DistType> &graph);    //get the minimize span tree  
     void DFS(int v, int *visited);      //depth first search  
     void DFS();  
     void Dijkstra(int v, DistType *shotestpath);    //get the min weight from v to other vertex  
   
 private:  
     Vertex<NameType, DistType> *m_pnodetable;   //neighbor list  
     int m_nnumvertex;  
     const int m_nMaxNum;  
     static const int m_nDefaultSize = 10;       //the default maximize vertex  
     static const DistType m_Infinity = 100000;  //there is no edge  
     int m_nnumedges;  
     int Getvertexpos(const NameType vertex);    //get the vertex's position with the name of vertex  
 };  
   
   
 template<typename NameType, typename DistType> Graph<NameType, DistType>::Graph(int size)  
     : m_nnumvertex(0), m_nMaxNum(size), m_nnumedges(0){  
     m_pnodetable = new Vertex<NameType, DistType>[size];  
 }  
   
 template<typename NameType, typename DistType> Graph<NameType, DistType>::~Graph(){  
     Edge<DistType> *pmove;  
     for (int i = 0; i < this->m_nnumvertex; i++){  
         pmove = this->m_pnodetable[i].adj;  
         if (pmove){  
             this->m_pnodetable[i].adj = pmove->m_pnext;  
             delete pmove;  
             pmove = this->m_pnodetable[i].adj;  
         }  
     }  
     delete[] m_pnodetable;  
 }  
   
 template<typename NameType, typename DistType> int Graph<NameType, DistType>::GetFirst(int v){  
     if (v < 0 || v >= this->m_nnumvertex){  
         return -1;  
     }  
     Edge<DistType> *ptemp = this->m_pnodetable[v].adj;  
     return m_pnodetable[v].adj ? m_pnodetable[v].adj->m_ndest : -1;  
 }  
   
 template<typename NameType, typename DistType> int Graph<NameType, DistType>::GetNext(int v1, int v2){  
     if (-1 != v1){  
         Edge<DistType> *pmove = this->m_pnodetable[v1].adj;  
         while (NULL != pmove->m_pnext){  
             if (pmove->m_ndest == v2){  
                 return pmove->m_pnext->m_ndest;  
             }  
             pmove = pmove->m_pnext;  
         }  
     }  
     return -1;  
 }  
   
 template<typename NameType, typename DistType> NameType Graph<NameType, DistType>::GetValue(int v){  
     if (v < 0 || v >= this->m_nnumvertex){  
         cerr << "The vertex is not exsit" << endl;  
         exit(1);  
     }  
     return m_pnodetable[v].m_data;  
   
 }  
   
 template<typename NameType, typename DistType> int Graph<NameType, DistType>::Getvertexpos(const NameType vertex){  
     for (int i = 0; i < this->m_nnumvertex; i++){  
         if (vertex == m_pnodetable[i].m_data){  
             return i;  
         }  
     }  
     return -1;  
 }  
   
 template<typename NameType, typename DistType> DistType Graph<NameType, DistType>::GetWeight(int v1, int v2){  
     if (v1 >= 0 && v1 < this->m_nnumvertex && v2 >= 0 && v2 < this->m_nnumvertex){  
         if (v1 == v2){  
             return 0;  
         }  
         Edge<DistType> *pmove = m_pnodetable[v1].adj;  
         while (pmove){  
             if (pmove->m_ndest == v2){  
                 return pmove->m_cost;  
             }  
             pmove = pmove->m_pnext;  
         }  
     }  
     return m_Infinity;  
 }  
   
 template<typename NameType, typename DistType> bool Graph<NameType, DistType>::InsertEdge(int v1, int v2, DistType weight){  
     if (v1 >= 0 && v1 < this->m_nnumvertex && v2 >= 0 && v2 < this->m_nnumvertex){  
         Edge<DistType> *pmove = m_pnodetable[v1].adj;  
         if (NULL == pmove){ //the first neighbor  
             m_pnodetable[v1].adj = new Edge<DistType>(v2, weight);  
             return 1;  
         }  
         while (pmove->m_pnext){  
             if (pmove->m_ndest == v2){  
                 break;  
             }  
             pmove = pmove->m_pnext;  
         }  
         if (pmove->m_ndest == v2){  //if the edge is exist, change the weight  
             pmove->m_cost = weight;  
             return 1;  
         }  
         else{  
             pmove->m_pnext = new Edge<DistType>(v2, weight);  
             return 1;  
         }  
     }  
     return 0;  
 }  
 template<typename NameType, typename DistType> bool Graph<NameType, DistType>::InsertVertex(const NameType vertex){  
     int i = this->Getvertexpos(vertex);  
     if (-1 != i){  
         this->m_pnodetable[i].m_data = vertex;  
     }  
     else{  
         if (!this->GraphFull()){  
             this->m_pnodetable[this->m_nnumvertex].m_data = vertex;  
             this->m_nnumvertex++;  
         }  
         else{  
             cerr << "The Graph is Full" << endl;  
             return 0;  
         }  
     }  
     return 1;  
 }  
 template<typename NameType, typename DistType> bool Graph<NameType, DistType>::RemoveEdge(int v1, int v2){  
     if (v1 >= 0 && v1 < this->m_nnumvertex && v2 >= 0 && v2 < this->m_nnumvertex){  
         Edge<DistType> *pmove = this->m_pnodetable[v1].adj, *pdel;  
         if (NULL == pmove){  
             cerr << "the edge is not exist!" << endl;  
             return 0;  
         }  
         if (pmove->m_ndest == v2){  //the first neighbor  
             this->m_pnodetable[v1].adj = pmove->m_pnext;  
             delete pmove;  
             return 1;  
         }  
         while (pmove->m_pnext){  
             if (pmove->m_pnext->m_ndest == v2){  
                 pdel = pmove->m_pnext;  
                 pmove->m_pnext = pdel->m_pnext;  
                 delete pdel;  
                 return 1;  
             }  
             pmove = pmove->m_pnext;  
         }  
     }  
     cerr << "the edge is not exist!" << endl;  
     return 0;  
 }  
 template<typename NameType, typename DistType> bool Graph<NameType, DistType>::Removevertex(int v){  
     if (v < 0 || v >= this->m_nnumvertex){  
         cerr << "the vertex is not exist!" << endl;  
         return 0;  
     }  
     Edge<DistType> *pmove, *pdel;  
     for (int i = 0; i < this->m_nnumvertex; i++){  
         pmove = this->m_pnodetable[i].adj;  
         if (i != v){    //delete the edge point to v  
             if (NULL == pmove){  
                 continue;  
             }  
             if (pmove->m_ndest == v){  
                 this->m_pnodetable[i].adj = pmove->m_pnext;  
                 delete pmove;  
                 continue;  
             }  
             else {  
                 if (pmove->m_ndest > v){    //the vertex more than v subtract 1  
                     pmove->m_ndest--;  
                 }  
             }  
             while (pmove->m_pnext){  
                 if (pmove->m_pnext->m_ndest == v){  
                     pdel = pmove->m_pnext;  
                     pmove->m_pnext = pdel->m_pnext;  
                     delete pdel;  
                 }  
                 else {  
                     if (pmove->m_pnext->m_ndest > v){  
                         pmove->m_pnext->m_ndest--;  
                         pmove = pmove->m_pnext;  
                     }  
                 }  
             }  
         }  
         else {      //delete the edge point from v  
             while (pmove){  
                 this->m_pnodetable[i].adj = pmove->m_pnext;  
                 delete pmove;  
                 pmove = this->m_pnodetable[i].adj;  
             }  
         }  
     }  
     this->m_nnumvertex--;  
     for (int i = v; i < this->m_nnumvertex; i++)    //delete the vertex  
     {  
         this->m_pnodetable[i].adj = this->m_pnodetable[i + 1].adj;  
         this->m_pnodetable[i].m_data = this->m_pnodetable[i + 1].m_data;  
     }  
     this->m_pnodetable[this->m_nnumvertex].adj = NULL;  
     return 1;  
 }  
   
 template<typename NameType, typename DistType> void Graph<NameType, DistType>::Print(){  
     Edge<DistType> *pmove;  
     for (int i = 0; i < this->m_nnumvertex; i++){  
         cout << this->m_pnodetable[i].m_data << "--->";  
         pmove = this->m_pnodetable[i].adj;  
         while (pmove){  
             cout << pmove->m_cost << "--->" << this->m_pnodetable[pmove->m_ndest].m_data << "--->";  
             pmove = pmove->m_pnext;  
         }  
         cout << "NULL" << endl;  
     }  
 }  
   
 template<typename NameType, typename DistType> void Graph<NameType, DistType>::Prim(Graph<NameType, DistType> &graph){  
     int *node = new int[this->m_nnumvertex];    //using for store the vertex visited  
     int *visited = new int[this->m_nnumvertex];  
     int count = 0;  
     Edge<DistType> *ptemp, *ptemp2 = new Edge<DistType>(0, this->m_Infinity), *pmin;  
     int min;  
     for (int i = 0; i < this->m_nnumvertex; i++){  
         graph.InsertVertex(this->m_pnodetable[i].m_data);  
         node[i] = 0;  
         visited[i] = 0;  
     }  
     visited[0] = 1;  
     while (++count < this->m_nnumvertex){  
         pmin = ptemp2;  
         pmin->m_cost = this->m_Infinity;  
   
         //get the minimize weight between the vertex visited and the  vertex which is not visited  
         for (int i = 0; i<count; i++){  
             ptemp = GetMin(node[i], visited);  
             if (NULL == ptemp){  
                 continue;  
             }  
             if (pmin->m_cost > ptemp->m_cost){  
                 pmin = ptemp;  
                 min = node[i];  
             }  
         }  
   
         node[count] = pmin->m_ndest;  
         visited[node[count]] = 1;  
         graph.InsertEdge(pmin->m_ndest, min, pmin->m_cost);  
         graph.InsertEdge(min, pmin->m_ndest, pmin->m_cost);  
     }  
     graph.DFS();  
     delete ptemp2;  
     delete[] node;  
     delete[] visited;  
 }  
   
 template<typename NameType, typename DistType> void Graph<NameType, DistType>::DFS(int v, int *visited){  
     cout << "--->" << this->GetValue(v);  
     visited[v] = 1;  
     int weight = this->GetFirst(v);  
     while (-1 != weight){  
         if (!visited[weight]){  
             cout << "--->" << this->GetWeight(v, weight);  
             DFS(weight, visited);  
         }  
         weight = this->GetNext(v, weight);  
     }  
 }  
   
 template<typename NameType, typename DistType> void Graph<NameType, DistType>::DFS(){  
     int *visited = new int[this->m_nnumvertex];  
     for (int i = 0; i < this->m_nnumvertex; i++){  
         visited[i] = 0;  
     }  
     cout << "head";  
     DFS(0, visited);  
     cout << "--->end";  
 }  
   
 template<typename NameType, typename DistType> Edge<DistType>* Graph<NameType, DistType>::GetMin(int v, int *visited){  
     Edge<DistType> *pmove = this->m_pnodetable[v].adj, *ptemp = new Edge<DistType>(0, this->m_Infinity), *pmin = ptemp;  
     while (pmove){  
         if (!visited[pmove->m_ndest] && pmin->m_cost > pmove->m_cost){  
             pmin = pmove;  
         }  
         pmove = pmove->m_pnext;  
     }  
     if (pmin == ptemp){  
         delete ptemp;  
         return NULL;  
     }  
     delete ptemp;  
     return pmin;  
 }  
 template<typename NameType, typename DistType> void Graph<NameType, DistType>::Dijkstra(int v, DistType *shotestpath){  
     int *visited = new int[this->m_nnumvertex];  
     int *node = new int[this->m_nnumvertex];  
     for (int i = 0; i < this->m_nnumvertex; i++){  
         visited[i] = 0;  
         node[i] = 0;  
         shotestpath[i] = this->GetWeight(v, i);  
     }  
     visited[v] = 1;  
     for (int i = 1; i < this->m_nnumvertex; i++){  
         DistType min = this->m_Infinity;  
         int u = v;  
   
         for (int j = 0; j < this->m_nnumvertex; j++){   //get the minimize weight  
             if (!visited[j] && shotestpath[j] < min){  
                 min = shotestpath[j];  
                 u = j;  
             }  
         }  
   
         visited[u] = 1;  
         for (int w = 0; w < this->m_nnumvertex; w++){   //change the weight from v to other vertex  
             DistType weight = this->GetWeight(u, w);  
             if (!visited[w] && weight != this->m_Infinity  
                 && shotestpath[u] + weight < shotestpath[w]){  
                 shotestpath[w] = shotestpath[u] + weight;  
             }  
         }  
     }  
     delete[] visited;  
     delete[] node;  
 }  

MinHeap.h具体内容如下：

[cpp]view plaincopy 
   
 template<typename Type> class MinHeap{  
 public:  
     MinHeap(Type heap[], int n);        //initialize heap by a array  
     ~MinHeap(){  
         delete[] m_pheap;  
     }  
   
 public:  
     bool Insert(const Type item);  
     bool DeleteMin(Type &first);  
   
 private:  
     void Adjust(const int start, const int end);    //adjust the elements from start to end  
   
   
 private:  
     const int m_nMaxSize;  
     Type *m_pheap;  
     int m_ncurrentsize;  
 };  
   
 template<typename Type> void MinHeap<Type>::Adjust(const int start, const int end){  
     int i = start, j = i * 2 + 1;  
     Type temp = m_pheap[i];  
     while (j <= end){  
         if (j<end && m_pheap[j]>m_pheap[j + 1]){  
             j++;  
         }  
         if (temp <= m_pheap[j]){  
             break;  
         }  
         else{  
             m_pheap[i] = m_pheap[j];  
             i = j;  
             j = 2 * i + 1;  
         }  
     }  
     m_pheap[i] = temp;  
 }  
   
 template<typename Type> MinHeap<Type>::MinHeap(Type heap[], int n) :m_nMaxSize(n){  
     m_pheap = new Type[m_nMaxSize];  
     for (int i = 0; i < n; i++){  
         m_pheap[i] = heap[i];  
     }  
     m_ncurrentsize = n;  
     int pos = (n - 2) / 2;  //Find the last tree which has more than one element;  
     while (pos >= 0){  
         Adjust(pos, n - 1);  
         pos--;  
     }  
 }  
   
 template<typename Type> bool MinHeap<Type>::DeleteMin(Type &first){  
     first = m_pheap[0];  
     m_pheap[0] = m_pheap[m_ncurrentsize - 1];  
     m_ncurrentsize--;  
     Adjust(0, m_ncurrentsize - 1);  
     return 1;  
 }  
   
 template<typename Type> bool MinHeap<Type>::Insert(const Type item){  
     if (m_ncurrentsize == m_nMaxSize){  
         cerr << "Heap Full!" << endl;  
         return 0;  
     }  
     m_pheap[m_ncurrentsize] = item;  
     int j = m_ncurrentsize, i = (j - 1) / 2;  
     Type temp = m_pheap[j];  
     while (j > 0){  
         if (m_pheap[i] <= temp){  
             break;  
         }  
         else{  
             m_pheap[j] = m_pheap[i];  
             j = i;  
             i = (j - 1) / 2;  
         }  
     }  
     m_pheap[j] = temp;  
     m_ncurrentsize++;  
     return 1;  
 }  

Vertex.h具体内容如下：

[cpp]view plaincopy 
   
 #include "Edge.h"  
   
 template<typename NameType, typename DistType> struct Vertex{  
 public:  
     Vertex() : adj(NULL){}  
     NameType m_data;  
     Edge<DistType> *adj;  
     ~Vertex();  
 };  
   
 template<typename NameType, typename DistType> Vertex<NameType, DistType>::~Vertex(){  
     Edge<DistType> *pmove = adj;  
     while (pmove){  
         adj = pmove->m_pnext;  
         delete pmove;  
         pmove = adj;  
     }  
 }  

main.cpp具体内容如下：

[cpp]view plaincopy 
   
 #include <iostream>  
   
 using namespace std;  
   
 #include "Graph.h"  
   
 int main(){  
     Graph<char *, int> graph, graph2;  
     int shotestpath[7];  
     char *vertex[] = { "清华", "武大", "华科", "交大", "北大", "地大", "复旦" };  
     int edge[][3] = { { 0, 1, 43 }, { 0, 2, 12 }, { 1, 2, 38 }, { 2, 3, 1325 }  
     , { 3, 6, 55 }, { 4, 5, 34 }, { 4, 6, 248 } };  
     for (int i = 0; i < 7; i++){  
         graph.InsertVertex(vertex[i]);  
     }  
     graph.Print();  
     cout << endl << endl << endl;  
     for (int i = 0; i < 7; i++){  
         graph.InsertEdge(edge[i][0], edge[i][1], edge[i][2]);  
         graph.InsertEdge(edge[i][1], edge[i][0], edge[i][2]);  
     }  
     graph.Print();  
     cout << endl << endl << endl;  
     graph.Dijkstra(0, shotestpath);  
     for (int i = 0; i < 7; i++){  
         cout << graph.GetValue(0) << "--->" << graph.GetValue(i)  
             << ":   " << shotestpath[i] << endl;  
     }  
   
     cout << endl << endl << endl;  
     graph.Prim(graph2);  
     cout << endl << endl << endl;  
     graph.Removevertex(2);  
     graph.Print();  
     cin.get();  
     return 0;  
 }  

运行效果如图1所示：

图1 运行效果

Y千年老妖

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
图

今天，我们一起来实践一下数据结构-图，具体实现代码如下：Edge.h具体内容如下：[cpp] view plaincopytemplatetypename DistType> struct Edge{ public: Edge(int dest, DistType cost) : m_ndest(dest), m_
复制链接

扫一扫

专栏目录