精华内容
下载资源
问答
  • java中图的构造与遍历

    2019-11-11 17:25:49
    1、图的定义。 2、图的构造 3、图的遍历

    1、图的定义。

    图分为两个部分组长,包括边和点。将点用边连接起来就形成了图。
    图也分为有向图与无向图。有向图就是边会带上方向。指明从哪个点到哪个点,反之无向图指没有方向得边。更多的时候会给边加上值,在图中,我们称之为该边得权。有向图中,叫做,有向带权图。无向图中,叫做,无向带权图。

    2、图的构造

    图是由边和点组成。那么构造就从边和点开始。
    边:
    每条边得两端各对应一个点,边得大小。所以图得边构造类如下:

     /**
         * 图中的边
         */
    
        //边的左节点
        GraphNode leftNode;
    
        //边的右节点
        GraphNode rightNode;
    
        //边的权值
        int value;
    
        public GraphEdge(GraphNode leftNode,GraphNode rightNode,int value){
            this.leftNode = leftNode;
            this.rightNode = rightNode;
            this.value = value;
        }
    

    点:

    一个点可对应零条或者多条边。以及为了图得遍历,可对点设置boolean值。用来判断该点是否遍历过。点得构造类如下:

    /**
         * 图的节点
         */
         int value;//节点得值
         boolean tf;//节点是否遍历过
    
         List<GraphEdge> edges;//该节点连接得边
    
    
         public GraphNode(int value,boolean tf){
             this.value = value;
             this.tf = tf;
         }
    
         public void addEdge(GraphEdge edge){
             if(edges == null){
                 edges= new ArrayList<>();
             }
             edges.add(edge);
         }
    

    3、图的遍历

    遍历之前,先构造一个简单得图。构造代码如下:

    	/**
         * 生成图
         */
        
        //存放点得集合
        List<GraphNode> nodeList = null;
        //初始化点
        public void initNode(int n ){
            if(nodeList == null){
                nodeList = new ArrayList<>();
            }
    
            GraphNode node = null;
            for(int i = 0; i < n ; i++){
                node = new GraphNode(i,false);
                nodeList.add(node);
            }
        }
    
        //初始化边
        public void initGraph(int n){
            initNode(n);
            GraphEdge edge01 = new GraphEdge(nodeList.get(0),nodeList.get(1),0);
            GraphEdge edge02 = new GraphEdge(nodeList.get(0),nodeList.get(2),0);
            GraphEdge edge13 = new GraphEdge(nodeList.get(1),nodeList.get(3),0);
            GraphEdge edge14 = new GraphEdge(nodeList.get(1),nodeList.get(4),0);
            GraphEdge edge25 = new GraphEdge(nodeList.get(2),nodeList.get(5),0);
            GraphEdge edge26 = new GraphEdge(nodeList.get(2),nodeList.get(6),0);
            GraphEdge edge37 = new GraphEdge(nodeList.get(3),nodeList.get(7),0);
            GraphEdge edge47 = new GraphEdge(nodeList.get(4),nodeList.get(7),0);
            GraphEdge edge56 = new GraphEdge(nodeList.get(5),nodeList.get(6),0);
            GraphEdge edge67 = new GraphEdge(nodeList.get(6),nodeList.get(7),0);
    
            nodeList.get(0).addEdge(edge01);
            nodeList.get(0).addEdge(edge02);
            nodeList.get(1).addEdge(edge13);
            nodeList.get(1).addEdge(edge14);
            nodeList.get(2).addEdge(edge25);
            nodeList.get(2).addEdge(edge26);
            nodeList.get(3).addEdge(edge37);
            nodeList.get(4).addEdge(edge47);
            nodeList.get(5).addEdge(edge56);
            nodeList.get(6).addEdge(edge67);
    
        }
        //获取所有点    
        public List<GraphNode> getNodeList() {
            return nodeList;
        }
    

    构造完成之后进行图的遍历,可通过深度遍历与广度遍历完成
    深度遍历可通过递归或栈完成。广度遍历可通过队列完成。
    1、图得深度遍历-栈

     public void dfSearchTraversing(GraphNode node) {
            if (node == null) {
                return;
            }
            Stack<GraphNode> stack = new Stack<GraphNode>();//创建栈
            stack.push(node);//加入首节点
            while (!stack.isEmpty()) {
                GraphNode node1 = stack.pop();//弹出首节点
                node1.setTf(true);//设置标记,该节点已访问
                System.out.println("节点得值" + node1.getValue());
                List<GraphEdge> list = node1.getEdges();//根据节点获得关联得边
                if (list == null) {//该点无对应得边了
                    continue;
                }
                for (int i = 0; i < list.size(); i++) {
                    GraphEdge graphEdge = list.get(i);//获取每条边对应得另一端节点
                    GraphNode temp = graphEdge.getRightNode();
                    if (temp.getTf()) {//已访问过,就跳过该节点。
                        continue;
                    }
                    stack.push(temp);//将没访问过得节点加入栈中
                }
            }
    
        }
    

    2、图得深度遍历-递归
    对递归算法不太了解得可参考上篇博客博客地址

     public void dfSearchTraversing(GraphNode node) {
            if (node == null || node.getTf()) { //判断节点是否为空,或者是否已经遍历过
                return;
            }
            node.setTf(true);//设置已遍历
            System.out.println("节点:"+node.getValue());
            List<GraphEdge> graphEdgeList = node.getEdges();//获取左节点的应得边
            if(graphEdgeList == null){
                return;
            }
            for(int i = 0; i < graphEdgeList.size(); i ++){
                GraphNode graphNode = graphEdgeList.get(i).getRightNode();//获取边得右节点
                if(graphNode.getTf()) {//判断是否已经遍历过
                    continue;
                }
                dfSearchTraversing(graphNode);//递归调用
            }
    
        }
    

    3、图得广度遍历-队列

    public void bfSearchTraversing(GraphNode node) {
            if(node == null){
                return;
            }
            Queue<GraphNode> queue = new LinkedList<>();//创建队列
            queue.add(node);//加入第一个节点
            while(queue.isEmpty() == false){
                GraphNode node1 = queue.remove();//先进先出。移除节点
                node1.setTf(true);//设置该节点已遍历过
                System.out.println("值:"+node1.getValue());
                List<GraphEdge> list = node1.getEdges();//获取点相关联得边
                if(list == null){
                    continue;
                }
                for(int i = 0; i <list.size(); i++){
                    GraphEdge graphEdge = list.get(i);//获取边对应得右节点
                    GraphNode temp = graphEdge.getRightNode();
                    if(temp.getTf()){//判断该节点是否已经遍历过
                        continue;
                    }
                    queue.add(temp);//加入到队列中
                }
            }
        }
    

    个人记录,仅供参考。

    展开全文
  • java中图的遍历

    2010-09-19 16:02:31
    http://chengyue2007.iteye.com/blog/553106
    展开全文
  • java中图的两种存储方式

    千次阅读 2015-08-09 10:38:49
    大家知道,图这种数据结构在java中有邻接表与邻接矩阵这两种存储方式,前者编程相对复杂但是效率较高,后者编程相对简单但是效率较低,我们利用java可以很容易的实现这两种数据结构。代码如下 邻接矩阵的存储方式:...

    大家知道,图这种数据结构在java中有邻接表与邻接矩阵这两种存储方式,前者编程相对复杂但是效率较高,后者编程相对简单但是效率较低,我们利用java可以很容易的实现这两种数据结构。代码如下

    邻接矩阵的存储方式:

    public class MGraph {
    	
    	
    	 private int[][] edges;//邻接矩阵
    	 private int numOfEdges;//边的数目
    	 private int numOfVetex;//顶点的数目
    	 
    	//初始化一个邻接矩阵 
    	public MGraph(int n) {
    		edges = new int[n][n];
    		numOfEdges = 0;
    		numOfVetex = n;
    	}
    	
    	//初始化一个邻接矩阵并且以一个n*n的矩阵为其赋值
    	public MGraph(int[][] edges,int n){
    		numOfVetex=n;
    		numOfEdges=0;
    		this.edges = new int[n][n];
    		for(int i=0;i<n;i++){
    			for(int j=0;j<n;j++){
    				this.edges[i][j]=edges[i][j];
    				if((edges[i][j]!=-1)&&(edges[i][j]!=0)){
    					numOfEdges++;
    				}
    			}
    		}
    	}
    	
    	//从某一个顶点开始对该图进行深度优先搜索
    	public void DFS(int v) {
    		int[] visited = new int[numOfVetex];
    		for (int i = 0; i < numOfVetex; i++) {
    			visited[i] = 0;
    		}
    		DFSREC(v, visited);
    		System.out.println();
    		int flag=1;
    		for(int i=0;i<visited.length;i++){
    			if(visited[i]==0)
    			{
    				flag=0;
    				break;
    			}
    		}
    		if(flag==1)
    			System.out.println("已遍历完全图");
    		else
    			System.out.println("从该点出发无法遍历全图");
    
    	}
    	
    	//深度优先搜索辅助函数
    	private void DFSREC(int v, int visited[]) {
    		visited[v] = 1;
    		System.out.print(v + "-->");
    		for (int i = 0; i < numOfVetex; i++) {
    			if (edges[v][i] != -1 && edges[v][i] != 0 && visited[i] != 1) {
    				DFSREC(i, visited);
    			}
    		}
    	}
    	
    	//广度优先搜索
    	public void BFS(int v) {
    		int[] qu=new int[numOfVetex];
    		int[] visited=new int[numOfVetex];
    		int head=0;
    		int tail=0;
    		qu[tail++]=v;
    		visited[v]=1;
    		while(head!=tail){
    			int t=qu[head++];
    			System.out.print(t+"-->");
    			for(int i=0;i<numOfVetex;i++){
    				if(edges[t][i]!=-1&&edges[t][i]!=0&&visited[i]==0)
    				{
    					qu[tail++]=i;
    					visited[i]=1;
    				}
    				
    			}
    		}
    		
    	}
    	
    	//测试该图是否为连通图
    	public boolean isConnect(){
    		int[] visited = new int[numOfVetex];
    		for (int i = 0; i < numOfVetex; i++) {
    			visited[i] = 0;
    		}
    		DFSREC(0, visited);
    		
    		for(int i=0;i<visited.length;i++){
    			if(visited[i]==0)
    				return false;
    		}
    		return true;
    	}
    	
    	//输出从顶点u至顶点v的所有长度为l的路径
    	//path数组用来记录当前已经走过的路径
    	//d用来代表当前走过的长度
    	private void pathAllREC(int u,int v,int l,int d,int[] visited,int[] path){
    		visited[u]=1;
    		d++;
    		path[d]=u;
    		if(u==v&&d==l){
    			for(int i=0;i<=d;i++)
    				if(i==d){
    					System.out.print(path[i]);
    				}
    				else{
    					System.out.print(path[i]+"-->");
    				}
    		}
    		else{
    			for(int t=0;t<numOfVetex;t++){
    				if(visited[t]!=1&&edges[u][t]!=0&&edges[u][t]!=-1){
    					pathAllREC(t, v, l, d, visited, path);
    				}
    			}
    			visited[u]=0;
    		}
    	}
    	
    	//输出从顶点u至顶点v的所有长度为l的路径
    	//path数组用来记录当前已经走过的路径
    	//d用来代表当前走过的长度
    	public void pathAll(int u,int v,int l){
    		int d=-1;
    		int[] visited=new int[numOfVetex];
    		int[] path=new int[numOfVetex];
    		pathAllREC(u,v,l,d,visited,path);
    	}
    	
    	
    	
    	
    	
    	public static void main(String args[]){
    		int[][] edges={{0,2,-1,-1},{-1,0,3,1},{-1,-1,0,4},{5,-1,-1,0}};
    		MGraph m=new MGraph(edges,4);
    		m.pathAll(0, 3, 3);
    //		if(m.isConnect()==true)
    //			System.out.println("YES");
    		
    	}
    	 
    	 
    
    }
    

    邻接表的存储方式:

    package Graph;
    
    import java.util.ArrayList;
    
    public class LGraph {
    	//顶点表节点
    	private class VNode{
    		int data;              //起点的序号
    		ArcNode firstArc;      //指向第一条边
    		
    		
    		
    		
    		public VNode(int data, ArcNode firstArc) {
    			this.data = data;
    			this.firstArc = firstArc;
    		}
    		
    		public int getData() {
    			return data;
    		}
    		public void setData(int data) {
    			this.data = data;
    		}
    		public ArcNode getFirstArc() {
    			return firstArc;
    		}
    		public void setFirstArc(ArcNode firstArc) {
    			this.firstArc = firstArc;
    		}
    		
    		
    	}
    	
    	//边表结点
    	private class ArcNode{
    		int adjvex;           //该边指向终点的序号
    		ArcNode nextarc;      //下一条边的指针 
    		int len;              //该边的长度
    		
    		public ArcNode(int adjvex, ArcNode nextarc, int len) {
    			super();
    			this.adjvex = adjvex;
    			this.nextarc = nextarc;
    			this.len = len;
    		}
    
    		public int getAdjvex() {
    			return adjvex;
    		}
    
    		public void setAdjvex(int adjvex) {
    			this.adjvex = adjvex;
    		}
    
    		public ArcNode getNextarc() {
    			return nextarc;
    		}
    
    		public void setNextarc(ArcNode nextarc) {
    			this.nextarc = nextarc;
    		}
    
    		public int getLen() {
    			return len;
    		}
    
    		public void setLen(int len) {
    			this.len = len;
    		}
    		
    		
    		
    		
    	}
    	
    	ArrayList<VNode> vNodes;
    	int numOfVetex;
    	int numOfEdges;
    	
    	public LGraph() {
    		vNodes=new ArrayList<VNode>();
    		numOfVetex=0;
    		numOfEdges=0;
    	}
    	
    	public LGraph(int[][] edges,int n){
    		numOfVetex=n;
    		numOfEdges=0;
    		vNodes=new ArrayList<VNode>();
    		for(int i=0;i<n;i++){
    			VNode v=new VNode(i,null);
    			vNodes.add(v);
    		}
    		for(int i=0;i<n;i++)
    			for(int j=0;j<n;j++)
    			{
    				if(edges[i][j]!=0&&edges[i][j]!=-1){
    					ArcNode arc=new ArcNode(j,null,edges[i][j]);
    					VNode v=vNodes.get(i);
    					arc.setNextarc(v.getFirstArc());
    					v.setFirstArc(arc);
    					numOfEdges++;
    				}
    			}
    	}
    	
    	public void disp(){
    		for(int i=0;i<vNodes.size();i++){
    			System.out.print("Node:"+vNodes.get(i).getData());
    			ArcNode arc=vNodes.get(i).getFirstArc();
    			while(arc!=null){
    				System.out.print("-->"+arc.getAdjvex());
    				arc=arc.getNextarc();
    			}
    			System.out.println();
    		}
    	}
    	
    	//深度优先搜索的辅助函数
    	private void DFSREC(int v,int visited[]){
    		System.out.print(v+"-->");
    		visited[v]=1;
    		ArcNode arc=vNodes.get(v).getFirstArc();
    		while(arc!=null){
    			if(visited[arc.getAdjvex()]==0)
    				DFSREC(arc.getAdjvex(),visited);
    			arc=arc.getNextarc();
    		}
    	}
    	
    	//深度优先搜索
    	public void DFS(int v){
    		int[] visited=new int[numOfVetex];
    		DFSREC(v,visited);
    	}
    	
    	//广度优先搜索
    	public void BFS(int v){
    		int[] qu=new int[numOfVetex];
    		int tail=0;
    		int head=0;
    		int[] visited=new int[numOfVetex];
    		qu[tail++]=v;
    		while(head!=tail){
    			int t=qu[head++];
    			visited[t]=1;
    			System.out.print(t+"-->");
    			ArcNode arc=vNodes.get(t).getFirstArc();
    			while(arc!=null){
    				if(visited[arc.getAdjvex()]!=1){
    					qu[tail++]=arc.getAdjvex();
    				}
    				arc=arc.getNextarc();
    			}
    		}
    	}
    	
    	//将邻接表存储的图转化为矩阵存储的图
    	public MGraph toMGraph(){
    		int[][] edges=new int[numOfVetex][numOfVetex];
    		for(int i=0;i<vNodes.size();i++){
    			edges[i][i]=0;
    			ArcNode arc=vNodes.get(i).getFirstArc();
    			while(arc!=null){
    				edges[i][arc.getAdjvex()]=arc.getLen();
    				arc=arc.getNextarc();
    			}
    		}
    		MGraph m=new MGraph(edges,numOfVetex);
    		return m;
    		
    	}
    	
    	public static void main(String args[]){
    		int[][] edges={{0,2,-1,-1},{-1,0,3,1},{-1,-1,0,4},{5,-1,-1,0}};
    		LGraph l=new LGraph(edges,4);
    		MGraph m=l.toMGraph();
    //		m.DFS(0);
    	}
    	
    	
    	
    
    }
    
    


    展开全文
  • 一个简单的Java 图的任一节点遍历程序
    package HuaWei;

    import java.util.Arrays;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.Scanner;

    public  class GraTree<T> {
        int length;
        public Map<Integer,List<Integer>> MyTree =  new HashMap<>(length);
        public void  DFS(int i,int d)
        {
            if(MyTree.get(i).size()==0&&d<=3)
            {
                System.out.println("深度3以内的节点有:"+i);
                return;
            }
            //System.out.println(MyTree.get(6).size()==0);
            List<Integer> ChildList = MyTree.get(i);
            int length = ChildList.size();
            d++;
            for(int l =0;l<length;l++)
            {
                System.out.println("当前节点:"+i+" 深度:"+d+"   "+ ChildList+"即将遍历节点"+ChildList.get(l));
                DFS(ChildList.get(l),d);
            }
        }
        public GraTree(int n)
        {
            this.length  = n;
        }
        public static void main(String[] args)
        {
            GraTree t = new GraTree(9);        
            Integer[] a1 = {2};            
            t.MyTree.put(1,Arrays.asList(a1));
            Integer[] a2 = {3,6};
            t.MyTree.put(2,Arrays.asList(a2));    
            Integer[] a3 = {4};
            t.MyTree.put(3,Arrays.asList(a3));
            Integer[] a4 = {5};
            t.MyTree.put(4,Arrays.asList(a4));
            Integer[] a5 = {6};
            t.MyTree.put(5,Arrays.asList(a5));
            Integer[] a6 = {};
            t.MyTree.put(6,Arrays.asList(a6));
            
            t.DFS(4, 0);    
            
        }

    }

    展开全文
  • 对算法导论中图的广度优先搜索(BFS)和深度优先搜索(DFS)用Java实现其中的伪代码算法,案例也采用算法导论中的图。 import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; import ...
  • 中图分类号 中图分类号 中图分类号 中图分类号 中图分类号
  • 精品文档可编辑 值得下载 基于JAVA的聚类分析实现 摘要由于聚类技术的不断发展近几年运用范围越来越大在生物学上营销分析...关键词聚类技术Java 中图分类号TP3 文献标识码A 文章编号1009-3044201308-1894-06 1 研究背景
  • GraphStore是用Java编写的内存中图结构实现。 它被设计为功能强大,高效且健壮。 它为Gephi软件提供了支持,并支持密集型应用程序中的大型图形。 功能亮点 为读取和写入而优化的炽烈的快速图形数据结构 全面的API...
  • 精品文档可编辑 值得下载 建立Java应用程序框架降低Java信息系统开发难度 摘 要 Java语言是面向对象程序设计应用最广泛的语言之一Java的三层结构程序作为...关键词 降低难度Java程序Java应用程序框架 中图分类号TP311.
  • 爬虫遍历中图分类法

    千次阅读 2012-11-12 21:47:12
    很多图书馆网站都有较为完整的网页版本《中图分类法》,不同的分类目录都位于不同的链接网页上 为此专门写了一个遍历该种网站的Java程序,我们以“中国图书馆分类法网站”为例 数据库创建表脚本: CREATE TABLE...
  • 中图分类号

    千次阅读 2010-06-07 22:34:00
    中图分类号 TP 自动化技术、计算机技术(下分六类)   1 自动化基础理论 2 自动化技术及设备 3 计算技术、计算机技术 6 射流技术(流控技术) 7 遥感技术 8 远动技术...
  • China New Technologies and Products 中国新技术新产品 ...然而,要充分利用网络计算模式的功能与效益,平台的运行环境是个制约因素,而 Java语言和 Java 技术则是解决这一问题的最佳途径。 2.Java语言的主要特
  • JAVA GC解析

    2020-01-13 11:08:52
    java中内存使用时要不断的清理,以避免内存溢出,内存垃圾的清理我就叫做java的GC,即指 垃圾收集并清理内存。说到java虚拟机不得不先说一下java虚拟机的分区,来指出GC时会涉及到那些分区。 java虚拟机分区图如下...
  • 4.3 Matplotlib 图中图

    2021-04-21 13:07:39
    Matplotlib常见用法全部OneNote笔记 全部笔记思维导图整理 PyTorch常见用法全部OneNote笔记 全部笔记思维导图整理 Scikit-Learn常见用法全部OneNote笔记 全部笔记思维导图整理 Java相关技术/ssm框架全部笔记 ...
  • Java调用Tuxedo方法

    千次阅读 2017-04-20 16:44:53
    原文章地址 摘要:在以Tuxedo为中间件的企业信息系统中,为满足分布式系统的应用,需要解决在Java程序中调用Tuxedo服务的难题,给出了一种免费的、用Visual C++2、Visual ... 中图分类号:TP311文献标识码:A
  • UML中图的分类

    千次阅读 热门讨论 2020-01-18 11:54:19
    3.2多重继承:一个子类集成多个父类,JAVA中不可实现,可用接口实现; 4.实现:虚线空心箭头表示,尾部实现头部,一般用于类实现接口 (二)包图 (三)对象图 对象图一般描述了一个系统某个时刻某...
  • 使用Java编写Oracle触发器的实现全立新【期刊名称】《计算机与现代化》【年(卷),期】2004(000)010【摘要】数据库触发器是响应插入、更新和删除等数据库事件而执行的过程.本文详细叙述了Oracle触发器的功能及应用场合...
  • 第十章 Java综合项目实训 10.1多功能计算器重点 10.2 简单记事本重点 10.3 音乐播放器重点 10.4 简单图形界面聊天工具重点 10.1 多功能计算器 10.1.1程序的功能及界面 要求能够实现一个计算器的功能可以进行整数及...
  • Android 中图能够用到的图片处理类 BitmapUtils Android在实际开发中非常多时候都要对图片进行一定的处理,这里总结的BitmapUtils 类包含一下几个功能: 1.Android图片倒影, 2.Android图片模糊...
  • 记忆模型 基于内存的图形数据结构实现。
  • Java构造方法的特点如下: 构造方法名必须与类名相同。 构造方法没有任何返回值,包括void。 构造方法只能与new运算符结合使用。 示例代码如下: 1 //Rectangle.java文件 2 package ...
  • neo4j中图的存储结构

    千次阅读 2018-05-28 17:21:06
    如果需要指定得到某个结点的入度或出度,需要遍历所有关系通过判断边上的起点终点是否和中心结点相等来判断方向: 代码如下(org\neo4j\kernel\impl\api\store\StoreNodeRelationshipCursor.java): public boolean...
  • Java智能卡的安全性 摘要Java智能卡的应用已日益广泛由于其中涉及到了身份认证移动通信和电子支付等...关键词Java智能卡事务处理防火墙 中图分类号TP393文献标识码A文章编号1009-3044(2011)24-6015-02 The Security o
  • 首先,来看下java.util包中Map相关的集合类的类图(见附件中图1)。接口Map是整个类图的跟,Map往下又提供了两个接口:ConcurrentMap和SortedMap。ConcurrentMap是java5中新增的线程安全的Map接口;而SortedMa
  • Java 组件的视图绘制机制 摘要本文详细分析了 Java 中两大类型的组件的各自 特性以及由此...关键词 Java组件视图绘制重量组件轻量组件 中图分类号 TP3 文献标识码 A 文章编号 1007-9599 (2011) 18-0000-02 View Rend
  • 1181000701软件构造week3

    2020-03-22 16:35:55
    java中图表示方法(邻接矩阵,邻接表) 最短路径球法
  • 首先,来看下java.util包中Map相关的集合类的类图(见附件中图1)。接口Map是整个类图的跟,Map往下又提供了两个接口:ConcurrentMap和SortedMap。ConcurrentMap是java5中新增的线程安全的Map接口;而SortedMap则...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,553
精华内容 621
关键字:

java中图

java 订阅