Given n nodes labeled from 0 to n - 1 and a list of undirected edges (each edge is a pair of nodes), write a function to find the number of connected components in an undirected graph.

Example 1:
     0          3
     |          |
     1 --- 2    4
Given n = 5 and edges = [[0, 1], [1, 2], [3, 4]], return 2.

Example 2:
     0           4
     |           |
     1 --- 2 --- 3
Given n = 5 and edges = [[0, 1], [1, 2], [2, 3], [3, 4]], return 1.

Note:
You can assume that no duplicate edges will appear in edges. Since all edges are undirected,
 [0, 1] is the same as [1, 0] and thus will not appear together in edges.

Solution：I use a map to store the relationship between them and the key is the index. We use Array list as a list of friends.Thus we can use DFS to solve this problem.

Time Complexity: O(n+e)

class Solution {
    public int countComponents(int n, int[][] edges) {
       HashMap<Integer,List<Integer>> map = new HashMap<>();
        if(n < 1) return n;
        for(int i = 0; i < n; i++){
            map.put(i,new ArrayList<Integer>());//create a map to store.
        }
        for(int[] edge:edges){//add each other as a friend
            map.get(edge[0]).add(edge[1]);
            map.get(edge[1]).add(edge[0]);
        }
        Set<Integer> visited = new HashSet<>();//cause this problem is not about 0 or 1, 
                                              //thus we cannot use boolean array, we use set.
        int count = 0;
        for(int i = 0; i < n; i++){
            if(visited.add(i)){
                dfs(i,map,visited);
                count++;//new dfs, means we have find one connected, this one is a new one, which count++
            }
        }
        return count;
    }
    public void dfs(int i, HashMap<Integer,List<Integer>> map, Set<Integer> visited){
        for(int j:map.get(i)){//get all its friends from the list
            if(visited.add(j)){//if not visited, recursively call this function 
                 dfs(j,map,visited);
             }
        }
    }
}