๐ ๋ฐฐ์ด
๐ ๋ฐฐ์ด(Array)์ด๋?
๋ฐฐ์ด์ CRUD๋ฅผ ํ ๋ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ผ๋ก ์ฌ์ฉ๋๋ ์๋ฃ๊ตฌ์กฐ์ด๋ค.
์์ฑํ ๋ ํฌ๊ธฐ๊ฐ ๊ฒฐ์ ๋๊ณ ๊ฐ ์๋ฆฌ์ ๋ํด ์ธ๋ฑ์ค ๋ฒํธ๊ฐ ๋ถ์ฌ๋๋ค. ์ธ๋ฑ์ค ๋ฒํธ๋ฅผ ํตํด ๋ฐฐ์ด ๋ด๋ถ์ ์๋ ์์๋ค์ ์ ๊ทผํ ์ ์๋ค.
์์ ๊ฐ์ด ๋ฐฐ์ด์ ์ฃผ์๋ฅผ ๋ํ๋ด๋ ์ธ๋ฑ์ค(index)์ ์์(elements)๋ก ๊ตฌ์ฑ๋์ด ์๋ค.
๋ฐฐ์ด์ ์ฅ์
๋ฐฐ์ด์ ํ์์ ๋ฐ๋ผ ๋ฐ๋ก ์์ฑํ์ฌ ์ฌ์ฉํ๊ธฐ ์ฉ์ดํ๋ค.
int[] numArr = { 1, 2, 3, 4, 5 };
์ ๊ฐ์ด ๋ฐฐ์ด์ ๋ฐ๋ก ์์ฑํ ์ ์๋ค๋๊ฒ ์ต๊ณ ์ฅ์ ์ด๋ค.
๊ทธ๋ฆฌ๊ณ ๋ฐฐ์ด์ด ์์ฉ๋์ด ์คํ์ด๋ ํ ๊ฐ์๊ฒ๋ค์ด ์กด์ฌํ๋ค๊ณ ๋ณผ ์ ์๊ธฐ ๋๋ฌธ์ ๋ฐฐ์ด์ ์ด๋ค ์๋ฃ๊ตฌ์กฐ์ ๊ธฐ์ด๊ฐ ๋ ์ ์๋ค.
๋ํ ์ํ๋ ๋ฐ์ดํฐ์ ๋ํด CRUD๋ฅผ ์ฝ๊ฒ ์ฒ๋ฆฌํ ์ ์์ผ๋ฉฐ ์ ๋ ฌํ๊ธฐ์ ์ฉ์ดํ๋ค๋ ์ฅ์ ์ ๊ฐ๋๋ค.
๋ฐฐ์ด์ ๋จ์
๋ฐฐ์ด์ ๋จ์ ์ ๋ฐ๋ก ์์ฑ ์ ํฌ๊ธฐ๊ฐ ๊ฒฐ์ ๋๊ธฐ ๋๋ฌธ์ ์ ์ฐํ์ง ๋ชปํ๋ค. ์ฆ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ ์ ์๋ ๋ฉ๋ชจ๋ฆฌ์ ํฌ๊ธฐ๊ฐ ๊ณ ์ ๋์ด ์์ผ๋ฉฐ ์ด๋ฅผ ๋์ ์ผ๋ก ๋ฐ๊ฟ ์ ์๋ค.
๋ํ ๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐํ๊ฑฐ๋ ์ญ์ ํ๋ ๋ฐฉ๋ฒ์ด ๋ค์ ๋นํจ์จ์ ์ด๋ค. ์๋ฅผ ๋ค์ด ์ ์ฌ์ง์ ๋ฐฐ์ด์์ 1๋ฒ์งธ์ 2๋ฒ์งธ ์ฌ์ด์ ์๋ก์ด ์์๋ฅผ ๋ฃ๋๋ค๊ณ ๊ฐ์ ํ๋ฉด, ๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ ๊ณ ์ ๋์ด ์๊ณ ์ ๋ ฅ๋ฐ์ ์์๋๋ก ๋ค์ด๊ฐ๊ธฐ ๋๋ฌธ์ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ์ฌ์ง์ ํด์ฃผ๊ณ ๋งจ ๋ค๋ก ๋ค์ด๊ฐ ์๋ก ์ ๋ ฅ๋ฐ์ ์์๋ฅผ 1๋ฒ์งธ์ 2๋ฒ์งธ ์ธ๋ฑ์ค ์ฌ์ด๊น์ง ๋น๊ฒจ์์ฃผ๋ ์์ ์ด ํ์ํ๋ค.
๋ฐฐ์ด ์ฌ์ฉ ์์
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] numArr = new int [5];
// ์ธ๋ฑ์ค์ ์ง์ ๊ฐ์ ํ ๋นํ๋ ๋ฐฉ๋ฒ
numArr[0] = 1;
numArr[1] = 2;
numArr[2] = 3;
numArr[3] = 4;
numArr[4] = 5;
System.out.println(Arrays.toString(numArr));
// for loop๋ก ๋ฐฐ์ด์ ์ํํ๋ฉฐ ํ ๋นํ๋ ๋ฐฉ๋ฒ
String[] strArr = new String [5];
for (int i = 0; i < strArr.length; i++) {
strArr[i] = Integer.toString(i+1);
}
System.out.println(Arrays.toString(strArr));
// ๊ฐ ์ญ์
numArr[0] = 0; // 0์ผ๋ก ์ด๊ธฐํ
// ๋๋
for (int i = 0; i < numArr.length; i++) {
numArr[i] = 0;
}
// fill ๋ฉ์๋ ์ฌ์ฉ
Arrays.fill(numArr, 0);
// Null ์ฐธ์กฐ ์ค์
numArr = null;
}
}
๐ ์ฐ๊ฒฐ ๋ฆฌ์คํธ(Linked List)
๐ ์ฐ๊ฒฐ ๋ฆฌ์คํธ(Linked List)๋?
์์ ์๊ฐํ ๋ฐฐ์ด๊ณผ ์คํ, ํ๋ ๋ฉ๋ชจ๋ฆฌ์ ์๋ ๋ฐ์ดํฐ์ ๋ฌผ๋ฆฌ์ ๋ฐฐ์น์ ์์กดํ๋ ์๋ฃ๊ตฌ์กฐ๋ผ๊ณ ๋ณผ ์ ์๋ค. ๋ฐ๋๋ก Linked List
๋ ๋ฉ๋ชจ๋ฆฌ์ ์๋ ๋ฐ์ดํฐ์ ๋ฌผ๋ฆฌ์ ๋ฐฐ์น์ ์์กด์ ์ด์ง ์๋ค(์ฌ์ฉํ์ง ์๋๋ค).
๋ฐฐ์ด์ index
๋ ํ/์คํ์ ์์น ๊ฐ๋
๋ณด๋ค ์ฐธ์กฐ ์์คํ
์ ์ฌ์ฉํ๋๋ฐ, ๋ด๋ถ์ ์๋ ๊ฐ ์์๋ค์ Node
๋ผ๋ ๊ฒ์ ์ ์ฅ๋๋ค.
์ด๋ ๋ค์ Node
์ฐ๊ฒฐ์ ๋ํ ํฌ์ธํฐ ๋๋ ์ฃผ์๊ฐ ํฌํจ๋ ๋ ๋ค๋ฅธ Node
์ ์ ์ฅ๋๋ค.
๋ฐ์ดํฐ๊ฐ ๋ค์ด๊ฐ๋ ๊ณต๊ฐ์ธ Data Field
(๋ฐ์ดํฐ ํ๋)์ ๋ค์ ๋
ธ๋๋ก ์ฐ๊ฒฐ๋๋ Link Field
(๋งํฌ ํ๋)๋ก ๊ตฌ์ฑ๋๋ฉฐ ์ด ์ ์ฒด๋ฅผ Node
๋ก ๋ณธ๋ค.
Node
๋ ์ต์ ๋ ๊ฐ์ง ์ ๋ณด๊ฐ ์ ์ ๋์ด์ผ ํ๋๋ฐ, ์ด๋ Node
์ ๊ฐ๊ณผ ๋ค์ Node
์ ๊ฐ์ด๋ค. ๊ฐ๊ฐ์ Node
๊ฐ ๋ค์ Node
๋ฅผ ์๊ณ ์ฐ๊ฒฐ๋์ด ์๊ธฐ ๋๋ฌธ์ ํ๋์ ๋ชจ์์ ๋ง๋ค์ด๋ผ ์ ์๋ ๊ฒ์ด๋ค.
๋น์ทํ ์ด๋ฆ์ ArrayList
๋ Node
๋ผ๋ ์ฒด๊ณ๋ก ์ด๋ฃจ์ด์ ธ์๊ธฐ ๋ณด๋ค ๋ฐฐ์ด๊ณผ ์ ์ฌํ๋ค๊ณ ๋ณด๋ฉด ๋๋ค.
์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ ๋ฐ์ดํฐ์ ์ถ๊ฐ/์ญ์ ์ ์ฌ๊ตฌ์ฑ์ ํ์ง ์์๋ ์์์ Node
๋ผ๋ฆฌ ๋ค์ ์ฐ๊ฒฐ๋๊ธฐ ๋๋ฌธ์ ๋งค์ฐ ํจ์จ์ ์ด๋ผ๊ณ ๋งํ ์ ์๋ค.
์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ์ฅ์
์ฐ์ ์๋ก์ด ์์๋ฅผ ์ถ๊ฐํ๊ฑฐ๋ ๊ธฐ์กด์ ์์๋ฅผ ์ญ์ ํ ๋ Node
๊ฐ ์์์ ์ฐ๊ฒฐ๋๊ธฐ ๋๋ฌธ์ ํจ์จ์ ์ด๋ค.
๋ฐฐ์ด์ฒ๋ผ ๋ฉ๋ชจ๋ฆฌ์ ์ฐ์์ ์ผ๋ก ์์นํ์ง ์์ผ๋ฉฐ CRUD๊ฐ ๊ตฌ์กฐ์ ์ฌ๊ตฌ์ฑ์ ํ์ง ์์๋ ๋๋ค.
๋ฐฐ์ด์ฒ๋ผ ํฌ๊ธฐ๊ฐ ์ ํ์ ์ด์ง ์๊ธฐ ๋๋ฌธ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋์ ์ผ๋ก ์ฌ์ฉํ์ฌ ๋์ฉ๋ ๋ฐ์ดํฐ ์ฒ๋ฆฌ๋ฅผ ํ ๋ ์ ์ฐํ๋ค.
์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ๋จ์
๋ฐฐ์ด๋ณด๋ค ๋ ๋ง์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฌ์ฉํ๋ค.
๊ฒ์ ์ ์ฒ์๋ถํฐ ๋๊น์ง ๋ฆฌ์คํธ๋ฅผ ์ํํ๋ฉฐ ์กฐํํ๊ธฐ ๋๋ฌธ์ ์ํ๋ ๊ฐ์ ๊ฐ์ ธ์ค๋๋ฐ ๋นํจ์จ์ ์ด๋ค.
์ด์ค ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ธ ๊ฒฝ์ฐ Node
๋ฅผ ๋ฐ๋ ๋ฐฉํฅ์ผ๋ก ๊ฒ์ํ ๋ ๋นํจ์จ์ ์ด๋ค.
์ฐ๊ฒฐ ๋ฆฌ์คํธ ์ฌ์ฉ ์์
import java.util.LinkedList;
public class Main {
public static void main(String[] args) {
// ์ฐ๊ฒฐ ๋ฆฌ์คํธ ์์ฑ, ์ด๊ธฐํ
LinkedList<Integer> list = new LinkedList<>();
// ๊ฐ ๋ฃ์ด์ฃผ๊ธฐ
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
// ์กฐํ
System.out.println(list);
// ๊ฐ ์ญ์ ํ๊ธฐ
list.remove(0); // 0๋ฒ์งธ ๊ฐ ์ญ์
System.out.println(list); // 2, 3, 4, 5
// ๊ฐ ์กฐํ
System.out.println(list.get(1)); // 1๋ฒ์งธ ๊ฐ ์ถ๋ ฅ : 3
}
}
'๊ธฐ์ ์คํ > CS' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋ฉ๋ชจ๋ฆฌ์ ๊ตฌ์กฐ (0) | 2022.11.17 |
---|---|
ํด๋์ค, ๊ฐ์ฒด, ์ธ์คํด์ค (0) | 2022.04.24 |
[์๋ฃ๊ตฌ์กฐ] ํด์ ํ ์ด๋ธ(Hash Table) (0) | 2022.02.18 |
[์๋ฃ๊ตฌ์กฐ] ์คํ(Stack)๊ณผ ํ(Queue) (3) | 2022.02.17 |