06-图1 列出连通集

//06-图1 列出连通集 

import java.util.Scanner;
import java.util.Stack;
import java.util.LinkedList;
import java.util.Queue;

class node{
    int data;
    node next;
}

public class Main {
    public static boolean[] visited = new boolean[10];

    static void connect(node p1, int c1, node p2, int c2){
        node newnode1 = p1;
        while(newnode1.next != null){
            newnode1  = newnode1.next;
        }
        newnode1.next = new node();
        newnode1.next.data = c2;
        node newnode2 = p2;
        while(newnode2.next != null){
            newnode2  = newnode2.next;
        }
        newnode2.next = new node();
        newnode2.next.data = c1;
    }

    static void read(Scanner s, node[] nodes, int E){
        int c1, c2;
        for(int i = 0; i < E; i ++){
            c1 = s.nextInt();
            c2 = s.nextInt();
            node p1 = nodes[c1];
            node p2 = nodes[c2];
            connect(p1, c1, p2, c2);
        }
    }

    static int findmin(node v){
        int min = 11;
        node p = v.next;
        for(;p != null; p = p.next){
            if(!visited[p.data]) {
                if (min > p.data) min = p.data;
            }
        }
        return min;
    }

    static void dfs(node[] nodes, node v, Stack stack){
        if(!visited[v.data]) {
            stack.push(v.data);
            System.out.print(v.data + " ");
            visited[v.data] = true;
        }
        int min;
        min = findmin(v);
        if(min == 11){
            if(stack.empty()){
                return;
            }
            min = (int)stack.pop();
        }
        dfs(nodes, nodes[min], stack);
    }


    static void bfs(node[] nodes, int x, Queue q){
       q.add(nodes[x].data);
       visited[x] = true;
       while(!q.isEmpty()){
           int p = (int)q.remove();
           int num = 0;
           node n = nodes[p];
           while(n != null){
               num ++;
               n = n.next;
           }
           for(int i = 0; i < num; i ++){
               int min = findmin(nodes[p]);
               if(min < 11) {
                   visited[min] = true;
                   q.add(min);
               }
           }
           System.out.print(p + " ");
       }
    }

    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        Queue<Integer> queue = new LinkedList<>();
        Scanner s = new Scanner(System.in);
        int N, E;
        N = s.nextInt();
        E = s.nextInt();
        node[] nodes = new node[N];
        for(int i = 0; i < N; i ++){
            nodes[i] = new node();
            nodes[i].data = i;
        }
        read(s, nodes, E);
        for(int i = 0; i < N; i ++){
            if(!visited[i]){
                System.out.print("{ ");
                dfs(nodes, nodes[i], stack);
                System.out.println("}");
            }
            visited[i] = false;
        }

        for(int i = 0; i < N; i ++){
            if(!visited[i]){
                System.out.print("{ ");
                bfs(nodes, i, queue);
                System.out.println("}");
            }

        }


    }
}

更科学的DFS见下一题。