[LeetCode- Ch3. 배열] 4. 그룹 아나그램 (+ computeIfAbsent() )

https://leetcode.com/problems/group-anagrams/

Group Anagrams - LeetCode

 

Map<String, List<String>> 자료구조를 만들어서 해결

1. toCharArray()후 정렬을 수행해 유일한 키로 만든다

2. 정렬한 키의 리스트가 존재하면, 존재하지 않으면 케이스분류해서 작성

 

1. 자바8 람다식 이용 : computeIfAbsent()

2. List 존재하면, 존재하지 않으면 분류

 

import java.util.*;
class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        //Key Point : toCharArray()이후 sort해서 유일한 키로 사용
        List<List<String>> result = new ArrayList<>();
        Map<String, List<String>> map = new HashMap<>();
        for(String str : strs){
            char[] arr = str.toCharArray();
            Arrays.sort(arr);
            String tmp=String.valueOf(arr);
            //1. 람다식
             map.computeIfAbsent(tmp, k -> new ArrayList<>()).add(str); 
             
            //2. map
            // List<String> tmplist =map.get(tmp);
            // if(tmplist==null){
            //     tmplist=new ArrayList<>();
            //     tmplist.add(str);
            //     map.put(tmp, tmplist);
            // }else {
            //     tmplist.add(str);
            //     map.put(tmp, tmplist);
            // }
        }
        for(List<String> tmplist : map.values()) result.add(tmplist);
        return result;
    }
}

 

+) 세련된 풀이

1. charArray 이용

	//1. 
	public static List<List<String>> groupAnagrams(String[] strs) {
		// 1
		List<List<String>> result = new ArrayList<>();
		if (strs == null || strs.length == 0)
			return result;
		Map<String, List<String>> map = new HashMap<>();

		// 2
		for (String str : strs) {
			System.out.println("str: " + str);
			char[] charArray = str.toCharArray();
			Arrays.sort(charArray);
			System.out.println(charArray);
			String key = String.valueOf(charArray);
			System.out.println("key " + key);

//			if (map.containsKey(key)) {
//				map.get(key).add(str);
//			} else {
//				List<String> list = new ArrayList<>();
//				list.add(str);
//				map.put(key, list);
//			}
			List<String> list = map.getOrDefault(key, new ArrayList<>());
			list.add(str);
			map.put(key, list);
		}
		return new ArrayList<>(map.values());

 

2. 아스키 코드와 containsKey 이용

//2.
	public static List<List<String>> groupAnagrams_ascii(String[] strs) {
		Map<String, List<String>> map = new HashMap<>();
		List<List<String>> result = new ArrayList<>();
	
		for (String str : strs) {
			int[] count = new int[26];
			for (int k = 0; k < str.length(); k++)
				count[str.charAt(k) - 'a']++;
			String key = Arrays.toString(count);
			System.out.println("hash " + key);
			if (map.containsKey(key)) {
				map.get(key).add(str);
			} else {
				List<String> list = new ArrayList<>();
				list.add(str);
				map.put(key, list);
			}
		}
		result.addAll(map.values());
		return result;
	}

---

Map과 List<String> 활용

1. containsKey 이용

2. getOrDefault 이용

3. computeIfAbsent 이용

 

1. containsKey 이용

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        //String 순서 상관없이 같은 아나그램 리턴
        List<List<String>> answer = new ArrayList<>();
        Map<String, List<String> > map = new HashMap<>();
        for(String str : strs){
            char[] arr = str.toCharArray();
            Arrays.sort(arr);
            String tmp = String.valueOf(arr);
            
            if(map.containsKey(String.valueOf(arr))){
                List<String> list = map.get(String.valueOf(arr));
                list.add(str);
                map.put(tmp, list); 
            }else{
                List<String> list =new ArrayList<>();
                list.add(str);
                map.put(tmp, list);  
            } 
        }
        for(List<String> list : map.values()){
            answer.add(list);
        }
        return answer;
    }
        
    
    }

 

2. getOrDefault 이용

	public static List<List<String>> groupAnagrams(String[] strs) {
		// 1
		List<List<String>> result = new ArrayList<>();
		if (strs == null || strs.length == 0)
			return result;
		Map<String, List<String>> map = new HashMap<>();

		// 2
		for (String str : strs) {
			System.out.println("str: " + str);
			char[] charArray = str.toCharArray();
			Arrays.sort(charArray);
			System.out.println(charArray);
			String key = String.valueOf(charArray);
			System.out.println("key " + key);

//			if (map.containsKey(key)) {
//				map.get(key).add(str);
//			} else {
//				List<String> list = new ArrayList<>();
//				list.add(str);
//				map.put(key, list);
//			}
			List<String> list = map.getOrDefault(key, new ArrayList<>());
			list.add(str);
			map.put(key, list);
		}
		return new ArrayList<>(map.values());
//		result.addAll(map.values());
//		 for (Map.Entry<String, List<String>> entry : map.entrySet())
//			 result.add(entry.getValue());
//		return result;
	}

 

3. computeIfAbsent 이용

import java.util.*;
class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        //Key Point : toCharArray()이후 sort해서 유일한 키로 사용
        List<List<String>> result = new ArrayList<>();
        Map<String, List<String>> map = new HashMap<>();
        for(String str : strs){
            char[] arr = str.toCharArray();
            Arrays.sort(arr);
            String tmp=String.valueOf(arr);
            //1. 람다식
             map.computeIfAbsent(tmp, k -> new ArrayList<>()).add(str); 
             
        }
        for(List<String> tmplist : map.values()) result.add(tmplist);
        return result;
    }
}

 

---

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        //String 순서 상관없이 같은 아나그램 리턴
        Map<String, List<String> > map = new HashMap<>();
        for(String str : strs){
            char[] arr = str.toCharArray();
            Arrays.sort(arr);
            String key = String.valueOf(arr);
            //1. getOrDeafult 이용
            // List<String> list = map.getOrDefault(key, new ArrayList<>());
            // list.add(str);
            // map.put(key, list);
            
            //2.containsKey 이용
//             if(map.containsKey(String.valueOf(key))){
//                 List<String> list = map.get(String.valueOf(arr));
//                 list.add(str);
//                 map.put(key, list); 
//             }else{
//                 List<String> list =new ArrayList<>();
//                 list.add(str);
//                 map.put(key, list);  
//             } 
            //3. computeIfAbsent 이용
            map.computeIfAbsent(key, list -> new ArrayList<>()).add(str);
            
        }
        //List<List<String>>을 map.values()로 생성
        return new ArrayList<>(map.values());
    }
}