[프로그래머스] 달리기 경주 자바 코드

* things i leant

1. LinkedList의 IndexOf() 함수는 시간효율이 낮음

문제 보고 LinkedList 개념이라서 사용해봤지만 타임아웃, indexOf 함수가 시간효율이 낮은 함수라고 한다.

2. Array -> ArrayList

입력값으로 주어지는 배열을 List로 바로 넣고 싶을때 for문 대신 사용하는 방법 알아냄.. 이걸 지금까지 for문 돌렸다;

• Arrays.asList(배열)

ArrayList<String> playerList = new ArrayList<>(Arrays.asList(players));

3. <HashMap 함수 탈탈 털기>

//선언			HashMap<String, Integer> hm = new HashMap<String, Integer>();

//아이템 넣기	hm.put("merong", 150);
//값 찾기		value = hm.get("merong");
//아이템 삭제	hm.remove("merong");
//아이템 갯수	int counts = hm.size();

//전체삭제		hm.clear();
//복제			newHM = hm.clone();
//키가 있는지	yn = hm.containsKey("merong");
//값이 있는지	yn = hm.containsValue(150);
//비었는지		yn = hm.isEmpty();

//전체 set		Set set = hm.entrySet();
				System.out.println("Set 데이터는 : " + set);
                //"set values : [merong=150,babo=3, ...]"
//키 set		Set keys = hm.keySet();
				//"key values : [merong,babo, ...]"
//값 collection	Collection c = hm.values();
				//"values values : [150,3, ...]"

* 알고리즘

1. HashMap을 두개 선언해서 하나는 이름으로 하나는 등수로 검색할 수 있게 함
2. callings 하나당 이름 HashMap도 앞사람이랑 등수 서로 바꿔주고 등수 HashMap도 앞사람이랑 이름 서로 바꿔줌
3. 아무 HashMap으로 최종 array 뽑아냄

* 자바 코드

- (1차 - LinkedList)

import java.util.*;

class Solution {
    public String[] solution(String[] players, String[] callings) {
        String[] answer = {};
        LinkedList<String> seq = new LinkedList<String>();
        int current = 0;
        
        for(int i = 0; i < players.length; i++){
            seq.add(players[i]);
        }
        
        for(int i = 0; i < callings.length; i++){
            current = seq.indexOf(callings[i]);
            seq.remove(current);
            seq.add(current-1, callings[i]);
        }
        
        answer = seq.toArray(new String[seq.size()]);
        return answer;
    }
}

-> 시작한지 20분만에 쉽게 끝내나 했는데, List는 역시 시간효율성이 좋지않아 코테에서는 무용지물 개념인 듯 하다..
-> 다시 짜보자! 시간효율성 갑인 개념..
-> 다시 생각해보니 삭제, 추가가 아니라 그냥 제쳐간 앞, 뒤만 서로 바꾸면 되는거구나.............;;; 그럼 Map으로 할 수 있겠네

- (2차 - HashMap but)

import java.util.*;

class Solution {
    public String[] solution(String[] players, String[] callings) {
        String[] answer = {};
        HashMap< Integer, String> seq = new HashMap<Integer, String>();
        int current = 0;
        String backPerson = "";
        
        for(int i = 0; i < players.length; i++){
            seq.put(i, players[i]);
        }
        
        for(int i = 0; i < callings.length; i++){
        	// HashMap을 매번 전체 검색해서 사람을 찾으니까 효율성 떨어짐
            for(int j = 0; j < seq.size(); j++){
                if(callings[i].equals(seq.get(j)) == true){     // a.strcmp(b) == 0 *c랑 완전 다르니 주의*
                    current = j;
                    break;
                }
            }
            backPerson = seq.get(current - 1);
            seq.replace(current-1, callings[i]); 
            seq.replace(current, backPerson); 
            }
        
        Collection<String> c = seq.values();
        answer = c.toArray(new String[c.size()]);
        return answer;
    }
}

-> 동일한 결과. HashMap을 썼지만 전체 탐색을 하기 때문에 당연한 결과였다.

- (3차 - HashMap)

import java.util.*;

class Solution {
    public String[] solution(String[] players, String[] callings) {
        String[] answer = new String[players.length];
        //이름으로 검색하는 HashMap, 등수로 검색하는 HashMap 각각 선언
        HashMap<String, Integer> playersName = new HashMap<String, Integer>();
        HashMap<Integer, String> playersNumber = new HashMap<Integer, String>();
        int currentNum = 0;
        String backName = "";
        
        //이름, 등수 HashMap에 초기값 할당
        for(int i = 0; i < players.length; i++){
            playersName.put(players[i], i);
            playersNumber.put(i, players[i]);
        }
        
        //이름으로 검색후 이름 불린 사람과 앞 사람의 등수 바꾸고, 등수 HashMap에도 동일하게 적용
        for(int i = 0; i < callings.length; i++){   
            currentNum = playersName.get(callings[i]);
            backName = playersNumber.get(currentNum-1);
            //이름 HashMap
            playersName.replace(callings[i], currentNum-1);
            playersName.replace(backName, currentNum);
            //등수 HashMap
            playersNumber.replace(currentNum-1, callings[i]);
            playersNumber.replace(currentNum, backName);            
        }
        //KeySet()을 사용한 for문
        for(String key: playersName.keySet()){
            answer[playersName.get(key)] = key;
        }
        
        return answer;
    }
}

-> HashMap 두개 선언할 생각을 왜 못했지? 15분만에 통과