java图，创建，广度优先遍历，深度优先遍历

图：
代码：

package com.wangyq.datastructrue.map;

import com.sun.jmx.remote.internal.ArrayQueue;

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

class Test {
    public static void main(String[] args) {
        //初始化图
        Map map = new Map(5);
        //设置联通
        map.setEdge(1, 2);
        map.setEdge(1, 3);
        map.setEdge(1, 5);
        map.setEdge(2, 4);
        map.setEdge(3, 5);
        map.setEdge(4, 5);

        //打印图
        map.show();
        //广度优先遍历
        System.out.println("广度优先遍历：");
        map.breadthFirst();
        //深度优先
        System.out.println("深度优先遍历：");
        map.depthFirst();
    }
}

public class Map {
    int[][] ints = null;
    int[] vertexs = null;
    int vertexNum = 0;
    int edgeNum = 0;

    Map(int vertexNum) {
        //初始化数组，图
        ints = new int[vertexNum][vertexNum];
        //初始化顶点
        vertexs = new int[vertexNum];
        //初始化顶点数量
        this.vertexNum = vertexNum;
        //进行默认赋值
        for (int[] ints1 : ints) {
            for (int i = 0; i < ints1.length; i++) {
                ints1[i] = 0;
            }
        }
    }

    /**
     * 打印图
     */
    public void show() {
        for (int[] ints1 : ints) {
            System.out.println(Arrays.toString(ints1));
        }
    }

    public void setEdge(int i, int i1) {
        //防止角标越界
        if (i > vertexNum || i1 > vertexNum || i < 1 || i1 < 1) {
            System.out.println("顶点不存在");
            return;
        } else {
            if (ints[i - 1][i1 - 1] != 1) {
                edgeNum++;
                //赋值联通，无向图
                ints[i - 1][i1 - 1] = 1;
                ints[i1 - 1][i - 1] = 1;
            } else {
                System.out.println("该节点已经联通");
            }
        }
    }

    /**
     * 广度优先遍历
     */
    public void breadthFirst() {
        //记录访问过的节点
        int[] temp = new int[vertexNum];
        Queue<Integer> queue = new ArrayDeque();
        queue.add(0);
        //广度优先遍历
        while (!queue.isEmpty()) {
            int i = queue.poll();
            System.out.println(i + 1);
            //横向循环
            for (int j = 0; j < vertexNum; j++) {
                if (ints[i][j] == 1) {
                    //遍历到当前节点
                    if (temp[j] != 1) {
                        temp[j] = 1;
                        queue.add(j);
                    }
                }
            }
        }
    }

    /**
     * 深度优先,默认从第0个开始
     */
    public void depthFirst() {
        //记录访问过的节点
        int[] temp = new int[vertexNum];
        for (int i = 0; i < vertexNum; i++) {
            depthFirst(i, temp);
        }

    }

    public void depthFirst(int vertex, int[] temp) {
        for (int i = 0; i < vertexNum; i++) {
            if (ints[vertex][i] == 1) {
                //遍历到当前节点
                if (temp[vertex] != 1) {
                    temp[vertex] = 1;
                    System.out.println(vertex + 1);
                }
                if (temp[i] != 1) {
                    temp[i] = 1;
                    System.out.println(i + 1);
                    //当前节点联通，可继续深入遍历
                    depthFirst(i, temp);
                }
            }
        }
    }
}

运行结果：
[0, 1, 1, 0, 1]
[1, 0, 0, 1, 0]
[1, 0, 0, 0, 1]
[0, 1, 0, 0, 1]
[1, 0, 1, 1, 0]
广度优先遍历：
1
2
3
5
4
深度优先遍历：
1
2
4
5
3