Java数据结构54:图的深度优先遍历与广度优先遍历数据结构课程设计

简介: 给出一个无向图顶点和边的信息,输出这个无向图的深度优先遍历序列和广度优先遍历序列。从一个顶点出发如果有2个以上的顶点可以访问时,我们约定先访问编号大的那个顶点。示例输入对应的图如下图所示:

54:图的深度优先遍历与广度优先遍历

时间限制: 20000ms 内存限制: 131072kB


描述


给出一个无向图顶点和边的信息,输出这个无向图的深度优先遍历序列和广度优先遍历序列。从一个顶点出发如果有2个以上的顶点可以访问时,我们约定先访问编号大的那个顶点。示例输入对应的图如下图所示:

aHR0cDovL21lZGlhLm9wZW5qdWRnZS5jbi9pbWFnZXMvdXBsb2FkLzE0MzM3NzE0NjAuSlBH.png


输入

输入的第1行有2个整数m和n。表示图g有m个顶点和n条边。

第2行是m个以空格隔开的字符串,依次是图中第1个顶点的名字,第2个顶点的名字.....第m个顶点的名字。

此后还有n行,每行由2个字符串构成,分别是构成图中1条边的两个顶点。我们约定不会有重边。

输出

输出有2行。

第1行是从第1个顶点出发对图g做深度优先遍历得到的顶点序列。

第2行是从第1个顶点出发对图g做广度优先遍历得到的顶点序列。

样例输入


8 9
v1 v2 v3 v4 v5 v6 v7 v8
v1 v2
v1 v3
v1 v6
v2 v3
v2 v4
v3 v4
v4 v6
v5 v6
v7 v8


样例输出


v1 v6 v5 v4 v3 v2 v7 v8
v1 v6 v3 v2 v5 v4 v7 v8


提示

注意:从一个顶点出发如果有2个以上的顶点可以访问时,我们约定先访问编号大的那个顶点。

 

首先声明,上课没听讲,代码瞎搞的,纯属做着玩,写得质量不好,但是能通过OpenJudge的测试,管他三七二一,反正我过了就行了,好的,废话不多说,直接上代码,拿去就能运行。

import java.util.*;
/**
 * @author baikunlong
 * @date 2020/6/23 10:55
 */
public class Main {
    private static ArrayList<Graph> list = new ArrayList<>();
    private static ArrayList<Graph> visited;
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        scanner.nextLine();
        String[] names = scanner.nextLine().split(" ");
        for (int i = 0; i < names.length; i++) {
            list.add(new Graph(Integer.parseInt(names[i].substring(1))));
        }
        for (int i = 0; i < m; i++) {
            String[] strings = scanner.nextLine().split(" ");
            Graph graph = list.get(Integer.parseInt(strings[0].substring(1)) - 1);
            graph.list.add(list.get(Integer.parseInt(strings[1].substring(1)) - 1));
            graph = list.get(Integer.parseInt(strings[1].substring(1)) - 1);
            graph.list.add(list.get(Integer.parseInt(strings[0].substring(1)) - 1));
        }
        //开始深度遍历
        visited = new ArrayList<>();
        Graph cGraph = list.get(0);
        visited.add(cGraph);
        DFS(cGraph);
        for (int i = 0; i < visited.size(); i++) {
            System.out.print("v" + visited.get(i).gravity + " ");
        }
        System.out.println();
        //开始广度遍历
        visited = new ArrayList<>();
        //恢复访问状态
        for (int i = 0; i < list.size(); i++) {
            list.get(i).visited = false;
            list.get(i).preGraph = null;
        }
        cGraph = list.get(0);
        visited.add(cGraph);
        ArrayList<Graph> cGraphs = new ArrayList<>();
        cGraphs.add(cGraph);
        BFS(cGraphs);
        for (int i = 0; i < visited.size(); i++) {
            System.out.print("v" + visited.get(i).gravity + " ");
        }
    }
    /**
     * 广度优先遍历
     * @param cGraphs 当前点的连接点集合
     */
    private static void BFS(ArrayList<Graph> cGraphs) {
//        System.out.println("set " + cGraphs);
        //是否还存在没访问的点
        boolean isEmpty = true;
        ArrayList<Graph> nextGraphs = new ArrayList<>();
        //遍历每个连接点
        for (int i = 0; i < cGraphs.size(); i++) {
            Graph cGraph = cGraphs.get(i);
            ArrayList<Graph> cList = cGraph.list;
            if (cList.size() != 0) {
                cList.sort(Comparator.comparingInt(o -> (o.gravity)));
                Collections.reverse(cList);
                //把连接点的所有子连接点给访问了,还是遵循从大大小,上面已排序
                for (int k = 0; k < cList.size(); k++) {
                    Graph graph = cList.get(k);
                    graph.preGraph = cGraph;
                    graph.visited = true;
                    if (!visited.contains(graph)){
                        visited.add(graph);
                        isEmpty = false;
                    }
                    //保存为下一层的连接点
                    nextGraphs.add(graph);
                }
            }
        }
        //如果所有连接点都访问了
        if (isEmpty) {
            //遍历剩下的其他的未连接的点
            for (int i = 0; i < list.size(); i++) {
                if (!list.get(i).visited) {
                    visited.add(list.get(i));
                    cGraphs = new ArrayList<>();
                    cGraphs.add(list.get(i));
                    BFS(cGraphs);
                }
            }
        }else {
            //访问下一层
            BFS(nextGraphs);
        }
    }
    /**
     * 深度优先遍历
     * @param cGraph 当前点
     */
    private static void DFS(Graph cGraph) {
//        System.out.println("set v" + cGraph.gravity);
        //设置被访问
        cGraph.visited = true;
        //如果被访问集合不包含则添加该点
        if (!visited.contains(cGraph))
            visited.add(cGraph);
        ArrayList<Graph> cList = cGraph.list;
        if (cList.size() == 0) {
            //如果该点的连接点为空,代表已到最深处,则回到上一个点
            DFS(cGraph.preGraph);
            return;
        }
        //根据权重排序,优先访问大的点
        cList.sort(Comparator.comparingInt(o -> (o.gravity)));
        Collections.reverse(cList);
//        System.out.println(cList);
        //访问每一个连接点
        for (int i = 0; i < cList.size(); i++) {
            if (!cList.get(i).visited) {
                cList.get(i).preGraph = cGraph;
                cGraph = cList.get(i);
                //递归访问下去,知道没有连接点为止
                DFS(cGraph);
                return;
            }
        }
        //如果没有回到起点则继续遍历
        if (cGraph.preGraph != null) {
            DFS(cGraph.preGraph);
        } else {
            //遍历剩下的未连接的点
            for (int i = 0; i < list.size(); i++) {
                if (!list.get(i).visited) {
                    DFS(list.get(i));
                }
            }
        }
    }
    static class Graph {
        //权重
        int gravity;
        //连接点
        ArrayList<Graph> list = new ArrayList<>();
        //是否访问
        boolean visited;
        //上一个点
        Graph preGraph;
        public Graph(int gravity) {
            this.gravity = gravity;
        }
        @Override
        public String toString() {
            return "Graph{" +
                    "gravity=" + gravity +
                    '}';
        }
    }
}


目录
相关文章
|
1月前
|
Java
【Java集合类面试二十六】、介绍一下ArrayList的数据结构?
ArrayList是基于可动态扩展的数组实现的,支持快速随机访问,但在插入和删除操作时可能需要数组复制而性能较差。
|
1月前
|
存储 设计模式 算法
JAVA中的常见数据结构
JAVA中的常见数据结构
|
1天前
|
Java
java数据结构,双向链表的实现
文章介绍了双向链表的实现,包括数据结构定义、插入和删除操作的代码实现,以及双向链表的其他操作方法,并提供了完整的Java代码实现。
java数据结构,双向链表的实现
|
1天前
|
存储 Java
java数据结构,线性表链式存储(单链表)的实现
文章讲解了单链表的基本概念和Java实现,包括头指针、尾节点和节点结构。提供了实现代码,包括数据结构、接口定义和具体实现类。通过测试代码演示了单链表的基本操作,如添加、删除、更新和查找元素,并总结了操作的时间复杂度。
java数据结构,线性表链式存储(单链表)的实现
|
1天前
|
存储 Java
java数据结构,线性表顺序存储(数组)的实现
文章介绍了Java中线性表顺序存储(数组)的实现。线性表是数据结构的一种,它使用数组来实现。文章详细描述了线性表的基本操作,如增加、查找、删除、修改元素,以及其他操作如遍历、清空、求长度等。同时,提供了完整的Java代码实现,包括MyList接口和MyLinearList实现类。通过main函数的测试代码,展示了如何使用这些方法操作线性表。
|
1月前
|
存储 Java
数据结构中的哈希表(java实现)利用哈希表实现学生信息的存储
这篇文章通过Java代码示例展示了如何实现哈希表,包括定义结点类、链表类、数组存储多条链表,并使用简单的散列函数处理冲突,以及如何利用哈希表存储和查询学生信息。
数据结构中的哈希表(java实现)利用哈希表实现学生信息的存储
|
1月前
|
存储 算法 Java
"解锁Java对象数据结构的奥秘:从基础到实战,与热点技术共舞,让你的编程之路更激情四溢!"
【8月更文挑战第21天】Java以对象为核心,它是程序的基本单元与数据处理的基础。对象源自类,拥有属性(字段)和方法。对象在内存中分为对象头(含哈希码、GC信息等)和实例数据区(存储属性值)。例如,`Student`类定义了姓名、年龄等属性及相应的方法。通过`new`关键字实例化对象并调用其方法进行数据操作,是Java编程的关键技能。
28 0
|
2月前
|
算法 Python
逆袭之路!用 Python 玩转图的 DFS 与 BFS,让数据结构难题无处遁形
【7月更文挑战第12天】图的遍历利器:DFS 和 BFS。Python 中,图可表示为邻接表或矩阵。DFS 沿路径深入,回溯时遍历所有可达顶点,适合找路径和环。BFS 层次遍历,先近后远,解决最短路径问题。两者在迷宫、网络路由等场景各显神通。通过练习,掌握这些算法,图处理将游刃有余。
50 3
|
2月前
|
存储 算法 Python
“解锁Python高级数据结构新姿势:图的表示与遍历,让你的算法思维跃升新高度
【7月更文挑战第13天】Python中的图数据结构用于表示复杂关系,通过节点和边连接。常见的表示方法是邻接矩阵(适合稠密图)和邻接表(适合稀疏图)。图遍历包括DFS(深度优先搜索)和BFS(广度优先搜索):DFS深入探索分支,BFS逐层访问邻居。掌握这些技巧对优化算法和解决实际问题至关重要。**
27 1
|
2月前
|
缓存 算法 安全
Java中的数据结构与算法优化策略
Java中的数据结构与算法优化策略