图算法一之图的创建和转换

最新推荐文章于 2022-11-20 22:40:49 发布
最新推荐文章于 2022-11-20 22:40:49 发布
阅读量911 收藏 4
点赞数
分类专栏： 数据结构 文章标签： 数据结构 图 创建
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/thepeakofmountain/article/details/31382465
版权

    几乎快近一个月没有写博客，因为一些事耽误了，或者去看其他方面的书去了。另外关于图，犹豫了很久，是否写这一章，因为也听同学和师兄师姐们说过，对于面试和笔试来说，图难度更大一些，而且代码量也更大一些，所以一般不会作为笔试和面试的首选考察对象，考察最多的就是链表、二叉树和字符串了。但是作为数据结构中最难的一章，其实图的应用应该比较多，另外这也是最后一次系统性的学习数据结构了，学习中没有点迎难而上的精神怎么能行？

   好了，言归正传，关于图的术语这些知识略去，可以参考任何一本数据结构的书，但是与本篇文章相关的知识还是要介绍一下的，现在开始了，其中本文的大部分内容和代码参考《大话数据结构》，其中用邻接表的尾插法创建图参考的是《妙趣横生的算法 C语言实现》


1.用邻接矩阵创建图

   图的邻接矩阵存储方式是用两个数组来表示图，一个一维数组储存图中定点信息，一个二维数组(邻接矩阵)存储储存图中边或弧的信息。

   文字还是没有图来的直观，其实看着图，感觉代码就出来了，下面的邻接表也是根据图来写代码的，邻接表中的图更能体现图形的优势。


代码对应如下：

#define MAXVEX 100
#define INFINITY 65536

struct MGraph{
	int vex[MAXVEX];			//顶点表
	int arc[MAXVEX][MAXVEX];    //邻接矩阵，可看左边表
	int numVertexes,numEdges;   //图中的顶点数和边数
};

//用邻接矩阵创建图
void createMGraph(MGraph *mGraph){
	printf("请输入图的顶点数和边数：\n");
	scanf("%d%d",&mGraph->numVertexes,&mGraph->numEdges);
	int i,j,k,w;
	printf("请输入个顶点：\n");
	for(i = 0;i < mGraph->numVertexes; i++){
		scanf("%d",&mGraph->vex[i]);   
	}
	for (i = 0; i < mGraph->numVertexes; i++)
		for(j = 0; j < mGraph->numVertexes;j++)
			mGraph->arc[i][j] = INFINITY;
	for(k = 0;k < mGraph->numEdges; k++){
		printf("请输入边(vi,vj)上的下标i，下标j和权值w:\n");
		scanf("%d%d%d",&i,&j,&w);
		mGraph->arc[i][j]=mGraph->arc[j][i]=w;
	}
}
    写的过程中发现了一处小问题，当邻接矩阵的图顶点如果用char表示的话，上文是用的int，如果用%c读取顶点，注意在读取顶点之前和之后用getchar()获得敲下的回车符，代码还是非常简单的，一看就明白，先初始化总顶点和边数，然后初始化各顶点和个边的权值，最后输入实际的边的值，最后用了无向图的邻接矩阵是对称矩阵的性质。


2.用邻接表创建图

   相比邻接矩阵创建图，用邻接表创建图就复杂多了。采用的是用数组和链表相结合的方法创建图，看图



   其实邻接表的方式，就是上面图就是用data和firstedge表示的顶点信息和用adjext和next构成的链表表示边表的信息，最后组合就是图了，我们知道链表的创建有两种方式，一种是头插法和尾插法，既然图中用到了链表，那么肯定也有两种方法

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

typedef struct VexNode{		//顶点表结点
	int data;    //顶点
	EdgeNode *firstarc;   //边表头指针
}AdjList[MAXVEX];

struct LGraph{
	int numVertexes,numEdges;
	AdjList adjList;   
};

//用邻接表创建图，其中边表结点链表使用的是头插法
void createLGraph(LGraph *lGraph){
	printf("请输入图的顶点数和边数：\n");
	scanf("%d%d",&lGraph->numVertexes,&lGraph->numEdges);
	int i,j,k,w;
	printf("请输入个顶点:\n");
	for(i = 0;i < lGraph->numVertexes; i++){
		scanf("%d",&lGraph->adjList[i].data);
		lGraph->adjList[i].firstarc = NULL;
	}
	for(k = 0;k < lGraph->numEdges; k++){
		printf("请输入边(vi,vj)上的下标i，下标j:\n");
		scanf("%d%d",&i,&j);
		EdgeNode *e = (EdgeNode*)malloc(sizeof(struct EdgeNode));
		e->adjex = j;
		e->next = lGraph->adjList[i].firstarc;
		lGraph->adjList[i].firstarc = e;

		e = (struct EdgeNode*)malloc(sizeof(struct EdgeNode));
		e->adjex = i;
		e->next = lGraph->adjList[j].firstarc;
		lGraph->adjList[j].firstarc = e;
	}
}

//用邻接表创建图，其中边表的链表使用的是尾插法
void createLGraph2(LGraph *graph){
	printf("请输入图的总顶点数和总边数:\n");
	scanf("%d%d",&graph->numVertexes,&graph->numEdges);
	int i,j,k;
	printf("请输入个顶点:\n");
	for(i=0;i<graph->numVertexes;i++){
		scanf("%d",&graph->adjList[i].data);
		graph->adjList[i].firstarc = NULL;
	}
	EdgeNode *e = NULL,*q = NULL,*p = NULL;
	for(i=0;i<graph->numVertexes;i++){
		printf("创建第%d个顶点的所有边,输入-1结束\n",i);
		int x;
		scanf("%d",&x);
		while(x!=-1){
			e = (struct EdgeNode *)malloc(sizeof(struct EdgeNode));
			e->adjex = x;
			e->next = NULL;
			if(graph->adjList[i].firstarc == NULL){
				graph->adjList[i].firstarc = e;
			}
			else{
				p->next = e;
			}
			p = e;
			scanf("%d",&x);
		}
	}
}

   
 由于 
用到了指针，相对来说变复杂了，出现的错误也就多了，对此总结 

 

   1.直观的感受是用头插法的代码剪短的多，而且还不用像尾插法那样需要最后输入一个-1判断某个顶点输入完毕，其原因是因为头插法每次都保持和firstarc链接上，当然头插法肯定是逆序的，而尾插法每次都是和最后一个结点链接，需要用到一个记录的结点p   
 

   2.在用尾插法创建图的时候，一开始以为直接复制粘贴就行了，发现了其实不然，因为头插法用的头结点，可以把j的顶点插入到i的顶点，也可以把i的顶点插入到j的顶点，而用尾插法如果想同时插入i和j顶点的话，是不行了，因为尾插法需要一次性把所有的关联的顶点全部插入完毕
 

   3.用上面的头插法更适合无向图，而尾插法更适用有向图，因为无向图是对称的，而尾插法，按道理说我在输入顶点1的时候输入了2，代表1和2之间有边，当等到顶点2输入的时候，本不应该重复输入1的结点， 但是代码需要每次都输入每个顶点相连的顶点
 

 

   理解了图的这两种表示方式，那么对于由邻接矩阵转换为邻接表的表示方式就呼之欲出了
 

 

//将图的邻接矩阵的表示形式转换为邻接表表示
LGraph* convert(MGraph *mgraph){
	int i,j;
	LGraph *lgraph = (LGraph *)malloc(sizeof(struct LGraph));
	lgraph->numVertexes = mgraph->numVertexes;
	lgraph->numEdges = mgraph->numEdges;
	for(i=0;i<mgraph->numVertexes;i++){
		lgraph->adjList[i].data = mgraph->vex[i];
		lgraph->adjList[i].firstarc = NULL;    //别忘了初始化
	}

	for(i=0;i<mgraph->numVertexes;i++){
		struct EdgeNode *p = NULL;
		for(j=0;j<mgraph->numVertexes;j++){
			struct EdgeNode *e = NULL;
			if(mgraph->arc[i][j]!=INFINITY){
				e = (struct EdgeNode *)malloc(sizeof(struct EdgeNode));
				e->next = NULL;
				e->adjex = j;
				if(lgraph->adjList[i].firstarc == NULL){
					lgraph->adjList[i].firstarc = e;
				}
				else{
					p->next = e;
				}
				p = e;
			}
		}
	}
	return lgraph;
}
 

 


 
 
其中本文中创建的两种方式的顶点输入其实都是0、1、2。。。，特此说明 

最后，总的代码如下，最后还加上了关于显示邻接矩阵和邻接表的两个display函数：
 

 

#include <stdio.h>
#include <stdlib.h>

#define MAXVEX 100
#define INFINITY 65536

struct MGraph{
	int vex[MAXVEX];			//顶点表
	int arc[MAXVEX][MAXVEX];    //邻接矩阵，可看左边表
	int numVertexes,numEdges;   //图中的顶点数和边数
};

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

typedef struct VexNode{		//顶点表结点
	int data;    //顶点
	EdgeNode *firstarc;   //边表头指针
}AdjList[MAXVEX];

struct LGraph{
	int numVertexes,numEdges;
	AdjList adjList;   
};

//用邻接矩阵创建图
void createMGraph(MGraph *mGraph){
	printf("请输入图的顶点数和边数：\n");
	scanf("%d%d",&mGraph->numVertexes,&mGraph->numEdges);
	int i,j,k,w;
	//getchar();
	printf("请输入个顶点：\n");
	for(i = 0;i < mGraph->numVertexes; i++){
		//scanf("%c",&mGraph->vex[i]);
		scanf("%d",&mGraph->vex[i]);   //在处理%c的时候，需要注意前面输入顶点数和边数的最后的回车键，需要用getchar获取到
	}
	//getchar();
	for (i = 0; i < mGraph->numVertexes; i++)
		for(j = 0; j < mGraph->numVertexes;j++)
			mGraph->arc[i][j] = INFINITY;
	for(k = 0;k < mGraph->numEdges; k++){
		printf("请输入边(vi,vj)上的下标i，下标j和权值w:\n");
		scanf("%d%d%d",&i,&j,&w);
		mGraph->arc[i][j]=mGraph->arc[j][i]=w;
	}
}

//用邻接表创建图，其中边表结点链表使用的是头插法
void createLGraph(LGraph *lGraph){
	printf("请输入图的顶点数和边数：\n");
	scanf("%d%d",&lGraph->numVertexes,&lGraph->numEdges);
	int i,j,k,w;
	printf("请输入个顶点:\n");
	for(i = 0;i < lGraph->numVertexes; i++){
		scanf("%d",&lGraph->adjList[i].data);
		lGraph->adjList[i].firstarc = NULL;
	}
	for(k = 0;k < lGraph->numEdges; k++){
		printf("请输入边(vi,vj)上的下标i，下标j:\n");
		scanf("%d%d",&i,&j);
		EdgeNode *e = (EdgeNode*)malloc(sizeof(struct EdgeNode));
		e->adjex = j;
		e->next = lGraph->adjList[i].firstarc;
		lGraph->adjList[i].firstarc = e;

		e = (struct EdgeNode*)malloc(sizeof(struct EdgeNode));
		e->adjex = i;
		e->next = lGraph->adjList[j].firstarc;
		lGraph->adjList[j].firstarc = e;
	}
}

//用邻接表创建图，其中边表的链表使用的是尾插法
void createLGraph2(LGraph *graph){
	printf("请输入图的总顶点数和总边数:\n");
	scanf("%d%d",&graph->numVertexes,&graph->numEdges);
	int i,j,k;
	printf("请输入个顶点:\n");
	for(i=0;i<graph->numVertexes;i++){
		scanf("%d",&graph->adjList[i].data);
		graph->adjList[i].firstarc = NULL;
	}
	EdgeNode *e = NULL,*q = NULL,*p = NULL;
	for(i=0;i<graph->numVertexes;i++){
		printf("创建第%d个顶点的所有边,输入-1结束\n",i);
		int x;
		scanf("%d",&x);
		while(x!=-1){
			e = (struct EdgeNode *)malloc(sizeof(struct EdgeNode));
			e->adjex = x;
			e->next = NULL;
			if(graph->adjList[i].firstarc == NULL){
				graph->adjList[i].firstarc = e;
			}
			else{
				p->next = e;
			}
			p = e;
			scanf("%d",&x);
		}
	}
}

//将图的邻接矩阵的表示形式转换为邻接表表示
LGraph* convert(MGraph *mgraph){
	int i,j;
	LGraph *lgraph = (LGraph *)malloc(sizeof(struct LGraph));
	lgraph->numVertexes = mgraph->numVertexes;
	lgraph->numEdges = mgraph->numEdges;
	for(i=0;i<mgraph->numVertexes;i++){
		lgraph->adjList[i].data = mgraph->vex[i];
		lgraph->adjList[i].firstarc = NULL;
	}

	for(i=0;i<mgraph->numVertexes;i++){
		struct EdgeNode *p = NULL;
		for(j=0;j<mgraph->numVertexes;j++){
			struct EdgeNode *e = NULL;
			if(mgraph->arc[i][j]!=INFINITY){
				e = (struct EdgeNode *)malloc(sizeof(struct EdgeNode));
				e->next = NULL;
				e->adjex = j;
				if(lgraph->adjList[i].firstarc == NULL){
					lgraph->adjList[i].firstarc = e;
				}
				else{
					p->next = e;
				}
				p = e;
			}
		}
	}
	return lgraph;
}

void display(MGraph *graph){
	int i,j;
	for(i=0;i<graph->numVertexes;i++){
		for(j=0;j<graph->numVertexes;j++){
			printf("%d ",graph->arc[i][j]);
		}
		printf("\n");
	}
}

void display(LGraph *graph){
	int i,j;
	for(i=0;i<graph->numVertexes;i++){
		EdgeNode *tmp = graph->adjList[i].firstarc;
		printf("当前顶点是%d ",graph->adjList[i].data);
		while(tmp){
			printf("%d ",tmp->adjex);
			tmp = tmp->next;
		}
		printf("\n");
	}
}

int main(){
	MGraph metrixGraph;
	createMGraph(&metrixGraph);
	display(&metrixGraph);

	LGraph lgraph;
	createLGraph(&lgraph);
	display(&lgraph);

	createLGraph2(&lgraph);
	display(&lgraph);

	printf("讲邻接矩阵表示的图转换为用邻接表表示:\n");
	lgraph = *convert(&metrixGraph);
	display(&lgraph);
	return 0;
}
 


 
 

未完待续 下一节 图算法二之DFS
 

 

 如果文章有什么错误或者有什么建议，欢迎提出，大家共同交流，一起进步
 
 

 文章转载请注明出处，请尊重知识产权

                

        

        

    




    

      

        

            

              
                
                  thepeakofmountain
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    4
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
基于免疫自适应遗传算法的机器人栅格地图融合

				
			

			

				

					02-22
				

			

		

		

			
				
提出了一种基于免疫自适应遗传算法的栅格地图融合方法,该算法把反映两个栅格地图重叠区域相异程度的优化函数作为抗原,每个可能的平移、旋转平面转换对应一个抗体.仿真结果表明了该算法可以较快的收敛速度和较强的...

			
		

	



                

              
                



	

		

			

				
					
数据结构之图论算法（一）图的存储结构及其构建算法

				
			

			

				

					huxxyyy的博客
				

				

					08-11
					
					1729
					
				

			

		

		

			
				
数据结构之图论算法（一）图的存储结构
构成图的基本要素：
顶点+边（弧）
邻接矩阵存储结构（数组表示法）
总：图（二维数组） = 顶点（顶点表） + 边（邻接矩阵，即二维数组本身）
设图为：A = （V，E），则

上面是无向图的情况。其邻接矩阵是对称的。
而有向图的邻接矩阵中，将列看为“出”，行看为“入”， 所以列上的顶点出，行上的顶点入，满足的才是1。因此，有向图不一定对称。
有向网络的邻接矩阵也是同理：
代码表示：


#define INFINITY INT_MAX	//最大值，表示无穷大
#def

			
		

	



                


  
              

                


	

		

			

				
					
三种建图算法的原理（覆盖栅格建图算法、计数建图算法、TSDF建图算法）

				
			

			

				

					shoufei403的博客
				

				

					12-23
					
					7467
					
				

			

		

		

			
				
机器人地图的分类
尺度地图（Metric Map）

机器人领域中常见的尺度地图有栅格地图和点云地图。它的好处是可以用一个唯一的坐标描述一个具体的位置。
拓扑地图（Topological Map）

拓扑地图用节点表示每一个位置，位置与位置连接的线就是可以通行的路。拓扑地图一般用于大地图，比如国家公路网和城市地图路线图等等。
语义地图（Semantic Map）

语义地图会用标签来描述地点。如手...

			
		

	





	

		

			

				
					
图的构建方式

				
			

			

				

					FYPPPP的博客
				

				

					03-27
					
					557
					
				

			

		

		

			
				
左神的模板：
图：
package class06;

import java.util.HashMap;
import java.util.HashSet;

public class Graph {
	public HashMap<Integer,Node> nodes;//点集：键是点的编号，值是具体的每一个点
	public HashSet<Edge> edges;//边集

	public Graph() {
		nodes = new HashMap<>();

			
		

	



		

			
		



	

		

			

				
					
几种图的构建方法的总结

				
			

			

				

					x_y_q_的博客
				

				

					07-13
					
					1752
					
				

			

		

		

			
				
图的构成有各种各样的方式，只要你认为逻辑上能形成一张图，并且你看得懂自己的构图数据，那么就是一张好图。。（这只是我的一点认为）


为了打ACM不得不使用简洁，效率高的代码（说白了就是赶时间）  下面总结几种方法


第一种    也是目前比较流行的   邻接表形式

/********************************************************

			
		

	





	

		

			

				
					
JAVA算法：创建图算法（构建图）

				
			

			

				

					梅森上校的博客  业精于勤荒于嬉，形成于思毁于随。
				

				

					06-01
					
					4724
					
				

			

		

		

			
				
JAVA算法：创建图算法（构建图）

有北京、上海、广州、重庆、武汉、南昌五个城市，它们之间的关系和路径成本如图所示。

现在需要编写一个算法使用邻接矩阵表示上面的图。









算法设计




package com.bean.algorithm.graph3;

public class GraphMatrix {

	static final int MaxNum = 20...

			
		

	





	

		

			

				
					
使用模拟 退火、爬山和遗传算法使用形状重新创建图像_python_代码_下载

				
			

			

				

					06-21
				

			

		

		

			
				
效果展示： https://github.com/rish-16/Metroplex/blob/master/assets/earth_output.jpg ... 通过随机优化使用不同颜色和大小的形状重新创建图片  样品 这是我使用转换的一些示例图像Metroplex。

			
		

	





	

		

			

				
					
一种改进粒子群优化算法的多机器人地图拼接方法

				
			

			

				

					07-07
				

			

		

		

			
				
多机器人共同创建大规模地图，实现的关键在于机器人相对位置未知的情况下将多张局部栅格地图进行拼接。结合图像特征匹配的方法和改进的粒子群优化算法，先提取待拼接的两幅栅格地图的特征点进行匹配，并筛选有效特征...

			
		

	





	

		

			

				
					
实验六 图（算法与数据结构）

				
			

			

				

					04-25
				

			

		

		

			
				
理解实现无向图邻接表的创建的算法，理解实现无向图的深度优先遍历的算法；转换成程序并上机实现，并按要求撰写...实现无向图邻接矩阵的创建，实现无向图邻接矩阵方式存储的深度优先遍历的算法，转换成程序并上机实现

			
		

	





	

		

			

				
					
image2svg-potrace：服务器使用potrace算法将图像转换为svg

				
			

			

				

					02-27
				

			

		

		

			
				
image2svg-potrace 服务器使用Potrace算法将图像转换为svg。相关资料库 入门这些说明将为您提供在本地计算机上运行并运行的项目的副本，以进行开发和测试。 有关如何在实时系统上部署项目的注释，请参阅部署。先决...

			
		

	





	

		

			

				
					
基本图形生成的算法

				
			

			

				

					11-06
				

			

		

		

			
				
计算机辅助工程中，关于一些基本图形的生成，希望对编程有点用

			
		

	





	

		

			

				
					
图算法C语言实现

				
			

			

				

					02-25
				

			

		

		

			
				
图算法，图的性质及类型，图搜索，深度优先搜索，有向图和有向无环图，最小生成树，最短路径，网络流

			
		

	





	

		

			

				
					
C语言 输入无向图连通图的顶点数、顶点信息、边数、顶点对序列及遍历的起始点序号，输出深度优先遍历序列。

				
			

			

				

					05-24
				

			

		

		

			
				
①无向图的非递归深度优先搜索需借用一个堆栈保存被访问过的顶点，以便回溯查找已被访问结点的被访问过的邻接点。
②访问起始顶点v0,visited[v0]标记1,v0入栈，指针p指向v0对应的边表首结点；
③从左到右扫描p所指的边表（邻接表），查找边表中对应顶点的visited[v]标志为0的结点；
④若找到所求结点，则对应的顶点记为v。然后访问v,visited[v]标记1,v入栈,p指向v对应的边表首结点。否则，从栈中出栈一个顶点作为v（即回溯）p指向v对应的边表首结点；
⑤重复②、③直至所有的顶点都被访问一次。

			
		

	





	

		

			

				
					
【数据结构】图算法

				
			

			

				

					Y0704__00的博客
				

				

					10-31
					
					746
					
				

			

		

		

			
				
图的邻接表定义及创建 、无向图上实现深度优先算法 、无向图上实现广度优先遍历算法 、有向无环图上实现拓扑排序算法

			
		

	





	

		

			

				
					
【经典算法实现 33】图的创建 --- 有向邻接矩阵法 与 网

				
			

			

				

					|~~~热爱生活、努力学习的小伙汁~~~|
				

				

					08-25
					
					1734
					
				

			

		

		

			
				
【经典算法实现 33】图的创建 --- 邻接矩阵一、有向邻接矩阵法1. 有向邻接矩阵代码实现2. 运行结果二、网 （带权有向邻接矩阵法）
在前面《【经典算法实现 30】图的创建 — 十字链表法》 中我们实现了使用十字链表法创建图。
还是把之前的那张图搬出来，今天，我们来学习下使用邻接矩阵法创建这幅图：


一、有向邻接矩阵法

无向邻接矩阵的二维边数组是一个对称矩阵，相对比较简单
本章重点来讲下有向邻接矩阵。

有向图的邻接矩阵，如下图所示，使用的是一个一维数组 和一个二维数组来表示。

根据上图，因此我们

			
		

	





	

		

			

				
					
java数据结构和算法——图的创建

				
			

			

				

					小志的博客
				

				

					10-29
					
					605
					
				

			

		

		

			
				
一、示例要求

代码实现如下图结构


二、代码实现示例
1、创建图的类
package com.rf.springboot01.dataStructure.graph;

import java.util.ArrayList;
import java.util.Arrays;

/**
 * @description: 定义一个图 类
 * @author: xiaozhi
 * @create: 2020-10-27 21:58
 */
public class Graph {
    private 

			
		

	





	

		

			

				
					
数据结构与算法之------图的创建超详解

				
			

			

				

					markconca的博客
				

				

					11-18
					
					2799
					
				

			

		

		

			
				
一.用邻接矩阵创建图

思路：先创建一个只有顶点没有边的图，然后把边插入




//用邻接矩阵表示图
#define MaxVertexNum 100
typedef int WeightType;
typedef char DataType;
typedef struct GNode *PtrToGNode;

struct GNode
{
    int Nv;//顶点数
    int N...

			
		

	





	

		

			

				
					
图的创建（五种创建方式）

				
			

			

				

					dztom的博客
				

				

					11-20
					
					1894
					
				

			

		

		

			
				
图的创建，五种创建方式

			
		

	





	

		

			

				
					
经典图割算法中图的构建及实现:Graph-Cut

				
			

			

				

					juluwangriyue的博客
				

				

					11-10
					
					2037
					
				

			

		

		

			
				
讲解目前典型的3种图割算法：graph-cut、grab-but、one-cut。本文主要讲解graph-cut的方法在应用时，准则函数与图构建关系，如何构建图，以及如何代码实现图的构建。图割的原理网上文章和论文已介绍比较详细，不再详细介绍。该方法可谓是图割方法的开山鼻祖。该方法的准则函数如下：E(A)=λR(A)+B(A)E(A) = \lambda R(A) + B(A)E(A)=λR(A)+B(A)R(A)是先验惩罚项，B(A)是区域相似度惩罚项，λ\lambdaλ是平衡因子。该准则函数意义：同类间，

			
		

	





	

		

			

				
					
图像拼接算法及实现sift算法

					
最新发布

				
			

			

				

					11-24
				

			

		

		

			
				
其中的关键步骤之一就是特征点的提取和匹配。SIFT（Scale-Invariant Feature Transform）算法作为一种尺度不变特征转换算法，被广泛应用于图像拼接中。下面是SIFT特征提取的图像拼接算法的实现步骤：  1.读取图像并...

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值