1๏ธโฃ Java์ ๋ฐฐ์ด.
1๏ธโฃ ๋ฐฐ์ด์ด๋ ๋ฌด์์ธ๊ฐ?
๋ฐฐ์ด(Array)์ ๋์ผํ ํ์ ์ ์ฌ๋ฌ ์์๋ฅผ ํ๋์ ๋ณ์๋ก ๊ด๋ฆฌํ ์ ์๊ฒ ํด์ฃผ๋ ์๋ฃ๊ตฌ์กฐ์ ๋๋ค.
๋ฐฐ์ด์ ์ฐ์๋ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ํ ๋น๋๋ฉฐ, ๊ฐ ์์๋ ์ธ๋ฑ์ค๋ฅผ ํตํด ์ ๊ทผํ ์ ์์ต๋๋ค.
2๏ธโฃ ๋ฐฐ์ด์ ์ ์ธ๊ณผ ์ด๊ธฐํ.
Java์์ ๋ฐฐ์ด์ ๋ค์๊ณผ ๊ฐ์ด ์ ์ธํ๊ณ ์ด๊ธฐํํ ์ ์์ต๋๋ค.
int[] array = new int[5]; // ํฌ๊ธฐ๊ฐ 5์ธ ์ ์ํ ๋ฐฐ์ด ์ ์ธ.
int[] array = {10, 20, 30, 40, 50}; // ์ด๊ธฐํ์ ๋์์ ๋ฐฐ์ด ์ ์ธ
3๏ธโฃ ๋ฐฐ์ด์ ์์์ ์ ๊ทผ.
๋ฐฐ์ด์ ๊ฐ ์์๋ ์ธ๋ฑ์ค๋ฅผ ํตํด ์ ๊ทผํ ์ ์์ผ๋ฉฐ, ์ธ๋ฑ์ค๋ 0๋ถํฐ ์์ํฉ๋๋ค.
int firstElement = array[0]; // element = 10, ์ฒซ ๋ฒ์งธ ์์์ ์ ๊ทผ
array[1] = 25; // [10, 25, 30, 40, 50], ๋ ๋ฒ์งธ ์์์ ๊ฐ 25๋ฅผ ์ ์ฅ
4๏ธโฃ ๋ฐฐ์ด์ ์๊ฐ ๋ณต์ก๋.
๋ฐฐ์ด์ ์๊ฐ ๋ณต์ก๋๋ ์ฐ์ฐ์ ์ข ๋ฅ์ ๋ฐ๋ผ ๋ค๋ฆ ๋๋ค.
์๋๋ ์ผ๋ฐ์ ์ธ ๋ฐฐ์ด ์ฐ์ฐ๊ณผ ๊ทธ ์๊ฐ ๋ณต์ก๋๋ฅผ ์ค๋ช ํ ๊ฒ์ ๋๋ค.
1. ์ ๊ทผ(Access)
- ํน์ ์ธ๋ฑ์ค์ ์์์ ์ ๊ทผํ๋ ์๊ฐ ๋ณต์ก๋๋ O(1)์
๋๋ค.
- ์ด์ : ๋ฐฐ์ด์ ์ฐ์๋ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ ์ฅ๋๋ฏ๋ก ์ธ๋ฑ์ค๋ฅผ ํตํด ๋ฐ๋ก ์ ๊ทผํ ์ ์๊ธฐ ๋๋ฌธ์ ๋๋ค.
// ์ ๊ทผ(Access)
int element = array[2];
// element = 30, time complexity = O(1)
// [10, 25, 30, 40, 50]
2. ํ์(Search)
- ๋ฐฐ์ด์์ ํน์ ๊ฐ์ ์ฐพ๋ ์๊ฐ ๋ณต์ก๋๋ O(n)์
๋๋ค.
- ์ด์ : ์ต์ ์ ๊ฒฝ์ฐ ๋ฐฐ์ด์ ๋ชจ๋ ์์๋ฅผ ๊ฒ์ฌํด์ผ ํ ์๋ ์๊ธฐ ๋๋ฌธ์ ๋๋ค.
boolean found = false;
int target = 30;
for (int i = 0; i < array.length; i++) {
if (array[i] == target) { // i = 2, array[i] = 30
found = true;
break;
}
}
// [10, 25, 30, 40, 50]
3. ์ฝ์ (Insertion)
- ๋ฐฐ์ด์ ๋์ ์์๋ฅผ ์ถ๊ฐํ๋ ์๊ฐ ๋ณต์ก๋๋ O(1)์ ๋๋ค.
- ๋ฐฐ์ด์ ํน์ ์์น์ ์์๋ฅผ ์ฝ์
ํ๋ ์๊ฐ ๋ณต์ก๋๋ O(n)์
๋๋ค.
- ์ด์ : ํน์ ์์น์ ์ฝ์ ํ๊ธฐ ์ํด์๋ ํด๋น ์์น ์ดํ์ ๋ชจ๋ ์์๋ฅผ ํ ์นธ์ฉ ๋ค๋ก ๋ฐ์ด์ผ ํ๊ธฐ ๋๋ฌธ์ ๋๋ค.
// ์ฝ์
(Insertion)
// ๋ฐฐ์ด ์ฝ์
์ index๊ฐ array.length๊ฐ ์๋๊ณ array.length - 1์ธ ์ด์ ๋
// array.length๋ ๋ฐฐ์ด์ ํฌ๊ธฐ, ์ฆ 5๋ฅผ ๋ํ๋ด๊ธฐ ๋๋ฌธ์
๋๋ค.
// index๋ 0๋ถํฐ ์์ํ๊ธฐ ๋๋ฌธ์ ๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ 5์ธ ๋ฐฐ์ด์ ๋ index๋ 4์
๋๋ค.
// ๋๋ฌธ์ array.length - 1์ ํด์ค๋๋ค.
array[array.length - 1] = 60; // ๋ฐฐ์ด ๋์ ์ฝ์
(O(1)), [10, 25, 30, 40, 60]
// ๋ฐฐ์ด ์ค๊ฐ์ ์ฝ์
ํ๋ ๋ฉ์๋
public static void insertion(int[] array, int index, int insertValue) {
// ๋ฐฐ์ด ์ค๊ฐ์ ์ฝ์
(O(n))
for (int i = array.length - 1; i > index; i--) {
array[i] = array[i - 1];
}
array[index] = insertValue;
System.out.println(Arrays.toString(array));
}
4. ์ญ์ (Deletion)
- ๋ฐฐ์ด์ ๋์์ ์์๋ฅผ ์ ๊ฑฐํ๋ ์๊ฐ ๋ณต์ก๋๋ O(1)์ ๋๋ค.
- ๋ฐฐ์ด์ ํน์ ์์น์ ์์๋ฅผ ์ ๊ฑฐํ๋ ์๊ฐ ๋ณต์ก๋๋ O(n)์
๋๋ค.
- ์ด์ : ํน์ ์์น์ ์์๋ฅผ ์ ๊ฑฐํ ํ์๋ ํด๋น ์์น ์ดํ์ ๋ชจ๋ ์์๋ฅผ ํ ์นธ์ฉ ์์ผ๋ก ๋น๊ฒจ์ผ ํ๊ธฐ ๋๋ฌธ์ ๋๋ค.
// ์ญ์ (Deletion)
array[array.length - 1] = 0; // ๋ฐฐ์ด์ ๋์์ ์ญ์ ((O(1)), [10, 25, 30, 77, 0]
System.out.println(Arrays.toString(array));
// ๋ฐฐ์ด ์ค๊ฐ์์ ์ญ์ ํ๋ ๋ฉ์๋
int deletionValue = deletion(array, 2);
System.out.println(deletionValue); // 30
// ๋ฐฐ์ด ์ค๊ฐ์ ์ญ์ ํ๋ ๋ฉ์๋
public static int deletion(int[] array, int index) {
// ๋ฐฐ์ด ์ค๊ฐ์ ์ญ์ (O(n))
int[] returnValue = new int[array.length];
for (int i = index, j = 0; i < array.length - 1 ; i++) {
returnValue[j] = array[i];
j++;
array[i] = array[i + 1];
}
array[array.length - 1] = 0; // ๋ง์ง๋ง ์์ ์ด๊ธฐํ.
int deletionValue = returnValue[0]; // ๋ฐฐ์ด์ ๋ฉ๋ชจ๋ฆฌ์์ ์ง์ฐ๊ธฐ
returnValue = null;
return deletionValue;
}
5๏ธโฃ ๋ฐฐ์ด์ ์ฅ์ ๊ณผ ๋จ์ .
์ฅ์ .
- ๋น ๋ฅธ ์ ๊ทผ ์๋ : ์ธ๋ฑ์ค๋ฅผ ํตํด O(1) ์๊ฐ์ ์์๋ฅผ ์ ๊ทผํ ์ ์์ต๋๋ค.
- ๋ฉ๋ชจ๋ฆฌ ํจ์จ : ์ฐ์๋ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ฌ์ฉํ๋ฏ๋ก ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ์ด ํจ์จ์ ์ ๋๋ค.
๋จ์ .
- ๊ณ ์ ๋ ํฌ๊ธฐ : ๋ฐฐ์ด์ ํฌ๊ธฐ๋ ์ ์ธ ์์ ๊ณ ์ ๋๋ฏ๋ก, ์คํ ์ค์ ํฌ๊ธฐ๋ฅผ ๋ณ๊ฒฝํ ์ ์์ต๋๋ค.
- ์ฝ์ ๋ฐ ์ญ์ ์ ๋นํจ์จ์ฑ : ๋ฐฐ์ด ์ค๊ฐ์ ์์๋ฅผ ์ฝ์ ํ๊ฑฐ๋ ์ญ์ ํ ๋ O(n)์ ์๊ฐ์ด ์์๋ฉ๋๋ค.
- ์ฐ์๋ ๋ฉ๋ชจ๋ฆฌ ํ ๋น ํ์ : ํฐ ๋ฐฐ์ด์ ์ฌ์ฉํ ๋๋ ์ฐ์๋ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ด ํ์ํ์ฌ ๋ฉ๋ชจ๋ฆฌ ํ ๋น์ ์ ํ์ด ์์ ์ ์์ต๋๋ค.
๋ฐฐ์ด์ ์ด๋ฌํ ํน์ฑ๋ค๋ก ์ธํด ๋น ๋ฅธ ์ ๊ทผ์ด ํ์ํ ์ํฉ์์๋ ๋งค์ฐ ์ ์ฉํ์ง๋ง, ์ฝ์ ๋ฐ ์ญ์ ๊ฐ ๋น๋ฒํ ์ผ์ด๋๋ ๊ฒฝ์ฐ์๋ ๋นํจ์จ์ ์ผ ์ ์์ต๋๋ค.
๋ฐ๋ผ์ ์ํฉ์ ๋ง๊ฒ ์ ์ ํ ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ ํํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค.