java实现 基于邻接链表的BFS 和 （递归/非递归） DFS

最新推荐文章于 2024-08-17 08:59:42 发布
最新推荐文章于 2024-08-17 08:59:42 发布
阅读量805 收藏 5
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiedelong/article/details/80197276
版权 
package 算法;

import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Set;
import java.util.Stack;

public class First_Search {

    static int len_v=20;   //点的个数
    static int len_e=30;   //边的个数
    private static boolean visited[]=new boolean[len_v];  //BFS中被访问的点
    private static boolean visited2[]=new boolean[len_v];  //DFS中被访问的点
    static Vertex ver[]=new Vertex[len_v];  //存放点
    static int distance[]=new int[len_v];  //存放BFS距离
    static int num[]=new int[len_v];
    static int len[]=new int[len_v];
    static Queue<Vertex> q=new LinkedList<Vertex>();  //广度优先搜索中存放点的队列
    static Stack<Vertex> s=new Stack<Vertex>();  //非递归DFS的栈

    static class Vertex
    {
        int n;//邻接链表的点
        List<Integer> list=new LinkedList<Integer>();

        //点的构造方法
        public Vertex(int n)
        {
            this.n=n;
        }
        //向该点的链表中增加点
        public void add(int value)
        {
            list.add(value);
        }
    }

    static class Edge
    {
        int u;//该点
        int v;//下一个点

        //构造方法
        public Edge(int u,int v)
        {
            this.u=u;
            this.v=v;
        }

        @Override
        //重写hashcode方法
        public int hashCode() {
            return v;
        }

        @Override
        //重写equals方法
        public boolean equals(Object obj) {
            if(!(obj instanceof Edge)){
                return false;
            }
            if(obj == this){
                return true;
            }
            return this.v==((Edge)obj).v&&this.u==((Edge)obj).u;
        }

    }

    //csh即初始化
    public static void csh()
    {
        //构建100个点
        for(int i=0;i<len_v;i++)
        {
            ver[i]=create(i+1);
            //ver[i].list.add(i+1);
            visited[i]=false;
            visited2[i]=false;
        }

        //构建500条边
        Edge e;
        Set<Edge> s=new HashSet<Edge>();//存储所有的边

        while(s.size()<len_e)
        {
            int u=random();
            int v=random();

            while(u==v||s.contains(new Edge(u,v)))
                v=random();

            e=new Edge(u,v);

            if(!s.contains(e))
                s.add(e);
        }

        //将500条边加到对应的起始点的链表中
        Iterator<Edge> it=s.iterator();

        while(it.hasNext())
        {
            Edge ee=(Edge) it.next();
            ver[ee.u-1].list.add(ee.v);
            //System.out.println(ee.u+" * "+ee.v);
        }

    }

    //重新初始化BFS和DFS标注点
    public static void csh1()
    {
        for(int i=0;i<len_v;i++)
        {
            visited[i]=false;
            visited2[i]=false;
        }
    }

    public static void print(Vertex ver[])
    {
        System.out.println("打印所有点的邻接链表：");
        //打印所有的邻接链表
        for(int i=0;i<len_v;i++)
        {
            int len=ver[i].list.size();
            System.out.print(ver[i].n+"-->");

            for(int j=0;j<len;j++)
                System.out.print(ver[i].list.get(j)+"-->");

            System.out.println("");
        }
    }


    public static int random()
    {
        //生成随机数1-100
        int i=(int) (Math.random()*len_v+1);
        return i;
    }

    //构造100个点的邻接链表
    public static Vertex create(int n)
    {
        return new Vertex(n);
    }

    public static void BFS(Vertex v)
    {
        visited[v.n-1]=true;  //将参数对应的点标记为已读
        q.add(v);  //队列中增加该点
        System.out.print(v.n+"-->");

        while(!q.isEmpty())
        {
            Iterator<Integer> i=q.poll().list.iterator();  //遍历队列头结点对应的邻接链表
            while(i.hasNext())
            {
                int n=i.next();  

                //将该点邻接链表中所有未读的点放入队列
                if(visited[n-1]==false)
                {
                    q.add(ver[n-1]);
                    visited[n-1]=true;
                    System.out.print(n+"-->");
                }
            }
        }
    }

    public static void BFS_distance(Vertex v)
    {
        for(int i=0;i<len_v;i++)
            distance[i]=0;

        visited[v.n-1]=true;  //将参数对应的点标记为已读
        q.add(v);  //队列中增加该点
        System.out.print(v.n+"-->");

        distance[v.n-1]=0;

        while(!q.isEmpty())
        {
            int tem=distance[q.peek().n-1];

            Iterator<Integer> i=q.poll().list.iterator();  //遍历队列头结点对应的邻接链表
            while(i.hasNext())
            {
                int n=i.next();  
                //将该点邻接链表中所有未读的点放入队列
                if(visited[n-1]==false)
                {
                    distance[n-1]=tem+1;
                    q.add(ver[n-1]);
                    visited[n-1]=true;
                    System.out.print("("+n+","+distance[n-1]+")"+"-->");
                }
            }
        }
    }

    public static void DFS(Vertex v)
    {
        visited2[v.n-1]=true;  //将参数中对应点标为已读
        System.out.print(v.n+"-->");

        //接下来的操作针对的是该点的邻接链表中的点（除自身）
        int i=0;
        while(i<v.list.size())
        {
            //System.out.println(v.n+" * ");
            Vertex tem=ver[(int)v.list.get(i)-1]; //定义为该点的下一个点
            //System.out.println(tem.n+" * ");

            //当tem点未读，则对该点递归进行深度优先搜索
            if(visited2[tem.n-1]==false)
                DFS(tem);
            i++;
        }
    }

    //非递归DFS
    public static void DFS2(Vertex v)
    {
        visited2[v.n-1]=true;  //将参数中对应点标为已读
        s.add(v);  //将初始点加入栈中

        System.out.print(v.n+"-->");  //打印该点

        while(!s.empty())
        {
            int i=0;  //现在搜寻点邻接链表中的第一个邻接点
            while(i<v.list.size())
            {
                Vertex tem=ver[(int)v.list.get(i)-1]; //定义为该点的下一个点

                if(visited2[tem.n-1]==false)
                {
                    s.add(tem);  //将该点邻接表中第一个（未读）邻接点放入栈中
                    System.out.print(tem.n+"-->");
                    i=0;
                    visited2[tem.n-1]=true; //把刚才放入的点标记为已读
                }
                else
                    i++;  //若第i个点已读，继续寻找未读邻接点

                v=s.peek();  // v=刚才放入的那个点（即继续向下一层进行while寻找）
            }

            s.pop();  //这一条深度搜寻链已到底，将最底下的那个点从栈中删除

            if(!s.empty())
               v=s.peek();  //回溯到上一个点
        }

    }

        //非递归DFS求最大长度路径         (max为边的长度，也就是最长路径中点的个数为max+1)
        public static void topolongiest(Vertex v,Stack<Integer> s)
        {
            int max=0;
            Stack<Integer> ss=new Stack<Integer>();   //存放节点

            int length=s.size();
            for(int i=0;i<len_v;i++)
            {
                len[i]=0;  //初始化所有点的最大长度为0
            }

            for(int j=0;j<length;j++)
            {
                Vertex ve=ver[s.get(j)-1];  //当前节点
                int n=ve.n;  //当前节点的值
                int l=ve.list.size();  //当前节点邻接链表的长度

                int t=0;  //存放动态规划最大长度点

                //如果该点的邻接链表中有除了自己以外的点，即该点非叶子结点
                if(l>0)
                {
                    if(l==1)
                    {
                        len[n-1]=len[(int) ve.list.get(0)-1]+1;  //如果l=1（除自己外只有一个邻接点） 即无分支 直接加一
                        //System.out.println((int) ve.list.get(1));
                        ss.add((int) ve.list.get(0));
                        if(len[n-1]>=max)
                        {
                            max=len[n-1];
                            //System.out.println(n+"*"+max);
                        }
                    }
                    else
                    {
                        //若有分支，则动态规划找出路径最长的分支

                        int temp_max=len[(int) ve.list.get(0)-1];  //初始最大值为第一个点

                        //动态规划法，找出该点邻接链表中各点的最大路径长度temp_max 和具有最大长度的点的值t
                        for(int k=1;k<=l-1;k++)
                        {
                            if(len[(int) ve.list.get(k)-1]>temp_max)
                            {
                                temp_max=len[(int) ve.list.get(k)-1];
                                //System.out.println((int) ve.list.get(k));
                                t=(int) ve.list.get(k);
                            }
                        }
                        //System.out.println(t);
                        ss.add(t);  //把该点放入栈中，最终输出该栈即为最长路径

                        len[n-1]=temp_max+1;  //加上自己，+1

                        //最大长度
                        if(len[n-1]>=max)
                        {
                            max=len[n-1];
                            //System.out.println(n+"*"+max);
                        }
                    }
                }
            }       

            System.out.println("");
            System.out.println(max+"*");  //输出最终的最大长度

        }       

        public static void main(String args[])
        {
            csh();  //初始化
            print(ver);  //打印邻接链表

            System.out.println("");     
            System.out.println("BFS:");
            BFS(ver[0]);  //广度优先搜索

            csh1(); 
            System.out.println("");     
            System.out.println("BFS距离:");
            BFS_distance(ver[0]); 


            System.out.println("");
            csh1();     
            System.out.println("非递归DFS:");      
            DFS2(ver[0]);  //非递归深度优先搜索

            System.out.println("");
            csh1();     
            System.out.println("递归DFS:");
            DFS(ver[0]);  //递归深度优先搜索

        }   
}
xiedelong
关注
专栏目录
java建邻接链表
风雨落
09-14 893
建邻接链表分三部分： 要有一个总类Graph来存储所有的头节点//邻接表实现图的建立 public class Graph { public MyList<VertexNode> adjList; // 保存邻接表的头节点 public MyList<Boolean> visit; public Graph( ) { adjList = new MyList<Vert
用java写出一个邻接表的结构
weixin_35756892的博客
01-19 295
邻接表是一种图存储结构，可以用来存储稀疏图。在 Java 中，可以使用哈希表和链表来实现邻接表。下面是一个示例代码： import java.util.HashMap; import java.util.LinkedList; public class AdjacencyList { private HashMap<Integer, LinkedList<Integer&gt...
Java---邻接表（链表实现）
Tizzi的博客
07-26 1506
static int head[] = new int[1005]; // 存放链头 static edge[] e = new edge[1005]; static int len; // 边的个数 //添加有向边 static void add(int u, int v, int w) { //添加 u指向v 这条边，权值为w e[len] = new edge(v, w, he...
Java“链表“——数据结构（这一篇就够了）
最新发布
m0_73158088的博客
08-17 1118
本篇对数据结构中的"链表"进行详细的讲解 本期会分成一下五部分进行讲解： 1.链表的概念 2.链表的种类 3.链表的实现方法 4.代码实现链表 5.链表的常见使用场景
Java实现邻接表的DFS和BFS
li1376417539的博客
11-29 1269
顶点类 public class Vertex { String verName; boolean visited; Vertex nextVertex; } 图类 public class Graph extends Constent { Vertex[] verList = new Vertex[MAX_VERTEX]; int VerNum; int EdgeNum; } 常...
java 图的邻接表_JAVA实现图的邻接表以及DFS
weixin_39664431的博客
02-12 210
一：定义邻接表结构储存图package 图的遍历;//邻接表实现图的建立//储存边class EdgeNode {int index; // 习惯了用index，其实标准写法是(adjVertex)int value; // 权值EdgeNode nextArc; // 指向下一条弧}// 邻接表节点的类型class VertexNode {String name;EdgeNode firstAr...
java实现哈密顿路径，递归和非递归两种方式
04-13
在Java代码中，可能会包含一个图的表示（如邻接矩阵或邻接表），以及相应的递归和非递归算法实现。这些实现可能包括以下关键部分： 1. 图的初始化：创建一个图结构，用数组或链表存储顶点及其邻接关系。 2. 递归...
邻接矩阵非递归深度遍历和邻接链表非递归层次遍历
11-13
以下是邻接矩阵非递归深度遍历和邻接链表非递归层次遍历的Python实现： 邻接矩阵非递归深度遍历： ```python def DFS_iterative(graph, start): visited = set() # 用集合存储已访问的节点 stack = [start] # 用...
图的BFS与DFS算法在邻接矩阵与邻接表存储结构下实现
weixin_46127065的博客
10-19 3287
如题 自用笔记 如有错误欢迎及时指正
数据结构之图的DFS和BFS递归与非递归遍历
HPU_LY的博客
11-04 2992
一、邻接矩阵的DFS递归遍历 /* Author: luuuuyang Date: 2018/11/1 Version 1.0 Functions:创建无向网络邻接矩阵即带权无向图+递归DFS遍历 */ #include&lt;iostream&gt; #include&lt;cstring&gt; using namespace std; #define MaxInt 32767//表示无...
Graph1_非递归算法进行深度优先遍历和广度优先遍历_
10-02
本话题主要探讨如何使用非递归算法对无向图进行深度优先遍历（DFS, Depth First Search）和广度优先遍历（BFS, Breadth First Search），这两种遍历方法在图算法中有着广泛的应用。 **1. 邻接表表示法** 在处理大...
JAVA下基于邻接表的图的通用算法实现
04-15
(1) 基于邻接表的图的构建功能 (2) 标准Dijkstra算法 (3) 有向图的强连通算法 Environment: Eclipse 3.4 + JDK 1.6 注：目前只实现了以上三个功能，但由于各功能都基于模块化分解的思想实现，所以加入新功能会比较方便，易于扩展。
邻接链表与图及其相关操作--Java
Aguangg_6655_la的博客
04-18 1397
找了好久的关于图的邻接链表存储结构，这个是最满意的。一来方便自己以后查找使用，二来分享给大家。package Graph; import java.util.ArrayList; import java.util.List; /** * 邻接表实现的图 * @author ctk * */ public class ListGraph { private List gNodes
DFS和BFS的递归及非递归实现
半杯的博客
05-06 1388
DFS和BFS的递归及非递归实现 一 DFS 1 递归实现  定义一个搜索的函数，对附近八个方向的点进行搜索,如果这些点可以满足条件，那么对这些点进行继续搜索。 void DFS(int x,int y) { if(x<1||x>m||y<1||y>n) return; // 如果超过范围，直接返回 if(filed[x][y]) filed[x][y] = 0; // 如果那点有石油那么继续搜索 else return; for (
邻接表（Java）
贱贱的梦想
03-11 3912
无向图的邻接表结构如下所示： 无向图的邻接表的代码实现： /* * 邻接表无向图（已提供参数） * 输入说明：vexs -- 顶点数组 * edges -- 边数组 * 输出说明：邻接表（即每个顶点所连接的点） */ package test; public class ListUDG { int vlen; // 顶点个数 int elen
Java中的链表
weixin_52758364的博客
12-09 3561
以实践为线索，逐步深入数据结构和算法，提升编程能力和思维能力。
JAVA实践图的存储结构---邻接表（利用链表）
薛定谔的猫窝
07-29 893
前言关于邻接表，实现过一次数组版本的。 http://blog.csdn.net/xubaifu1997/article/details/51984760虽然会写了，也感觉略绕，所以尝试用了自带的链表对象粗暴的实现了。参考图来自：http://www.cnblogs.com/skywang12345/p/3707612.html 如上图，有7个顶点。我的实现思路非常粗暴，让每个顶点拥有一个链表。
邻接表存储图Java实现
热门推荐
liangxiamoyi的博客
08-08 1万+
使用Java实现邻接表存储的图及其操作，深度优先遍历和广度优先遍历，拓扑排序，关键路径和最短路径问题。
Java语言----LinkedList 和 链表的实现
tq02的博客
05-04 2065
java语言实现链表，以及LinkedList的讲解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值