有向无权图的最短路径算法

最新推荐文章于 2024-10-11 12:38:59 发布
最新推荐文章于 2024-10-11 12:38:59 发布
阅读量512 收藏 6
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/1242118789lr/p/6748075.html
版权

    对于一个有向无权的图，我们只需从起点开始，依次往后寻找即可，这还谈不上算法，只能说是一种思想，这种思想解释如下：

 

    首先对于一个有向无权的图：

    我们令v0为起点，v0到v0的路径为0，所有在v0下面标0，如下图所示：

     接着发现v0到v1和v2,v3都只需经过一条边，因此在v1和v2,v3下面标1，如下图所示：

  接着找v1和v2,v3相邻的点，发现是v2和v4,v6，就在这两个点下面标2.如下图所示：

   没有点剩下，整个过程完毕，如果还剩下点，就继续按照上面的思想执行，直到所有的点都遍历到。

   这样整个过程就完了，点下面标的数字就是所需要的最短的路径，把上述思想转换成代码就可以了。

 

   代码如下：

   

#include <iostream>
using namespace std;
 
#define Inf 65535
//列队的相关定义//
typedef struct QueueRecord *Queue;
#define MinQueueSize  10
struct QueueRecord
{
   int Capacity;    //队的容量
   int Front;       //队头
   int Rear;        //队尾
   int Size;        //队中元素的个数
   int *Array;       //数组
};
/邻接表的相关定义//
typedef struct EdgeNode *position;
typedef struct Led_table* Table; 


 struct EdgeNode     //边表结点  
{  
    int adjvex;    // 邻接点域,存储该顶点对应的下标  
    int weight;     // 对应边的权值 
    position next; // 链域,指向下一个邻接点
}; 

struct Led_table       // 邻接表结构  
{  
    int data;                //邻接表的大小
    position *firstedge;       //边表头指针，可以理解为数组
};  

///列队相关函数声明
int IsEmpty(Queue Q);    //判断队列是否为空
int IsFull(Queue Q);     //判断队列是否满了
void MakeEmpty(Queue Q);   //构造一个空列队
Queue CreateQueue(int MaxElements);  //创建一个列队
void DisposeQueue(Queue Q);      //释放一个列队
void Enqueue(int x, Queue Q);    //入队
int Dequeue(Queue Q);      //出队
int Front(Queue Q);     //返回队首值，不出队
 
 
///列队相关函数定义
int IsEmpty(Queue Q)
{
   return Q->Size == 0;
}
 
int IsFull(Queue Q)
{
    if(Q->Size > Q->Capacity )
    {
       cout << "queue full" << endl;
       return -1;
    }
    else
    {
       return 0;
    }
}
 
void MakeEmpty(Queue Q)
{
   Q->Size = 0;
   Q->Front = 1;
   Q->Rear = 0;
}
 
Queue CreateQueue(int MaxElements)
{
   Queue Q;
   if (MaxElements < MinQueueSize)
   {
      cout << "queue size is too small" << endl;
   }
   Q = static_cast<Queue> (malloc(sizeof(struct QueueRecord)));
   if(Q == NULL)
   {
      cout << "out of space!!!";
   }
   Q->Array =static_cast<int*>(malloc(sizeof(int)*MaxElements));
   if(Q->Array == NULL)
   {
     cout << "out of space!!!";
   }
   Q->Capacity = MaxElements;
   MakeEmpty(Q);
   return Q;
}
 
void DisposeQueue(Queue Q)
{
    if (Q != NULL)
   {
      free(Q->Array );
      free(Q);
   }
}
 
 
static int Succ(int Value, Queue Q)  //循环数组，用于回绕
{
   if(++Value == Q->Capacity )
       Value = 0;
   return Value;
}
void Enqueue(int x, Queue Q)
{
    if(IsFull(Q))
    {
       cout << "Full queue" << endl;
    }
    else
    {
       Q->Size ++;
       Q->Rear = Succ(Q->Rear, Q);
       Q->Array [Q->Rear] = x;
    }
}
 
 
int Dequeue(Queue Q)
{
    if(IsEmpty(Q))
    {
       cout << "Empty Queue" << endl;
       return false;    //仅表示错误
    }
    else
    {
       Q->Size --;
       Q->Front = Succ(Q->Front, Q);
       return Q->Array[(Q->Front)-1];
    }
}
 
int Front(Queue Q)
{
    if(IsEmpty(Q))
    {
       cout << "Empty Queue" << endl;
       return false;    //仅表示错误
    }
    else
    return Q->Array[Q->Front];
}
 

//邻接表相关函数定义///
Table Creat_Lable (int MaxElements)    //MaxElements参数为希望创建的节点数
{
	
	Table table1 = static_cast<Table> (malloc(sizeof(struct Led_table)));
	table1->data = MaxElements;
	if (table1 == NULL)
	{
	   cout << "out of space!!!";
	}

	table1->firstedge  = static_cast<position*>(malloc(sizeof(position)*(table1->data))); 
	if (table1->firstedge  == NULL)
	{
	   cout << "out of space!!!";
	}

	//给每个表头赋值，从0开始
	for (int i = 0; i <= table1->data - 1; ++i)
	{
	    table1->firstedge [i] = static_cast<position>(malloc(sizeof(position)));   //申请一个节点
		if (table1->firstedge [i]  == NULL)
			{
			   cout << "out of space!!!";
			}
		table1->firstedge [i]->adjvex = 0;   //表头这个参数存储入度
		table1->firstedge [i]->weight = 0;   //此参数在此时没有意义
		table1->firstedge [i]->next = NULL;

	}
	return table1;

}


void Insert (Table table1, int v, int w, int weig)   //表示存在一条边为<v,w>,且权重为weig
{
    position p = static_cast<position>(malloc(sizeof(position)));   //申请一个节点
	if(p == NULL)
	{
	   cout << "out of space!!!";
	}
	p->adjvex = w;
    p->weight = weig;
	p->next = table1->firstedge [v]->next;
	table1->firstedge [v]->next = p;
		
}

void CountIndegree(Table table1)      //计算顶点的入度，存在头结点中
{
   for(int i = 0; i <= table1->data - 1; ++i)
   {
       position p = table1->firstedge [i]->next;
        while (p != NULL) 
		{
           ++(table1->firstedge [p->adjvex]->adjvex) ;
            p = p->next;
        }
   }
}

int* Topsort(Table table1)          //拓扑排序
{
   Queue queue_1 = CreateQueue(15);   //创建一个列队
   int Counter = 0;
   int *TopNum = static_cast<int*>( malloc (sizeof(int)*(table1->data )));  //此数组用来存储结果
   int v;
   for(int i = 0; i != table1->data; ++i)
   {
      if(table1->firstedge[i]->adjvex == 0)
	  {
	     Enqueue(i,queue_1);  //如果顶点i的入度为0，就入队
	  }
   }

   while(!IsEmpty(queue_1))
   {
       v = Dequeue(queue_1);
	   TopNum[v] = ++Counter;   //若TopNum[5] = 3， 则排第三的为v5

	    position p = table1->firstedge [v]->next;

		while (p != NULL)   //把这个节点删除后，更新入度
		{
		  --(table1->firstedge [p->adjvex]->adjvex);
		  if(table1->firstedge [p->adjvex]->adjvex == 0) Enqueue(p->adjvex,queue_1);
		   p = p->next;
		}
	   
   }
   if(Counter != table1->data )
   {
       cout << "the graph has a cycle" << endl;
   }
   DisposeQueue(queue_1);
   return TopNum;
}

void print_Topsort_result(int *TopNum,Table table1)   //打印拓扑排序结果
{
   for(int i = 1; i != table1->data+1 ; ++i)
   {
      for (int j = 0; j != table1->data ; ++j)
	  {
	     if (TopNum[j] == i)
		 {
			 if(i == table1->data)
			 {
			    cout << "v" << j;
			 }
			 else
			 {
			    cout << "v" << j << "->";
			 }
		    
		 }
	  }
   }
   cout << endl;
}
/单源无权算法相关定义/
typedef struct unweight_path *unweight_node ;



 struct unweight_path     // 
{  
	bool know;
    int dist;    // 邻接点域,存储该顶点对应的下标  
    int path;     // 对应边的权值 
};

unweight_node unweight_init(Table table1, int start)     //节点初始化
{
	unweight_node Node  = static_cast<unweight_node>(malloc(sizeof(unweight_path)*(table1->data))); 
	if (Node  == NULL)
	{
	   cout << "out of space!!!";
	}
	for(int i = 0; i != table1->data; ++i)
	{
	    Node[i].know = false;
		Node[i].dist = Inf;
		Node[i].path = 0;
	}
	Node[start].dist = 0;
	return Node;
}

单源无权最短路径一般算法，时间复杂度较高
void Unweighted(Table table1,unweight_node Node)
{
	int currDist;
	int v;
	for(currDist = 0;currDist != table1->data; ++currDist)
	{
	   for(v = 0; v != table1->data; ++v )
	   {
	      if(!Node[v].know && Node[v].dist == currDist )
		  {
		     Node[v].know = true;
			 position p = table1->firstedge [v]->next;
			while (p != NULL)   //与这个节点有连接的距离+1
			{
			   if(Node[p->adjvex].dist  == Inf)
			   {
			      Node[p->adjvex].dist = currDist+1;
				  Node[p->adjvex].path = v;
			   }
			   p = p->next;
			}
		  }
	   }
	}
  
}
单源无权最短路径改进算法/
 void Unweighted_change (Table table1,unweight_node Node)
 {
	 int v;
     Queue queue_1 = CreateQueue(15);   //创建一个列队
	 for(int i = 0; i != table1->data; ++i)
	 {
	     if(Node[i].dist == 0)
		 {
		     Enqueue(i,queue_1);
		 }
	 }
	 while(!IsEmpty(queue_1))
	 {
	     v = Dequeue(queue_1);
		 Node[v].know = true;
		 position p = table1->firstedge [v]->next;
		while (p != NULL)   //与这个节点有连接的距离+1
		{
			if(Node[p->adjvex].dist  == Inf)
			{
			    Node[p->adjvex].dist = Node[v].dist +1;
				Node[p->adjvex].path = v;
				Enqueue(p->adjvex,queue_1);
			}
			p = p->next;
		}
	 }
	 DisposeQueue(queue_1);

 }
int main ()
{
  Table table_1 = Creat_Lable (7);    //创建一个大小为7的邻接表

  //根据图来为邻接表插入数据
  
  Insert (table_1, 0, 1, 2);Insert (table_1, 0, 2, 4);Insert (table_1, 0, 3, 1);
  Insert (table_1, 1, 3, 3);Insert (table_1, 1, 4, 10);
  Insert (table_1, 2, 5, 5);
  Insert (table_1, 3, 2, 2);Insert (table_1, 3, 5, 8);Insert (table_1, 3, 6, 4);
  Insert (table_1, 4, 3, 2);Insert (table_1, 4, 6, 6);
  Insert (table_1, 6, 5, 1);
  
  /测试
  unweight_node Node_1 = unweight_init(table_1, 0);
  Unweighted(table_1, Node_1);
  for (int i = 0; i != table_1->data; ++i)
  {
     cout << Node_1[i].dist << '\t';
  }
  cout << endl;
  Unweighted_change (table_1, Node_1);
   for (int i = 0; i != table_1->data; ++i)
  {
     cout << Node_1[i].dist << '\t';
  }
  cout << endl;
   while(1);
   return 0;
}

　　图放在邻接表中。

 

   上述代码提出了两种方法，区别在于一种用了两次for循环，时间复杂度比较高，另一种采用了列队数据结构，时间复杂度要低，但是两次的结果都一样，如下图所示：

 

    这种方法还是不错的，主要是要善于使用数据结构。

 

    夜深了，，，要下雨了。

 

转载于:https://www.cnblogs.com/1242118789lr/p/6748075.html

weixin_30905133
关注
最短路径算法--无权最短路径
杨春建的博客
09-19 6807
输入是一个赋权图：与每条边（vi，vj）相联系的是穿越该弧的代价（或称为值）ci,j。一条路径v1v2v3…vN的值是，叫做赋权路径长（weighted path length），而无权路径长（unweighted path length）只是路径上的边数，即N-1。 单源路径问题   给定一个赋权图G=（V，E）和一个特定顶点s作为输入，找出从s到G中每一个其它顶点的最短赋权路径。
图的无权最短路径算法
SanFancsgo的博客
06-23 8505
无权最短路径 对于无权图G（边没有权值或认为权值为1），如果G是连通的，则每个顶点之间都存在路径。 最短路径算法就是要找到一条连接不同顶点的最短路径。 上图表示一个有向无权图，顶点v2v2v_2到V6V6V_6之间存在多条路径如v2→v0→v1→v4→v6v2→v0→v1→v4→v6v_2 \to v_0 \to v_1 \to v_4 \to v_6为其中的1条，而最短的一条路径为...
有向无权图最短路径问题——BFS求解
好记性不如烂笔头的专栏
10-02 8417
解释 图1如图1所示，这是一个有向无权图，如果选中某个定点作为起始顶点s，我们要找出s到其他所有顶点的最短路径问题。由于是无权的，所以我们只关心最短路径所包含的边数。这就是一个有向无权图求最短路径的问题，用到BFS算法，广义优先搜索算法。流程解析设s为选中的v3。
图论算法之最短路径（有向无权图）
Coding365
06-12 2109
1.算法介绍 下图是一个无权图G。使用某个顶点s作为输入参数，我们想要找出从s到所有其他顶点的最短路径。 设我们选择s为v2.此时立刻可以说出从s到v2的最短路径长为0的路径。把这个信息做个标记。如下图。 现在我们可以开始找寻所有与s距离为1的顶点。这些顶点通过考查与s邻接的那些顶点可以找到。此时我们看到，v0和v5与s出发只有一步之遥。标记如下。
有向无权图的单源最短路径算法实现
最新发布
南城以北的博客
10-11 323
在无权图中，单源最短路径问题通常可以通过广度优先搜索（BFS）算法来解决。BFS是一种基于队列的图遍历算法，它从源点开始，逐层扩展，直到找到目标节点或遍历完所有节点。由于无权图中所有边的权重相同，BFS能够保证找到的路径是最短的。BFS算法的时间复杂度为O(V+E)，其中V是图中顶点的数量，E是边的数量。由于BFS访问每个顶点和边的次数最多为一次，因此在无权图中效率较高。
图（二）—— 一个有向无权图的最短路径算法
Firewall1076的专栏
11-20 1484
问题的描述是这样的：有一个有向无权图G，指定一个特定的顶点s作为起点，要求找出从s出发到G中的每一个其它顶点的最短路径。如下面的这个图：         （用v1、v2、……作为每个顶点的名称吧。。。）         对于顶点类Vertex要存有两个信息，dist用来保存从s到此顶点的距离，path用来保存最短路径中的前一个顶点。比如说若此顶点是v7,开始顶点是v1,最短路径
有向无权图的最短路径
我想要去航海的博客
11-16 427
寻找有向无权图的最短路径
BFS算法求无权图最短路径问题
m0_68805093的博客
08-04 687
前一篇文章我们详细讲了BFS的原理及实现，在使用BFS遍历图的过程中，我们可以对每个顶点进行标记，标记当前顶点距离源头顶点的距离。这个距离我们用int d[i]来存储，由于BFS的性质，d[i]中存放的就是源头顶点v到顶点i的最短路径。
Matlab实现Floyd最短路径算法
07-24
Floyd最短路径算法是一种经典的图论算法，用于查找图中所有顶点对之间的最短路径。该算法由美国计算机科学家Warren Stephen Floyd提出，它采用动态规划的方法逐步完善路径，通过迭代找到从每个顶点到其他所有顶点的...
毕业设计 最短路径算法.zip
08-04
最短路径算法的目标是从图中的一个源节点到其他所有节点找到具有最小权重的路径。这里的图可以是加权的或无权的，权重通常表示路径的成本、距离或时间。以下是一些经典的最短路径算法： 1. **Dijkstra算法**：由...
有向图的无权图最短路径算法与带权图的Dijkstra算法
lhf2112的博客
04-20 3963
最短路径算法是图论中的常见问题，在实际中有着较为广泛的应用，比如查找从一个地方到另一个地方的最快方式。问题可以概括为，对于某个输入顶点s，给出s到所有其它顶点的最短路径。水平有限，暂时先对这个问题的求解做简单记录。   无权图是有权最短路径的特例，即边的权重均是1。算法类似于BFS（宽度优先搜索），在实现时需要一个宽度优先搜索的队列。全局变量Distance用来保存所有点到输入顶点的距离。以邻接
无权图的最短路径算法
weixin_30336061的博客
04-19 402
邻接矩阵版 先构造邻接矩阵 typedef int Vertex; typedef struct MyGraph { int v, e; //顶点数， 边数 Vertex G[MaxVertexNum][MaxVertexNum]; //邻接矩阵 }MyGraph; 单源无权最短路算法 ...
Java 无权图的最短路路径算法
Cw_Herry的博客
03-20 697
同时，创建一个数组（shortPath）来记录，其中shortPath[x][0]代表是否已经被访问、shortPath[x][1]代表到目标定点的最短距离、shortPath[x][2]代表当前第x个顶点的邻节点，所有都初始化为0。在无权图中，由于所有边的权重被视为一致，使得无权图的最短路径问题在算法处理上相对简化，然而，这并不意味着其缺乏实际应用的意义，实际上，它在多个领域中仍具有不可忽视的实用价值。无权图的最短路径算法：某一点到任意一点的最短路径。： 将shortPath数组返回。
无权图的最短路径
一首小夜曲
09-21 3661
无权图的最短路径可以分为单源最短路径和多源最短路径。 无权图单源最短路径：从某个固定点出发，求其到所有其他定点的最短路径。 无权图多源最短路径：求任意两个结点之间的最短路径。单源最短路径算法，其实就是通过按照递增（非递减）的顺序找到各个定点的最短路；换个角度思考，就是通过BFS（广度优先搜索），算出每一层的最短路径。例如，先计算V结点的邻接点的最短路径，之后再计算V结点每一个邻接点W1，W2，W
无权有向图的最短路径
qq_40691051的博客
11-29 838
为什么使用BFS就够了? 因为BFS的时候离src越近的点越早被访问(先进先出)。 代码： #include<iostream> #include<list> #include<vector> #include<queue> #define INF 9999999 //无穷大 #define NIL -1 using n...
【图论算法】最短路径算法(无权最短路径、Dijkstra算法、带负边值的图、无圈图)
小米子的成长日记
07-22 4997
本篇博客将考察各种最短路径问题。包括无权最短路径、Dijkstra算法、带负边值的图、无圈图等的详细说明，包括对无圈图的关键路径分析，说明了动作节点图，事件节点图，最早完成时间，最晚完成时间和松弛时间的计算方法。最后通过一个无权最短路径的例子--词梯游戏来运用本章的算法。............
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值