【图的复习~~】

图的深度优先遍历

递归与非递归实现

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class DFS {
    public static void main(String[] args) {
                               //A, B, C, D, E, F, G
//        int[][] matrix = {{0, 1, 1, 0, 0, 0, 0, 0},
//                {1, 0, 0, 1, 1, 0, 0, 0},
//                {1, 0, 0, 0, 0, 1, 1, 0},
//                {0, 1, 0, 0, 0, 0, 0, 1},
//                {0, 1, 0, 0, 0, 0, 0, 1},
//                {0, 0, 1, 0, 0, 0, 1, 0},
//                {0, 0, 1, 0, 0, 1, 0, 0},
//                {0, 0, 0, 1, 1, 0, 0, 0}};
        int[][] weightMatrix =  {{0,1,0,0,0,1,1}, // 用0代表不可达
                            /*B*/{0,0,0,0,1,1,0},
                            /*C*/{0,1,0,1,1,1,0},
                            /*D*/{0,0,1,0,1,0,0},
                            /*E*/{0,0,0,0,0,0,1},
                            /*F*/{1,1,1,0,1,0,1},
                            /*G*/{1,0,0,0,1,1,0}};
        char[] vertices = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
        Graph graph = new Graph(weightMatrix,vertices);
        graph.dfs1();
        System.out.println();
        graph.dfs();
    }
}
class Graph {
    private int[][] matrix;
    private char[] vertices;
    private int numOfVertex;
    private boolean[] isVisited;
    public Graph(int[][] matrix, char[] vertices) {
        this.matrix = matrix;
        this.vertices = vertices;
        numOfVertex = vertices.length;
    }
    public char getVertexByIndex(int i) {
        return vertices[i];
    }
    public void dfs(int i) {
        //只要权值不为0，那么就代表可达，非递归
        Stack<Integer> stack = new Stack<>();
        List<Integer> list = new ArrayList<>();
        isVisited[i] = true;
        stack.push(i);
        list.add(i);
        while(list.size() < numOfVertex) {
            int index = stack.peek();
            for (int j = 0; j < numOfVertex; j++) {
                if(matrix[index][j] != 0 && !isVisited[j]) {
                    isVisited[j] = true;
                    stack.push(j);
                    list.add(j);
                    break;
                }
                if(j == numOfVertex - 1 && isVisited[j]) stack.pop();
            }
        }
        System.out.println(list);
        for (int j = 0; j < list.size(); j++) {
            System.out.print(getVertexByIndex(list.get(j)) + "-->");
        }
    }
    public void dfs() {
        isVisited = new boolean[numOfVertex];
        for (int i = 0; i < numOfVertex; i++) {
            if(!isVisited[i]) {
                dfs1(i);
            }
        }
    }
    public void dfs1() {
        isVisited = new boolean[numOfVertex];
        for (int i = 0; i < numOfVertex; i++) {
            if(!isVisited[i]) {
                dfs1(i);
            }
        }
    }
    public int getFirstNeighbor(int i) {
        for (int j = 0; j < numOfVertex; j++) {
            if(matrix[i][j] != 0) return j;
        }
        return -1;
    }
    public int getNextNeighbor(int i, int j) {
        for (int k = j + 1; k < numOfVertex; k++) {
            if(matrix[i][k] != 0) return k;
        }
        return -1;
    }
    public void dfs1(int i) {
        //递归形式
        isVisited[i] = true;
        System.out.print(getVertexByIndex(i) + "-->");
        int w = getFirstNeighbor(i);
        while(w != -1) {
            if(!isVisited[w]) {
                dfs1(w);
            }
            w = getNextNeighbor(i, w);
        }
    }
}

图的广度优先遍历

import java.util.ArrayDeque;
import java.util.Queue;

public class BFS {
    public static void main(String[] args) {
                                //A,B,C,D,E,F,G
        int[][] weightMatrix =  {{0,1,0,0,0,1,1}, // 用0代表不可达
                            /*B*/{1,0,1,0,0,1,0},
                            /*C*/{0,1,0,1,0,1,0},
                            /*D*/{0,0,1,0,1,0,0},
                            /*E*/{0,0,0,1,0,0,1},
                            /*F*/{1,1,1,0,0,0,1},
                            /*G*/{1,0,0,0,1,1,0}};
        char[] vertices = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
        BGraph bGraph = new BGraph(weightMatrix,vertices);
        bGraph.bfs();
    }
}

class BGraph {
    private int[][] matrix;
    private char[] vertices;
    private int numOfVertex;
    private boolean[] isVisited;
    public BGraph(int[][] matrix, char[] vertices) {
        this.matrix = matrix;
        this.vertices = vertices;
        numOfVertex = vertices.length;
    }
    public char getVertexByIndex(int i) {
        return vertices[i];
    }
    public void bfs() {
        isVisited = new boolean[numOfVertex];
        for (int i = 0; i < numOfVertex; i++) {
            if(!isVisited[i]) {
                bfs(i);
            }
        }
    }
    public void bfs(int i) {
        System.out.print(getVertexByIndex(i) + "-->");
        isVisited[i] = true;
        Queue<Integer> queue = new ArrayDeque<>();
        queue.offer(i);
        while(!queue.isEmpty()) {
            int index = queue.poll();
            for (int j = 0; j < numOfVertex; j++) {
                if(matrix[index][j] != 0 && !isVisited[j]) {
                    System.out.print(getVertexByIndex(j) + "-->");
                    isVisited[j] = true;
                    queue.offer(j);
                }
            }
        }
    }
}