โถ ์ ํ
- ๋ด๋ฆผ์ฐจ์, ์ค๋ฆ์ฐจ์ ๊ฐ์ ์ ๋ ฌ์ ์ด๋ค ๊ธฐ์ค์ ๋ง์ถฐ์ ํด์ผ๋ ๋๊ฐ ์๋๋ฐ Comparable์ ์ฌ์ฉํ๋ฉด ์ข๋ค
์๋ฐ๋ก ๋ฌธ์ ๋ฅผ ํ๋ค๋ณด๋ฉด ์๋ฃํ ๋ด์๋ ํด๋์ค๋ฅผ ๋งค์ฐ ์์ฃผ ์ ์ธํ๋ค. ํด๋์ค ์ ์ธํ ๋ Comparable ์ธํฐํ์ด์ค๋ฅผ implementsํด๋๊ณ , compareTo ๋ฉ์๋๋ฅผ @Overrideํด์ฃผ๋ฉด ๋๋ค.
implements Comparable<T>
@Override
public int compareTo(T o) {
return 0 or 1 or -1
}
์ด๋ฒ์ ์ฐ์ต์ฉ์ผ๋ก ๋ฌธ์ ํ๋ฉด์ ์ฌ์ฉํ Node ํด๋์ค๋ฅผ ๊ธฐ์ค์ผ๋ก ๋ณด์.
class Node implements Comparable<Node>{
int v, w;
Node(int v, int w){
this.v = v;
this.w = w;
}
@Override
public int compareTo(Node o) {
if(this.w == o.w) {
return Integer.compare(o.v, this.v); // ๊ฐ์ค์น๊ฐ ๊ฐ์ผ๋ฉด ๊ฐ์ด ํฐ๊ฒ ๋จผ์ ์์ผ๋จ
}else {
return Integer.compare(this.w, o.w); // ๊ฐ์ค์น๊ฐ ๋ ํฐ๊ฒ ๋ฉ๋ฆฌ๊ฐ์ผ๋จ(์ค๋ฆ์ฐจ์)
}
}
}
compareTo์ ๊ธฐ์ค์ ์ ์๊ธฐํด๋๋ ๊ฒ ์ค์ํ๋ค. ํญ์ this๊ฐ ๊ธฐ์ค์ด๊ณ , compareTo์ ๋งค๊ฐ๋ณ์๋ก ๋ค์ด์ค๋๊ฒ ๋น๊ตํ ๋์์ด๋ค.
๊ฐ primitive ์๋ฃํ์๋ compare ํจ์๊ฐ ์๋๋ฐ ๋น๊ตํ๋ ๋ ๊ฐ ์ค ์ค๋ฅธ์ชฝ์ด ํฌ๋ฉด 1, ๊ฐ์ผ๋ฉด 0, ์์ผ๋ฉด -1์ ๋ฐํํ๋ค.
์ฆ ์ค๋ฆ์ฐจ์์ผ๋ก ๋ง๋ค๊ณ ์ถ์๋๋ ์ค๋ฅธ์ชฝ์ด ๋ ํฌ๊ฒ ๋ง๋ค๊ณ , ๋ด๋ฆผ์ฐจ์์ผ๋ก ํ๊ณ ์ถ์ ๋๋ ์๊ฒ ๋ง๋ค๋ฉด ๋๋ค. ๊ฐ์ ๊ฒฝ์ฐ์ ํ๋ฒ๋ ๋น๊ต์์ผ์ ์ ๋ ฌ ์กฐ๊ฑด์ ์ธ๋ถํ ํ๋ ๊ฒ๋ ๊ฐ๋ฅํ๋ค.
์ด๋ ๊ฒ ๋ง๋ compareTo๋, ์ด ์๋ฃํ์ผ๋ก ๋ง๋ list๋ฅผ sort(null) ํด์ฃผ๋ฉด ์์์ ์ ๋ ฌ๋๋ค. null์ ๋ฃ์ด์ฃผ๋ฉด ๋ด๊ฐ ๊ตฌํํ Comparable์ด ๋ค์ด๊ฐ๊ธฐ ๋๋ฌธ์ด๋ค.
โถ ์ ๋ต
์ธ์์ผ ๋๋๊ฑฐ๋ผ์ ๊ทธ๋ฅ ๋ฌด์กฐ๊ฑด ๋ง์ด ์ณ๋ด์ผ๋๋ค. ํ๋ก๊ทธ๋๋จธ์ค๊ฐ์ ์๋์์ฑ์ด ์๋๋ ํ๊ฒฝ์๋ ์์ํ๊ฒ ์ธ ์ค ์์์ผํ๋ค.
https://school.programmers.co.kr/learn/courses/30/lessons/120880
ํ๋ก๊ทธ๋๋จธ์ค
์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์ ๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์ ๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์.
programmers.co.kr
import java.util.*;
class Node implements Comparable<Node>{
int v, w;
Node(int v, int w){
this.v = v;
this.w = w;
}
@Override
public int compareTo(Node o) {
if(this.w == o.w) {
return Integer.compare(o.v, this.v); // ๊ฐ์ค์น๊ฐ ๊ฐ์ผ๋ฉด ๊ฐ์ด ํฐ๊ฒ ๋จผ์ ์์ผ๋จ
}else {
return Integer.compare(this.w, o.w); // ๊ฐ์ค์น๊ฐ ๋ ํฐ๊ฒ ๋ฉ๋ฆฌ๊ฐ์ผ๋จ(์ค๋ฆ์ฐจ์)
}
}
}
class Solution {
public int[] solution(int[] numlist, int n) {
int[] answer = new int[numlist.length];
List<Node> arr = new ArrayList<Node>();
// ๊ฑฐ๋ฆฌ๊ฐ ๊ฐ์ผ๋ฉด ๋ ํฐ์๋ฅผ ๋ฐํํจ
int idx = 0;
for(int i: numlist){
arr.add(new Node(numlist[idx], Math.abs(n-numlist[idx++])));
}
arr.sort(null);
idx = 0;
for(Node i: arr){
answer[idx++] = i.v;
}
return answer;
}
}
๋์์ด ๋๋ค๋ฉด ๋๊ธ์ด๋ ๊ณต๊ฐ ๋ฒํผ ํ ๋ฒ์ฉ ๋๋ฅด๊ณ ๊ฐ์ฃผ์ธ์!
'OJ๐ผ > ์๊ณ ๋ฆฌ์ฆ ์ ํ ์ ๋ฆฌ๐' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋ชจ๋ ธํค์คํ(๋จ์กฐ์คํ)โฐ (0) | 2025.01.07 |
---|---|
โ๏ธ์ด์งํ์ - BinarySearch(feat. ํ๋ผ๋ฉํธ๋ฆญ ์์น) (0) | 2024.07.16 |
Dynamic Programming์ด ์์ธ DFSโ๏ธ - ๋ด๋ฆฌ๋ง๊ธธ, ์์ฌ์์ด ํ๋ค๐ผ (0) | 2024.04.07 |
์ ๋ ฌโ๏ธ- ์์์ ๋ ฌ (0) | 2024.04.04 |
Bruteforce๐คฎ - ์์ด, ์กฐํฉ, ๋ถ๋ถ์งํฉ (0) | 2024.03.31 |