Connected Component in Undirected Graph

Find the number connected component in the undirected graph. Each node in the graph contains a label and a list of its neighbors. (a connected component (or just component) of an undirected graph is a subgraph in which any two vertices are connected to each other by paths, and which is connected to no additional vertices in the supergraph.)

Notice

Each connected component should sort by label.

Have you met this question in a real interview? Yes
Clarification
Learn more about representation of graphs

Example
Given graph:

A——B C
\ | |
\ | |
\ | |
\ | |
D E
Return {A,B,D}, {C,E}. Since there are two connected component which is {A,B,D}, {C,E}

又是一道bfs可以直接解决的问题
java

/**
 * Definition for Undirected graph.
 * class UndirectedGraphNode {
 *     int label;
 *     ArrayList<UndirectedGraphNode> neighbors;
 *     UndirectedGraphNode(int x) { label = x; neighbors = new ArrayList<UndirectedGraphNode>(); }
 * };
 */


public class Solution {
    /*
     * @param nodes: a array of Undirected graph node
     * @return: a connected set of a Undirected graph
     */
    public List<List<Integer>> connectedSet(List<UndirectedGraphNode> nodes) {
        // write your code here
        List<List<Integer>> list = new ArrayList<>();
        if (nodes == null || nodes.size() == 0) {
            return list;
        }
        Map<UndirectedGraphNode, Boolean> map = new HashMap<>();
        for (UndirectedGraphNode node : nodes) {
            map.put(node, false);
        }
        for (UndirectedGraphNode node : nodes) {
            if (map.get(node) == false) {
                map.put(node, true);
                bfs(node, map, list);
            }
        }
        return list;
    }
    private void bfs(UndirectedGraphNode node, 
                     Map<UndirectedGraphNode, Boolean> map, 
                     List<List<Integer>> list) {
        List<Integer> path = new ArrayList<>();
        Queue<UndirectedGraphNode> queue = new LinkedList<>();
        queue.offer(node);
        while (!queue.isEmpty()) {
            UndirectedGraphNode n = queue.poll();
            path.add(n.label);
            for (UndirectedGraphNode val : n.neighbors) {
                if (map.get(val) == false) {
                    queue.offer(val);
                    map.put(val, true);
                }
            }
        }
        Collections.sort(path);
        list.add(path);
    }
}

python

"""
Definition for a undirected graph node
class UndirectedGraphNode:
    def __init__(self, x):
        self.label = x
        self.neighbors = []
"""

import Queue

class Solution:
    """
    @param: nodes: a array of Undirected graph node
    @return: a connected set of a Undirected graph
    """
    def connectedSet(self, nodes):
        # write your code here
        if nodes is None or len(nodes) == 0:
            return []
        result = []
        mapping = {ele : False for ele in nodes}
        for node in nodes:
            if mapping[node] is False:
                mapping[node] = True
                self.bfs(node, mapping, result)
        return result

    def bfs(self, node, mapping, result):
        path, queue = [], Queue.Queue()
        queue.put(node)
        while not queue.empty():
            n = queue.get()
            path.append(n.label)
            for ele in n.neighbors:
                if mapping[ele] == False:
                    queue.put(ele)
                    mapping[ele] = True
        path.sort()
        result.append(path)