
์ด ๋ถํธํ ๋ฌธ์ ์ ์ ํด๊ฒฐํ ์ ์๋ ๊ฒ์ด Listโ๏ธ
LinkedList ์ด๋ค. ๊ด๋ จ๋ ๋ฌธ์๋ Java Api Docs์ ๋์์๋ค. LinkedList๊ฐ implementํ๊ณ ์๋ ํด๋์ค๋ค์ ๋ค์๊ณผ ๊ฐ๋ค.Serializable, Cloneable, Iterable<E>, Collection<E>, Deque<E>, List<E>, Queue<E>List๋ LinkedList์์ implemented๋ ํด๋์ค์ด๋ค.LinkedList์์ ์ถ๊ฐ๋ก ๋ ๋ง์ ํจ์๋ฅผ ๊ฐ์ง๊ณ ์๊ธฐ ๋๋ฌธ์ LinkedListํ์
์ ๋ง๋ ๋ค ํ๋๋ผ๋ Listํ์
์ผ๋ก ํํํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง๋ค.List<Integer> list = new LinkedList<>();LinkedList์์ ์ํ๋ index์์ ๊ฐ์ ๋น ๋ฅด๊ฒ ์ฐพ์์ฌ ์ ์๋ Array์ ํน์ง์ ์ถ๊ฐํ ArrayList๊ฐ ์๋ค.ArrayList๋ฅผ ์ฌ์ฉํ๋ฉด get(index)ํจ์๋ฅผ ํตํด ์ํ๋ ์ธ๋ฑ์ค์ ๊ฐ์ ๊ตฌํ ์ ์๋ค.ArrayList์ Vector ๋ชจ๋ Listํด๋์ค๋ฅผ implementํ๊ธฐ ๋๋ฌธ์ ๋๋ค Listํ์
์ผ๋ก ๋ง์ด ํํํ๋ค.ArrayList ์ Vector๋ ๊ฑฐ์ ๋ชจ๋ ๋ถ๋ถ์ด ๋น์ทํ์ง๋ง synchronize(๋๊ธฐํ) ์์ ์ฐจ์ด๊ฐ ์๋ค.ArrayList -> not synchronizedVector -> synchronized ArrayList, ๊ทธ๋ ์ง ์๋ค๋ฉด Vector๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ ์ถ์ฒํ๋ค.thread-safe: ์ฌ๋ฌ ์ค๋ ๋๋ก๋ถํฐ ๋์์ ์ ๊ทผ๋์ด๋ ์์ ํ๊ฒ ์ฌ์ฉํ ์ ์๋ ์์ฑ
์ฃผ์ด์ง ์ ๋ ฅ์ค ์ต๋๊ฐ์ ๊ตฌํ๊ณ , ์ต๋๊ฐ์ด ์ด ์์นํ๋ index ๊ฐ์ ๋ชฉ๋ก์ ๋ฐํํ์ธ์.
[1, 3, 5, 4, 5, 2, 1]์
๋ ฅ๋ ๋ชฉ๋ก์ ์ต๋๊ฐ์ 5์
๋๋ค.
5์ ๋์ผํ ๊ฐ์ ๊ฐ์ง ์์น๋ 3๋ฒ์งธ, 5๋ฒ์งธ ์์น ์
๋๋ค.
์ด ์์น์ ํด๋นํ๋ index๋ [2, 4] ์
๋๋ค.
[2, 4]import java.util.*;
import java.util.stream.*;
class Solution {
public int[] solution(int[] arr) {
// max์ ์ํ ๋ฐํ๊ฐ์ด OptionalInt ์ด๊ธฐ ๋๋ฌธ๋ฐ getAsInt()๋ฅผ ๋ถ์ฌ์ค์ผ ํ๋ค.
int max = Arrays.stream(arr).max().getAsInt();
return IntStream.range(0, arr.length)
.filter(i -> arr[i] == max)
.toArray();
}
}
๋ฌธ์ ์ค๋ช
๊ธธ์ด๊ฐ n์ธ ๋ฐฐ์ด์ 1๋ถํฐ n๊น์ง ์ซ์๊ฐ ์ค๋ณต ์์ด ํ ๋ฒ์ฉ ๋ค์ด ์๋์ง๋ฅผ ํ์ธํ๋ ค๊ณ ํฉ๋๋ค.
1๋ถํฐ n๊น์ง ์ซ์๊ฐ ์ค๋ณต ์์ด ํ ๋ฒ์ฉ ๋ค์ด ์๋ ๊ฒฝ์ฐ true๋ฅผ, ์๋ ๊ฒฝ์ฐ false๋ฅผ ๋ฐํํ๋๋ก ํจ์ solution์ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
์ ์ถ๋ ฅ ์
[4, 1, 3, 2]true[4, 1, 3]false์ ์ถ๋ ฅ ์ ์ค๋ช
์
์ถ๋ ฅ ์ #1
์
๋ ฅ์ด [4, 1, 3, 2]๊ฐ ์ฃผ์ด์ง ๊ฒฝ์ฐ, ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ 4์ด๋ฏ๋ก ๋ฐฐ์ด์๋ 1๋ถํฐ 4๊น์ง ์ซ์๊ฐ ๋ชจ๋ ๋ค์ด ์์ด์ผ ํฉ๋๋ค. [4, 1, 3, 2]์๋ 1๋ถํฐ 4๊น์ง์ ์ซ์๊ฐ ๋ชจ๋ ๋ค์ด ์์ผ๋ฏ๋ก true๋ฅผ ๋ฐํํ๋ฉด ๋ฉ๋๋ค.
์
์ถ๋ ฅ ์ #2
[4, 1, 3]์ด ์ฃผ์ด์ง ๊ฒฝ์ฐ, ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ 3์ด๋ฏ๋ก ๋ฐฐ์ด์๋ 1๋ถํฐ 3๊น์ง ์ซ์๊ฐ ๋ชจ๋ ๋ค์ด ์์ด์ผ ํฉ๋๋ค. [4, 1, 3]์๋ 2๊ฐ ์๊ณ 4๊ฐ ์์ผ๋ฏ๋ก false๋ฅผ ๋ฐํํ๋ฉด ๋ฉ๋๋ค.
import java.util.*;
class Solution {
public boolean solution(int[] arr) {
int[] answer = new int[arr.length];
for (int i = 0; i < arr.length; i++) answer[i] = i+1;
Arrays.sort(arr);
return Arrays.equals(arr, answer);
}
}
sort() ์ ์๊ฐ ๋ณต์ก๋๋ O(nlogn)์ด๋ค.
๋ฌธ์ ์ค๋ช
์ ํ ์กฐ๊ฑด
์ ์ถ๋ ฅ ์
12345[5,4,3,2,1]import java.util.*;
class Solution {
public int[] solution(long n) {
List<Integer> list = new LinkedList<>();
while(n > 0) {
list.add((int)(n % 10);
n /= 10;
}
return list.stream().mapToInt(Integer::intValue).toArrays();
}
}