Java實現圖的遍歷（深搜與廣搜）

本文以鄰接矩陣作爲存儲結構，用Java實現圖的遍歷，話不多說，先給出的圖的結構，如下：

1、深度優先搜索遍歷
思想：
沿着樹的深度遍歷樹的節點，儘可能深的搜索樹的分支。當節點v的所有邊都己被探尋過，搜索將回溯到發現節點v的那條邊的起始節點。這一過程一直進行到已發現從源節點可達的所有節點爲止。如果還存在未被發現的節點，則選擇其中一個作爲源節點並重復以上過程，整個進程反覆進行直到所有節點都被訪問爲止。（百度百科）

代碼如下：

package com.ds.graph;

public class DFSTraverse {
    // 構造圖的邊
    private int[][] edges = { { 0, 1, 0, 0, 0, 1, 0, 0, 0 },
            { 1, 0, 1, 0, 0, 0, 1, 0, 1 }, { 0, 1, 0, 1, 0, 0, 0, 0, 1 },
            { 0, 0, 1, 0, 1, 0, 1, 1, 1 }, { 0, 0, 0, 1, 0, 1, 0, 1, 0 },
            { 1, 0, 0, 0, 1, 0, 1, 0, 0 }, { 0, 1, 0, 1, 0, 1, 0, 1, 0 },
            { 0, 0, 0, 1, 1, 0, 1, 0, 0 }, { 0, 1, 1, 1, 0, 0, 0, 0, 0 } };
    // 構造圖的頂點
    private String[] vertexs = { "A", "B", "C", "D", "E", "F", "G", "H", "I" };
    // 記錄被訪問頂點
    private boolean[] verStatus;
    // 頂點個數
    private int vertexsNum = vertexs.length;

    public void DFSTra() {
        verStatus = new boolean[vertexsNum];
        for (int i = 0; i < vertexsNum; i++) {
            if (verStatus[i] == false) {
                DFS(i);
            }
        }
    }

    // 遞歸深搜
    private void DFS(int i) {
        System.out.print(vertexs[i] + " ");
        verStatus[i] = true;
        for (int j = firstAdjVex(i); j >= 0; j = nextAdjvex(i, j)) {
            if (!verStatus[j]) {
                DFS(j);
            }
        }
    }

    // 返回與i相連的第一個頂點
    private int firstAdjVex(int i) {
        for (int j = 0; j < vertexsNum; j++) {
            if (edges[i][j] > 0) {
                return j;
            }
        }
        return -1;
    }

    // 返回與i相連的下一個頂點
    private int nextAdjvex(int i, int k) {
        for (int j = (k + 1); j < vertexsNum; j++) {
            if (edges[i][j] == 1) {
                return j;
            }
        }
        return -1;
    }

    // 測試
    public static void main(String[] args) {
        new DFSTraverse().DFSTra();
    }

}

2、廣度優先搜索遍歷
思想：
從根節點開始，沿着樹的寬度、按照層次依次遍歷樹的節點；

代碼如下：

package com.ds.graph;

import java.util.LinkedList;
import java.util.Queue;

public class BFSTraverse_0100 {
    // 構造圖的邊
    private int[][] edges = { { 0, 1, 0, 0, 0, 1, 0, 0, 0 },
            { 1, 0, 1, 0, 0, 0, 1, 0, 1 }, { 0, 1, 0, 1, 0, 0, 0, 0, 1 },
            { 0, 0, 1, 0, 1, 0, 1, 1, 1 }, { 0, 0, 0, 1, 0, 1, 0, 1, 0 },
            { 1, 0, 0, 0, 1, 0, 1, 0, 0 }, { 0, 1, 0, 1, 0, 1, 0, 1, 0 },
            { 0, 0, 0, 1, 1, 0, 1, 0, 0 }, { 0, 1, 1, 1, 0, 0, 0, 0, 0 } };
    // 構造圖的頂點
    private String[] vertexs = { "A", "B", "C", "D", "E", "F", "G", "H", "I" };
    // 記錄被訪問頂點
    private boolean[] verStatus;
    // 頂點個數
    private int vertexsNum = vertexs.length;

    // 廣搜
    private void BFS() {
        verStatus = new boolean[vertexsNum];
        Queue<Integer> temp = new LinkedList<Integer>();
        for (int i = 0; i < vertexsNum; i++) {
            if (!verStatus[i]) {
                System.out.print(vertexs[i] + " ");
                verStatus[i] = true;
                temp.offer(i);
                while (!temp.isEmpty()) {
                    int j = temp.poll();
                    for (int k = firstAdjvex(j); k >= 0; k = nextAdjvex(j, k)) {
                        if (!verStatus[k]) {
                            System.out.print(vertexs[k] + " ");
                            verStatus[k] = true;
                            temp.offer(k);
                        }
                    }
                }
            }
        }
    }

    // 返回與i相連的第一個頂點
    private int firstAdjvex(int i) {
        for (int j = 0; j < vertexsNum; j++) {
            if (edges[i][j] > 0) {
                return j;
            }
        }
        return -1;
    }

    // 返回與i相連的下一個頂點
    private int nextAdjvex(int i, int k) {
        for (int j = (k + 1); j < vertexsNum; j++) {
            if (edges[i][j] > 0) {
                return j;
            }
        }
        return -1;
    }

    // 測試
    public static void main(String args[]) {
        new BFSTraverse_0100().BFS();
    }
}

二：

[java]view
plain copy

import java.util.*;  

/** 

  *  這個例子是圖的遍歷的兩種方式 

  *  通過它，使我來理解圖的遍歷  

  *  Created on 2013-11-18 

  *  @version 0.1 

  */  

public class DeptSearch  

{  

    public static void main(String args[]){  

        //構造需要點對象  

        NodeT a=new NodeT("a");  

        NodeT b=new NodeT("b");  

        NodeT c=new NodeT("c");  

        NodeT d=new NodeT("d");  

        NodeT e=new NodeT("e");  

        NodeT f=new NodeT("f");  

        NodeT g=new NodeT("g");  

        NodeT h=new NodeT("h");  

        ArcT ab=new ArcT(a,b);  

        ArcT ac=new ArcT(a,c);  

        ArcT ad=new ArcT(a,d);  

        ArcT ah=new ArcT(a,h);  

        ArcT bc=new ArcT(b,c);  

        ArcT de=new ArcT(d,e);  

        ArcT ef=new ArcT(e,f);  

        ArcT eg=new ArcT(e,g);  

        ArcT hg=new ArcT(h,g);  

        //建立它們的關係  

        a.outgoing.add(ab);  

        a.outgoing.add(ac);  

        a.outgoing.add(ad);  

        a.outgoing.add(ah);  

        b.outgoing.add(bc);  

        d.outgoing.add(de);  

        e.outgoing.add(ef);  

        e.outgoing.add(eg);  

        h.outgoing.add(hg);  

        //構造本對象  

        DeptSearch search=new DeptSearch();  

        //廣度遍歷  

        System.out.println("廣度遍歷如下：");  

        search.widthSearch(a);  

        //深度遍歷  

        System.out.println("深度遍歷如下：");  

        List<NodeT> visited=new ArrayList<NodeT>();  

        search.deptFisrtSearch(a,visited);  

    }  

    /* 

     * 深度排序的方法 

     * 這個方法的方式：按一個節點，一直深入的找下去，直到它沒有節點爲止 

     * cur  當前的元素 

     * visited 訪問過的元素的集合 

     */  

    void deptFisrtSearch(NodeT cur,List<NodeT> visited){  

        //被訪問過了，就不訪問，防止死循環  

        if(visited.contains(cur)) return;  

        visited.add(cur);  

        System.out.println("這個遍歷的是："+cur.word);  

        for(int i=0;i<cur.outgoing.size();i++){  

            //訪問本點的結束點  

            deptFisrtSearch(cur.outgoing.get(i).end,visited);  

        }  

    }  

    /** 

     * 廣度排序的方法 

     * 這個方法的方式：按層次對圖進行訪問，先第一層，再第二層，依次類推 

     * @param start 從哪個開始廣度排序 

     */  

    void widthSearch(NodeT start){  

        //記錄所有訪問過的元素  

        Set<NodeT> visited=new HashSet<NodeT>();  

        //用隊列存放所有依次要訪問元素  

        Queue<NodeT> q=new LinkedList<NodeT>();  

        //把當前的元素加入到隊列尾  

        q.offer(start);  

        while(!q.isEmpty()){  

            NodeT cur=q.poll();  

            //被訪問過了，就不訪問，防止死循環  

            if(!visited.contains(cur)){  

                visited.add(cur);  

                System.out.println("查找的節點是："+cur.word);  

                for(int i=0;i<cur.outgoing.size();i++){  

                    //把它的下一層，加入到隊列中  

                    q.offer(cur.outgoing.get(i).end);  

                }  

            }  

        }  

    }  

}  

/** 

  * 圖的點 

  */  

class NodeT  

{  

    /* 點的所有關係的集合 */  

    List<ArcT> outgoing;  

    //點的字母  

    String word;  

    public NodeT(String word){  

        this.word=word;  

        outgoing=new ArrayList<ArcT>();  

    }  

}  

/** 

  * 單個圖點的關係 

  */  

class ArcT  

{  

    NodeT start,end;/* 開始點，結束點 */  

    public ArcT(NodeT start,NodeT end){  

        this.start=start;  

        this.end=end;  

    }  

}

yesIcando-bupt

發佈了164 篇原創文章 · 獲贊 26 · 訪問量 18萬+

私信關注

Java實現圖的遍歷（深搜與廣搜）

linux安裝cuda和cudnn

模擬手機設備：使用 Playwright 實現移動端自動化測試

Mellanox網卡開啓SR-IOV

全面系統的AI學習路徑，幫助普通人也能玩轉AI

uni-app實現上拉加載

vue3編譯優化之“靜態提升”

又是一個月-20240513

flask 如何保證返回json有序

linux服務器設置ssh免密

HTML 00 Tutorial

當一個線程進入一個對象的一個synchronized方法後，其它線程是否可進入此對象的其它方法? ?

泛洪填充算法(Flood Fill Algorithm)

基於SpringMVC框架使用ECharts3.0實現折線圖，柱狀圖，餅狀圖,的繪製（上篇）

ajax處理跨域有幾種方式？實現原理是什麼？

尋找最小生成樹的歐拉路徑，即一筆畫問題

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結