图的深度优先搜索和广度优先搜索

图的深度优先和广度优先

图的深度优先搜索(Depth First Search):

1. 深度优先遍历,从初始访问的结点出发,初始访问的结点可能有多个邻接点,深度优先的策略就是首先访问第一个邻接节点,然后再以这个被访问邻接节点作为初始的节点,访问他的第一个邻接结点,可以这样子理解,每次在访问完当前节点后,首先访问当前节点的第一个邻接结点
2. 我们可以看到,这样的访问策略是优先往纵向挖掘深入,而不是对一个邻接结点的所有 邻接结点进行访问,
3. 很显然,这是一个递归的过程

设计的基本思路:

1. 初始访问结点v,并结点v已经访问,
2. 查找v结点的第一个邻接结点
3. 若w存在,则继续执行4,如果w不存在,则回到第一步,将从v的下一个节点继续进行
4. 若w未被访问,对w进行深度优先的遍历递归,(即把w当做下一个w 然后开始123步骤)
5. 查找结点v的临界点的下一个节点,转到步骤3

图的广度优先(Broad First Search)

• 类似于一个分层搜索的过程,广度优先遍历需要使用一个队列以保持访问结点的顺序,以便按照这个顺序来访问这些节点的邻接结点

步骤:

1. 访问初始节点v并标记该节点已经进行了访问
2. 结点v加入队列
3. 当队列非空时,则继续执行,否则算法结束
4. 出队列,取得对头节点u
5. 查找结点u的第一个邻接节点w
6. 若节点u的邻接节点w不存在,则转到步骤三,否则循环执行以下的三个步骤
   1. 若节点w上没有被访问,则访问结点w并标记为已访问
   2. 加点w入队列
   3. 查找结点u的继w节点的下一节点w然后转到步骤6

package com.ywystu.Graph;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;

/**
 * @author 是狸猫啊！
 * @Version 1.0
 */
public class Graph {
    private ArrayList<String> vertexList;
    private int [][] edges;
    private int numOfEdges;
    private boolean[] isvisit = {false,false,false,false,false};

    public static void main(String[] args) {
        int n = 5;
        String[] VertexValue = {"A","B","C","D","E"};
        Graph graph = new Graph(n);
        for (String Vertexvalue :VertexValue) {
            graph.insertVertex(Vertexvalue);
        }

        //添加边
        graph.inserEdge(0,1,1);
        graph.inserEdge(0,2,1);
        graph.inserEdge(1,2,1);
        graph.inserEdge(1,3,1);
        graph.inserEdge(1,4,1);

        graph.showGraph();
//        graph.dfs();
        graph.bds();

    }
    //深度优先算法
    public void dfs(boolean[] isvisited,int i){
        //访问该节点,并进行输出
        System.out.print(getValueByIndex(i) + "->");
        //将该节点设置为已经访问
        isvisited[i] = true;
        //查找节点i的第一个临节点w
        int w = getFirstNeighbor(i);
        while(w != -1){
            if (!isvisited[w]){
                dfs(isvisited,w);
            }
            //如果该节点已经访问过了
            w = getNextNeighbor(i,w);
        }
    }

    //广度优先搜索
    private void bfs(boolean[] isvisited,int i) {
        int u;//表示对应的头结点对应的下标
        int w;//邻接节点w
        //队列 记录节点访问的顺序
        LinkedList<Object> queue = new LinkedList<>();
        //访问这个节点,输出这个结点的信息
        System.out.println(getValueByIndex(i)+ "=>");
        //标记为已经访问
        isvisited[i] = true;
        //将节点加入队列
        queue.addLast(i);
        while (!queue.isEmpty()) {
            u = (Integer)queue.removeFirst();
            w = getFirstNeighbor(u);
            while(w != -1){
                if (isvisited[w]) {
                    System.out.println(getValueByIndex(w) + "=>");
                    isvisited[w] = true;
                }
                //以u为前驱结点,找w后面的下一个节点
                w = getNextNeighbor(u,w);
            }
        }

    }

    //遍历所有的节点
    public void bds(){
        for (int i = 0; i < getNumOfVertex(); i++) {
            if (!isvisit[i]){
                bfs(isvisit,i);
            }
        }
    }

    public void dfs(){
        //遍历我们的所有节点,进行dfs
        for (int i = 0; i < getNumOfVertex(); i++) {
            if (!isvisit[i]){
                dfs(isvisit,i);
            }
        }
    }
    //构造器,

    public Graph(int n) {
        edges = new int[n][n];
        vertexList = new ArrayList<String>(n);
        numOfEdges = 0;
    }

    /**
     *
     * @param index
     * @return   如果存在,就返回对应的下标
     */
    //得到第一个节点的临界点
    public int getFirstNeighbor(int index){
        for (int j  = 0;j < vertexList.size();j++){
            if (edges[index][j] > 0){
                return j;
            }
        }
        return -1;
    }

    //根据前一个邻接节点的下标,来获取下一个邻接节点
    public int getNextNeighbor(int v1,int v2){
        for (int j = v2 + 1;j < vertexList.size();j++){
            if (edges[v1][j] > 0) {
                return j;
            }
        }

        return -1;
    }
    //图中常用的方法
    //返回节点的个数
    public int getNumOfVertex() {
        return vertexList.size();
    }
    //得到边的数目
    public int getNumOfEdges(){
        return numOfEdges;
    }
    //返回节点i对应的数据
    public String getValueByIndex(int i){
        return vertexList.get(i);
    }

    //返回v1 和 v2的权值
    public int getWeight(int v1,int v2){
        return edges[v1][v2];
    }

    //显示图
    public void showGraph(){
        for (int[] link : edges){
            System.out.println(Arrays.toString(link));
        }
    }


    //插入节点
    public void insertVertex(String vertex){
        vertexList.add(vertex);
    }
    //这里是边,通过对应的矩阵
    public void inserEdge(int v1,int v2,int weight){
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
    }
}