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月前
|
存储 算法
数据结构与算法学习二二:图的学习、图的概念、图的深度和广度优先遍历
这篇文章详细介绍了图的概念、表示方式以及深度优先遍历和广度优先遍历的算法实现。
52 1
数据结构与算法学习二二:图的学习、图的概念、图的深度和广度优先遍历
|
24天前
|
存储 Java
Java中的HashMap和TreeMap,通过具体示例展示了它们在处理复杂数据结构问题时的应用。
【10月更文挑战第19天】本文详细介绍了Java中的HashMap和TreeMap,通过具体示例展示了它们在处理复杂数据结构问题时的应用。HashMap以其高效的插入、查找和删除操作著称,而TreeMap则擅长于保持元素的自然排序或自定义排序,两者各具优势,适用于不同的开发场景。
41 1
|
26天前
|
存储 Java
告别混乱!用Java Map优雅管理你的数据结构
【10月更文挑战第17天】在软件开发中,随着项目复杂度增加,数据结构的组织和管理至关重要。Java中的Map接口提供了一种优雅的解决方案,帮助我们高效、清晰地管理数据。本文通过在线购物平台的案例,展示了Map在商品管理、用户管理和订单管理中的具体应用,有效提升了代码质量和维护性。
80 2
|
26天前
|
存储 Java 开发者
Java Map实战:用HashMap和TreeMap轻松解决复杂数据结构问题!
【10月更文挑战第17天】本文深入探讨了Java中HashMap和TreeMap两种Map类型的特性和应用场景。HashMap基于哈希表实现,支持高效的数据操作且允许键值为null;TreeMap基于红黑树实现,支持自然排序或自定义排序,确保元素有序。文章通过具体示例展示了两者的实战应用,帮助开发者根据实际需求选择合适的数据结构,提高开发效率。
57 2
|
9天前
|
缓存 算法 Java
本文聚焦于Java内存管理与调优,介绍Java内存模型、内存泄漏检测与预防、高效字符串拼接、数据结构优化及垃圾回收机制
在现代软件开发中,性能优化至关重要。本文聚焦于Java内存管理与调优,介绍Java内存模型、内存泄漏检测与预防、高效字符串拼接、数据结构优化及垃圾回收机制。通过调整垃圾回收器参数、优化堆大小与布局、使用对象池和缓存技术,开发者可显著提升应用性能和稳定性。
30 6
|
15天前
|
存储 Java 索引
Java中的数据结构:ArrayList和LinkedList的比较
【10月更文挑战第28天】在Java编程世界中,数据结构是构建复杂程序的基石。本文将深入探讨两种常用的数据结构:ArrayList和LinkedList,通过直观的比喻和实例分析,揭示它们各自的优势与局限,帮助你在面对不同的编程挑战时做出明智的选择。
|
23天前
|
存储 算法 Java
Java 中常用的数据结构
【10月更文挑战第20天】这些数据结构在 Java 编程中都有着广泛的应用,掌握它们的特点和用法对于提高编程能力和解决实际问题非常重要。
24 6
|
24天前
|
存储 Java 开发者
Java中的Map接口提供了一种优雅的方式来管理数据结构,使代码更加清晰、高效
【10月更文挑战第19天】在软件开发中,随着项目复杂度的增加,数据结构的组织和管理变得至关重要。Java中的Map接口提供了一种优雅的方式来管理数据结构,使代码更加清晰、高效。本文通过在线购物平台的案例,展示了Map在商品管理、用户管理和订单管理中的具体应用,帮助开发者告别混乱,提升代码质量。
26 1
|
1月前
|
存储 算法 Java
Java常用的数据结构
【10月更文挑战第3天】 在 Java 中,常用的数据结构包括数组、链表、栈、队列、树、图、哈希表和集合。每种数据结构都有其特点和适用场景,如数组适用于快速访问,链表适合频繁插入和删除,栈用于实现后进先出,队列用于先进先出,树和图用于复杂关系的表示和查找,哈希表提供高效的查找性能,集合用于存储不重复的元素。合理选择和组合使用这些数据结构,可以显著提升程序的性能和效率。
|
1月前
|
存储 Java
数据结构第二篇【关于java线性表(顺序表)的基本操作】
数据结构第二篇【关于java线性表(顺序表)的基本操作】
30 6

热门文章

最新文章