C++ 十字链表图转java版

最新推荐文章于 2021-06-26 21:38:55 发布
最新推荐文章于 2021-06-26 21:38:55 发布
阅读量773 收藏
点赞数
分类专栏： 捉虫记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/judyge/article/details/41303393
版权

C++ 图


#include <iostream>  
#include <string>  
#include <queue>  
#include <stack>  
using namespace std;  
  
bool visited[100]; //顶点是否已被访问的标志数组  
  
//十字链表存储图  
//弧结点  
struct ArcBox  
{  
    //弧结点头尾结点位置  
    int tailvex;  
    int headvex;  
    //弧头和弧尾相同的弧的链域  
    ArcBox *hlink;  
    ArcBox *tlink;  
};  
  
//顶点节点  
struct VexNode  
{  
    string data; //顶点名称  
    ArcBox *firstin; //指向第一条入弧  
    ArcBox *firstout; //指向第一条出弧  
};  
  
class OLGraph  
{  
private:  
    VexNode *xlist; //指向顶点数组的指针  
    int vexnum;  //顶点数  
    int arcnum;  //弧数  
    int maxnum; //顶点数的最大值  
public:  
    OLGraph(int num=20)  
    {  
        xlist=new VexNode[num];  
        maxnum=num;  
    }  
      
    int Locate_Vex(string v)  
    {  
        for(int i=0;i<vexnum;i++)  
        {  
            if(xlist[i].data==v)  
                return i;  
        }  
        return -1;  
    }  
  
    void CreateDG_OLG()  
    {  
        //构造有向图  
        string v1,v2;  
        int i,j,k;  
        cout<<"输入顶点数和边的数目：";  
        cin>>vexnum>>arcnum;  
          
        while(vexnum>maxnum)       
        {  
            cout<<"顶点数目大于最大限制，请重新输入：";  
            cin>>vexnum;  
        }  
  
        cout<<"输入各个顶点的名称：";  
        for(i=0;i<vexnum;i++)  
        {  
            cin>>xlist[i].data;  
            xlist[i].firstin=NULL;  
            xlist[i].firstout=NULL;  
        }  
          
        for(k=0;k<arcnum;k++)  
        {  
            cout<<"输入第"<<k+1<<"条边的两个顶点(尾—>头的顺序)：";  
            cin>>v1>>v2;  
            i=Locate_Vex(v1);  
            j=Locate_Vex(v2);  
              
            while(i == -1 || j == -1)  
            {  
                cout<<"结点位置输入错误,重新输入: ";  
                cin>>v1>>v2;  
                i=Locate_Vex(v1);  
                j=Locate_Vex(v2);     
            }         
              
            ArcBox *p=new ArcBox;  
            p->tailvex=i;  
            p->headvex=j;  
            p->hlink=xlist[j].firstin;  
            p->tlink=xlist[i].firstout;  
            xlist[i].firstout=xlist[j].firstin=p;  
        }  
  
        cout<<"有向图构造完成"<<endl;  
    }  
  
    //统计顶点入度  
    int In_degree(string v)  
    {  
        int pos=Locate_Vex(v);  
        if(pos == -1)  
        {  
            cout<<"结点不在图中"<<endl;  
            return -1;  
        }  
        ArcBox *p=xlist[pos].firstin;  
        int ins=0;  
        while(p)  
        {  
            ins++;  
            p=p->hlink;  
        }  
        return ins;  
    }  
  
    //统计顶点出度  
    int Out_degree(string v)  
    {  
        int pos=Locate_Vex(v);  
        if(pos == -1)  
        {  
            cout<<"结点不在图中"<<endl;  
            return -1;  
        }  
        ArcBox *p=xlist[pos].firstout;  
        int out=0;  
        while(p)  
        {  
            out++;  
            p=p->tlink;  
        }  
        return out;  
    }  
  
    //深度优先遍历  
    void DFS(int v)  
    {  
        visited[v]=true;  
        cout<<xlist[v].data<<"  ";  
        ArcBox *p=xlist[v].firstout;  
        while(p)  
        {  
            if(!visited[p->headvex])  
                DFS(p->headvex);  
            p=p->tlink;  
        }  
    }  
  
    void DFS_Traverse()  
    {  
        for(int i=0;i<vexnum;i++)  
            visited[i]=false;  
        for(int i=0;i<vexnum;i++) 
            if(!visited[i])  
                DFS(i); 	 
    }  
  
    //广度优先遍历  
    void BFS(int v)  
    {  
        visited[v]=true;  
        cout<<xlist[v].data<<"  ";  
        queue<int> qu;  
        int vex;  
        ArcBox *p;  
        qu.push(v);  
        while(!qu.empty())  
        {  
            vex=qu.front();  
            qu.pop();  
            p=xlist[vex].firstout;  
            while(p)  
            {  
                if(!visited[p->headvex])  
                {  
                    visited[p->headvex]=true;  
                    cout<<xlist[p->headvex].data<<"  ";  
                    qu.push(p->headvex);  
                }  
                p=p->tlink;  
            }  
        }  
    }  
  
    void BFS_Traverse()  
    {  
        for(int i=0;i<vexnum;i++)  
            visited[i]=false;  
        for(int i=0;i<vexnum;i++)  
            if(!visited[i])  
                BFS(i);  
    }  
  
    void DFS_2(int v)  
    {  
        visited[v]=true;  
        cout<<xlist[v].data<<"  ";  
        stack<int> s;  
        ArcBox *p;  
        int pos;  
        s.push(v);  
        while(!s.empty())  
        {  
            pos=s.top();  
            p=xlist[pos].firstout;  
            while(p && visited[p->headvex])  
                p=p->tlink;  
            if(!p)  
                s.pop();  
            else  
            {  
                visited[p->headvex]=true;  
                cout<<xlist[p->headvex].data<<"  ";  
                s.push(p->headvex);  
            }  
        }  
    }  
  
    void DFS_Traverse_2()  
    {  
        for(int i=0;i<vexnum;i++)  
            visited[i]=false;  
        for(int i=0;i<vexnum;i++)  
            if(!visited[i])  
                DFS_2(i);  
    }  
    //求连通分支数  
    int Connect_Cpnt()  
    {  
        for(int i=0;i<vexnum;i++)  
            visited[i]=false;  
        cout<<"下面的每一行显示一个连通分支："<<endl;  
        int num=1;  
        DFS(0);  
        cout<<endl;  
        for(int i=0;i<vexnum;i++)  
        {  
            if(!visited[i])  
            {  
                num++;  
                DFS(i);  
                cout<<endl;  
            }  
        }  
        return num;  
    }  
};  


#include "Graphis.h"  
#include <iostream>  
#include <string>  
using namespace std;  
  
int main()  
{  
    OLGraph G;  
    string v;  
    int ins,out,a;  
    G.CreateDG_OLG();  
      
    cout<<"输入要统计哪个结点的入度：";  
    cin>>v;  
    ins=G.In_degree(v);  
    if(ins != -1)  
        cout<<"顶点"<<v<<"的入度为："<<ins<<endl;  
  
    cout<<"输入要统计哪个结点的出度：";  
    cin>>v;  
    out=G.Out_degree(v);  
    if(out != -1)  
        cout<<"顶点"<<v<<"的出度为："<<out<<endl;  
  
    cout<<"深度优先遍历：";  
    G.DFS_Traverse();  
    cout<<endl;  
  
    cout<<"广度优先遍历：";  
    G.BFS_Traverse();  
    cout<<endl;  
  
    cout<<"计算图的连通分支"<<endl;  
    int num=G.Connect_Cpnt();  
    cout<<"图的连通分支数目为："<<num<<endl;  
  
    cout<<"深度优先遍历非递归：";  
    G.DFS_Traverse_2();  
    cout<<endl;  
  
    return 0;  
}

java版 


package graphis;

public class ArcBox {
	//弧结点头尾结点位置  
    int tailvex;  
    int headvex;  
    //弧头和弧尾相同的弧的链域  
    ArcBox hlink;  
    ArcBox tlink; 

}

package graphis;

public class VexNode {
	String data; //顶点名称  
    ArcBox firstin; //指向第一条入弧  
    ArcBox firstout; //指向第一条出弧  
}


package graphis;
import java.util.*;

public class OLGraph {
	
	  boolean visited[]=new boolean[100];
	    public  VexNode[] xlist=new VexNode[20]; //指向顶点数组的指针  
	    private int vexnum;  //顶点数  
	    private int arcnum;  //弧数  
	    private int maxnum; //顶点数的最大值  
	  
	public  OLGraph(int num)  
	    {  
	       this.xlist=new VexNode[num];
	       for(int i=0;i<20;i++)
			{
	    	   xlist[i]=new VexNode();
			}
	        maxnum=num;  
	    }  
	      
	    int Locate_Vex(String v)  
	    {  
	        for(int i=0;i<vexnum;i++)  
	        {  
	            if(xlist[i].data.equals(v); 	            	
	                return i;  
	        }  
	        return -1;  
	    }  
	  
	    void CreateDG_OLG()  
	    {  
	        //构造有向图  
	        String v1,v2;  
	        int i,j,k;  
	        System.out.println("输入顶点数和边的数目：");  
	        Scanner input = new Scanner(System.in);
	        vexnum = input.nextInt();
	        arcnum =  input.nextInt(); 
	          
	        while(vexnum>maxnum)       
	        {  
	        	System.out.println("顶点数目大于最大限制，请重新输入：");  
	            vexnum=input.nextInt(); ;  
	        }  
	  
	        System.out.println("输入各个顶点的名称：");  
	        for(i=0;i<vexnum;i++)  
	        {  
	            xlist[i].data=input.next();
	            xlist[i].firstin=null;  
	            xlist[i].firstout=null;  
	        }  
	          
	        for(k=0;k<arcnum;k++)  
	        {  
	        	System.out.println("输入第"+k+1+"条边的两个顶点(尾—>头的顺序)：");
	            v1=input.next();
	            v2=input.next();  
	            i=Locate_Vex(v1);  
	            j=Locate_Vex(v2);  
	              
	            while(i == -1 || j == -1)  
	            {  
	            	 System.out.println("结点位置输入错误,重新输入: ");  
	            	v1=input.next();
	 	            v2=input.next();    
	                i=Locate_Vex(v1);  
	                j=Locate_Vex(v2);     
	            }         
	              
	            ArcBox p=new ArcBox();  
	            p.tailvex=i;  
	            p.headvex=j;  
	            p.hlink=xlist[j].firstin;  
	            p.tlink=xlist[i].firstout;  
	            xlist[i].firstout=xlist[j].firstin=p;  
	        }  
	  
	        System.out.println("有向图构造完成\n");  
	        input.close();
	    }  
	  
	    //统计顶点入度  
	    int In_degree(String v)  
	    {  
	        int pos=Locate_Vex(v);  
	        if(pos == -1)  
	        {  
	        	System.out.println("结点不在图中\n");  
	            return -1;  
	        }  
	        ArcBox p=xlist[pos].firstin;  
	        int ins=0;  
	        while(p!=null)  
	        {  
	            ins++;  
	            p=p.hlink;  
	        }  
	        return ins;  
	    }  
	  
	    //统计顶点出度  
	    int Out_degree(String v)  
	    {  
	        int pos=Locate_Vex(v);  
	        if(pos == -1)  
	        {  
	        	System.out.println("结点不在图中\n");  
	            return -1;  
	        }  
	        ArcBox p=xlist[pos].firstout;  
	        int out=0;  
	        while(p!=null)  
	        {  
	            out++;  
	            p=p.tlink;  
	        }  
	        return out;  
	    }  
	  
	    //深度优先遍历  
	    void DFS(int v)  
	    {  
	        visited[v]=true;  
	        System.out.println(xlist[v].data+"  ");  
	        ArcBox p=xlist[v].firstout;  
	        while(p!=null)  
	        {  
	            if(!visited[p.headvex])  
	                DFS(p.headvex);  
	            p=p.tlink;  
	        }  
	    }  
	  
	    void DFS_Traverse()  
	    {  
	        for(int i=0;i<vexnum;i++)  
	            visited[i]=false;  
	        for(int i=0;i<vexnum;i++) 
	            if(!visited[i])  
	                DFS(i); 	 
	    }  
	  
	    //广度优先遍历  
	    void BFS(int v)  
	    {  
	        visited[v]=true;  
	        System.out.println(xlist[v].data+"  ");  
	        Queue<Integer> qu= new LinkedList<Integer>();  
	        int vex;  
	        ArcBox p;  
	        qu.offer(v);  
	        while(qu.peek()!=null)  
	        {  
	            vex=qu.peek();  
	            qu.poll();  
	            p=xlist[vex].firstout;  
	            while(p!=null)  
	            {  
	                if(!visited[p.headvex])  
	                {  
	                    visited[p.headvex]=true;  
	                    System.out.println(xlist[p.headvex].data+"  ");  
	                    qu.offer(p.headvex);  
	                }  
	                p=p.tlink;  
	            }  
	        }  
	    }  
	  
	    void BFS_Traverse()  
	    {  
	        for(int i=0;i<vexnum;i++)  
	            visited[i]=false;  
	        for(int i=0;i<vexnum;i++)  
	            if(!visited[i])  
	                BFS(i);  
	    }  
	  
	    void DFS_2(int v)  
	    {  
	        visited[v]=true;  
	        System.out.println(xlist[v].data+"  ");  
	        Stack<Integer> s = new Stack<Integer>();   
	        ArcBox p;  
	        int pos;  
	        s.push(v);  
	        while(!s.empty())  
	        {  
	            pos=s.peek(); 
	            p=xlist[pos].firstout;  
	            while(p!=null && visited[p.headvex])  
	                p=p.tlink;  
	            if(p==null)  
	                s.pop();  
	            else  
	            {  
	                visited[p.headvex]=true;  
	                System.out.println(xlist[p.headvex].data+"  ");  
	                s.push(p.headvex);  
	            }  
	        }  
	    }  
	  
	    void DFS_Traverse_2()  
	    {  
	        for(int i=0;i<vexnum;i++)  
	            visited[i]=false;  
	        for(int i=0;i<vexnum;i++)  
	            if(!visited[i])  
	                DFS_2(i);  
	    }  
	    //求连通分支数  
	    int Connect_Cpnt()  
	    {  
	        for(int i=0;i<vexnum;i++)  
	            visited[i]=false;  
	        System.out.println("下面的每一行显示一个连通分支：\n");  
	        int num=1;  
	        DFS(0);  
	        System.out.println("\n");   
	        for(int i=0;i<vexnum;i++)  
	        {  
	            if(!visited[i])  
	            {  
	                num++;  
	                DFS(i);  
	                System.out.println("\n");  
	            }  
	        }  
	        return num;  
	    }  

}


package graphis;

import java.util.Scanner;

public class Test {
	public static void main(String args[]){
		
		OLGraph G=new OLGraph(20);  
	    String v;  
	    int ins,out;  
	    G.CreateDG_OLG();  
	      
	    System.out.println("输入要统计哪个结点的入度："); 
	    Scanner input = new Scanner(System.in);
	    v=input.next();  
	    ins=G.In_degree(v);  
	    if(ins != -1)  
	    	 System.out.println("顶点"+v+"的入度为："+ins+'\n');  
	  
	    	 System.out.println("输入要统计哪个结点的出度：");  
	    v=input.next(); 
	    out=G.Out_degree(v);  
	    if(out != -1)  
	    	System.out.println("顶点"+v+"的出度为："+out+'\n');  
	  
	    System.out.println("深度优先遍历：");  
	    G.DFS_Traverse();  
	    System.out.println('\n');  
	  
	    System.out.println("广度优先遍历：");  
	    G.BFS_Traverse();  
	    System.out.println('\n');  
	  
	    System.out.println("计算图的连通分支"+'\n');  
	    int num=G.Connect_Cpnt();  
	    System.out.println("图的连通分支数目为："+num+'\n');  
	  
	    System.out.println("深度优先遍历非递归：");  
	    G.DFS_Traverse_2();  
	    System.out.println('\n');  
	    input.close();
	    
	}

}


judyge
关注
专栏目录
【C++/嵌入式梳理】二、23.Cookie和Session | DNS | URL
Hi
06-20 1018
【C++/嵌入式笔试面试八股】二、23.Cookie和Session | DNS | URL
java 十字链表
xyjikl
11-26 1467
结点package crossList; public class OLNode { //非零元素的行和列下标 int row, col; int value; //右边节点指针 OLNode right; //下方节点指针 OLNode down; } package crossList; import cr
Java实现十字链表
Caiji的博客
04-19 666
使用Java实现十字链表数据结构 存在着3个自定义类——Graph2、Data2、Vertex2，Graph用于定义图，Data2用于表示顶点节点的Struct，Vertex用于表示弧节点的Struct，定义同教材。 文件1-Graph2.java package orthogonallist; public class Graph2 { //自定义图，可存储50个节点 ...
数据结构（图）——十字链表（Java实现）
Advance_的博客
07-03 1501
　　上次学习了图的邻接表，对于有向图来讲，邻接表是有缺陷的，我们想得到一个顶点的出度，对该顶点的边表遍历即可，需要一个顶点的入度，则需要遍历整个图（逆邻接表解决了入度，解决不了出度）。 　　这时可以将邻接表跟逆邻接表结合起来就是我们所要说的——十字链表。 　　这里是个小例子： 　　图１ 　　内部类定义顶点数组：三个属性分别存放顶点，入边表，出边表 　　 private class Ve...
java 链表_图的存储结构之十字链表（Java实现）
weixin_39609354的博客
12-02 177
我们想要知道出度方向的顶点，可以使用邻接表，我们要了解入度就需要使用逆邻接表。但是我们既想要了解入度又想要了解出度，那么我们该如何处理？这时就需要使用到有向图的一种存储方法：十字链表顶点表结点结构firstin表示入边表头指针，指向该顶点的入边表中第一个结点。firstout表示出边表头指针，指向该顶点的出边表中第一个结点。边表结点结构tailvex是指弧起点在顶点表的下标headvex是指弧终点...
Java学习第37天：十字链表
xiaowuPHD的博客
06-26 232
概念： 十字链表是为了便于求得图中顶点的度（出度和入度）而提出来的。它是综合邻接表和逆邻接表形式的一种链式存储结构。 在十字链表存储结构中，有向图中的顶点的结构如下所示： 其中data表示顶点的具体数据信息，而firstIn则表示指向以该顶点为弧头的第一个弧节点。而firstOut则表示指向以该顶点为弧尾的第一个弧节点。为了表示有向图中所有的顶点，采用一个顶点数组存储每一个结点，如下图所示。 从十字链表的数据结构来看，每一个顶点对应两个链表：以该顶点为弧尾的弧结点所组成的链表以及以该..
稀疏矩阵十字链表
10-05
稀疏矩阵十字链表
深度优先算法和十字链表
05-27
在提供的"深度优先算法和十字链表程序实现"文件中，我们可以预期找到一个使用C++或Java等编程语言编写的程序，该程序将实现深度优先搜索算法，并利用十字链表数据结构来存储和操作图。代码可能包括定义顶点类、边类...
【数据结构基础】矩阵的存储结构，数组，三元组表及十字链表
热门推荐
wayne_lee_lwc的博客
12-04 1万+
前言 数据结构，一门数据处理的艺术，精巧的结构在一个又一个算法下发挥着他们无与伦比的高效和精密之美，在为信息技术打下坚实地基的同时，也令无数开发者和探索者为之着迷。 也因如此，它作为博主大二上学期最重要的必修课出现了。由于大家对于上学期C++系列博文的支持，我打算将这门课的笔记也写作系列博文，既用于整理、消化，也用于同各位交流、展示数据结构的美。 此系列文章，将会分成两条主线，一条“数据结构基础”，一条“数据结构拓展”。“数据结构基础”主要以记录课上内容为主，“拓展”则是以课上内容为基础的更加高深的数据结构
图像腐蚀 java_OpenCV3 图像膨胀 dilate、腐蚀 erode、提取图像中的条形码 JAVA 实现...
weixin_39638304的博客
02-25 425
关于 JAVA 学习 OpenCV 的内容，函数讲解，案例代码内容我均整理在 GitHub【OpenCV3-Study-JAVA 】上下面代码中所需的项目结构，图片，请访问 GitHub 获取。代码展示package opencv;import opencv.base.OpenCVStudyBase;import org.junit.Test;import org.opencv.core.*;im...
图的十字链表存储法详解
数据结构和算法教程（C语言版）
04-15 4866
前面介绍了图的邻接表存储法，本节继续讲解图的另一种链式存储结构——十字链表法。 与邻接表不同，十字链表法仅适用于存储有向图和有向网。不仅如此，十字链表法还改善了邻接表计算图中顶点入度的问题。 十字链表存储有向图（网）的方式与邻接表有一些相同，都以图（网）中各顶点为首元节点建立多条链表，同时为了便于管理，还将所有链表的首元节点存储到同一数组（或链表）中。 其中，建立个各个链表中用于存储顶点的首元节点...
java十字链表_Java 8公共更新的最后阶段–处于十字路口的商业用户
07-07 129
随着人们努力了解Oracle JDK与Oracle的OpenJDK构建与OpenJDK构建之间的差异，所涉及的成本，是否跳上Java版本发布的好事以及2018年，对于Java世界来说，2018年是充满不确定性和误解的一年。清单继续。 一些Java Champion 联手解散 Java版本并支持混乱。 他们创建了一个Google文档 ，其中总结了Oracle所做的所有更改以及Java SE用...
Java实现十字链表度的计算
weixin_43408956的博客
04-21 217
//计算度 public static int countDegreeByCrossLink(struct[] graph, char v, int n){//graph[]为给定定点顺序表，v为所有计算的顶点，n为定点个数 int i ; arc p = null;//弧边 int inDegree = 0, outDegree = 0;...
java十字图_(学习java)用十字链表表示有向图
weixin_30863333的博客
02-25 194
/*** Author:scorpio0zry** 功能:用java创建十字链表 表示有向图** */public class CrossGraph {int vexL; // 顶点数量int sideL; // 边的数量Vertex[] vertexs; // 顶点数组// 定义顶点结点private class Vertex {char vertex;SideNode firstin; // ...
基于十字链表储存大型路网Java实现
weixin_41399650的博客
04-11 625
文章首先介绍了图的十字链表表示原理，基于java实现了图的十字链表表示方法，后续将记录相关路径规划算法。
(学习java)用十字链表表示有向图
scropio0zry的博客
11-19 872
/** * Author:scorpio0zry * * 功能:用java创建十字链表 表示有向图 * * */ public class CrossGraph { int vexL; // 顶点数量 int sideL; // 边的数量 Vertex[] vertexs; // 顶点数组 // 定义顶点结点 private class Vertex { char
图之十字链表
suns的专栏
12-30 844
有向图的十字链表存储结构及Java实现；
十字链表的应用
weixin_33923148的博客
04-28 232
#include<iostream> #include<cstring> #include<cstdio> #include<cstdlib> #define MAX_VERTEX_NUM 20 using namespace std; typedef struct ArcBox{ ...
数据结构学习笔记 --- 图（十字链表）
JAVAweb学习
02-22 326
1.  图（十字链表）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值