圖的遍歷方式有倆種：

• 深度優先遍歷（DFS）
• 廣度優先遍歷（BFS）

（1）深度優先遍歷（利用棧和遞迴來實現）
思路：先以一個點為起點，這裡假如是點A，那麼就將A相鄰的點放入堆疊，然後在棧中再取出棧頂的頂點元素（假如是點B），再將B相鄰的且沒有訪問過的點放入棧中，不斷這樣重複操作直至棧中元素清空。這個時候你每次從棧中取出的元素就是你依次訪問的點，以此實現遍歷。

class Node {
    int x;
    Node next;
    public Node(int x) {
        this.x = x;
        this.next = null
 
;
    }
}
public class DFS {
    public Node first;
    public Node last;

    public static int run[] = new int[9];
    public static DFS head[] = new DFS[9];

    public static void dfs(int current) {
        run[current] = 1;
        System.out.print("[" + current + "]");

        while (head[current].first != null
 
) {
            if(run[head[current].first.x] == 0) { //如果頂點尚未遍歷，就進行dfs遞迴
                dfs(head[current].first.x);
            }
            head[current].first = head[current].first.next;
        }
    }

    public boolean isEmpty() {
        return first == null;
    }
    public void print() {
        Node current = first;
        while
 
(current != null) {
            System.out.print("[" + current.x + "]");
            current = current.next;
        }
        System.out.println();
    }
    public void insert(int x) {
        Node newNode = new Node(x);
        if(this.isEmpty()) {
            first = newNode;
            last = newNode;
        }
        else {
            last.next = newNode;
            last = newNode;
        }
    }

    public static void main(String[] args) {
        int Data[][] = { {1,2}, {2,1}, {1,3}, {3,1}, {2,4}, {4,2},
                {2,5}, {5,2}, {3,6}, {6,3}, {3,7}, {7,3}, {4,5}, {5,4},
                {6,7}, {7,6}, {5,8}, {8,5}, {6,8}, {8,6} };
        int DataNum;
        int i,j;
        System.out.println("圖形的鄰接表內容為：");
        for(i=1;i<9;i++) {
            run[i] = 0;
            head[i] = new DFS();
            System.out.print("頂點" + i + "=>");
            for (j=0;j<20;j++) {
                if(Data[j][0] == i) {
                    DataNum = Data[j][1];
                    head[i].insert(DataNum);
                }
            }
            head[i].print();
        }
        System.out.println("深度優先遍歷頂點：");
        dfs(1);
        System.out.println("");
    }
}

（2）廣度優先遍歷：（基於佇列和遞迴的方式）
思路：基本操作是和深度優先差不多的，只不過這裡是通過佇列來實現的，找到一個起點A，並將A相鄰的點放入佇列中，這時將隊首元素B取出，並將B相鄰且沒有訪問過的點放入佇列中，不斷重複這個操作，直至佇列清空，這個時候依次訪問的頂點就是遍歷的順序。

class Node {
    int x;
    Node next;
    public Node(int x) {
        this.x = x;
        this.next = null;
    }
}
public class BFS {
    public Node first;
    public Node last;

    public static int run[] = new int[9];
    public static BFS head[] = new BFS[9];
    public final static int MAXSIZE = 10;
    static int[] queue = new int[MAXSIZE];
    static int front = -1;
    static int rear = -1;

    public static void enqueue(int value) {
        if(rear>=MAXSIZE) return;
        rear++;
        queue[rear] = value;
    }

    public static int dequeue() {
        if(front == rear) return -1;
        front++;
        return queue[front];
    }

    public static void bfs(int current) {
        Node tempnode;
        enqueue(current);
        run[current] = 1;
        System.out.print("[" + current + "]");
        while (front != rear) {
            current = dequeue();
            tempnode = head[current].first;
            while (tempnode != null) {
                if(run[tempnode.x] == 0) {
                    enqueue(tempnode.x);
                    run[tempnode.x] = 1;
                    System.out.print("[" + tempnode.x + "]");
                }
                tempnode = tempnode.next;
            }
        }
    }

    public boolean isEmpty() {
        return first == null;
    }

    public void print() {
        Node current = first;
        while(current != null) {
            System.out.print("[" + current.x + "]");
            current = current.next;
        }
        System.out.println();
    }
    public void insert(int x) {
        Node newNode = new Node(x);
        if(this.isEmpty()) {
            first = newNode;
            last = newNode;
        }
        else {
            last.next = newNode;
            last = newNode;
        }
    }

    public static void main(String[] args) {
        int Data[][] = { {1,2}, {2,1}, {1,3}, {3,1}, {2,4}, {4,2},
                {2,5}, {5,2}, {3,6}, {6,3}, {3,7}, {7,3}, {4,5}, {5,4},
                {6,7}, {7,6}, {5,8}, {8,5}, {6,8}, {8,6} };
        int DataNum;
        int i,j;
        System.out.println("圖形的鄰接表內容為：");
        for(i=1;i<9;i++) {
            run[i] = 0;
            head[i] = new BFS();
            System.out.print("頂點" + i + "=>");
            for (j=0;j<20;j++) {
                if(Data[j][0] == i) {
                    DataNum = Data[j][1];
                    head[i].insert(DataNum);
                }
            }
            head[i].print();
        }
        System.out.println("深度優先遍歷頂點：");
        bfs(1);
        System.out.println("");
    }

}