๐ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด - Array
๐ซ ๋ฐฐ์ด ํ์
๋์ง์(homogeneous) ๋ฐ์ดํฐ ์์๋ค์ ์ฐ์๋ ๋ฐ์ดํฐ ๋ชจ์
๋ฐฐ์ด์ ์์์ ๋ํ ์ ๊ทผ์ ์ฒจ์๋ฅผ ์ด์ฉ
์ฒจ์์ ๋ณ์๊ฐ ์์ ๊ฒฝ์ฐ ์ค์๊ฐ ์ฐ์ฐ์ด ์ถ๊ฐ๋ก ์๊ตฌ
๋๋ถ๋ถ์ ์ธ์ด์์ ๋ฐฐ์ด์ด ์ ๊ณต๋๋ฉฐ, ๋ฐฐ์ด์ ๋ชจ๋ ์์๋ค์ ๋์ผํ ํ์ ์ ์ํด์ผ ํ๋ค.
@ Python,ย ๋์ ๋ฐฐ์ด์ ํน์ฑ์ ๊ฐ์ง ๋์์ฒด๋ฅผ โListโ๋ผ๋ ์ด๋ฆ์ผ๋ก ์ ๊ณตํ๋ค.
๐ซง ์ค๊ณ ๊ณ ๋ ค์ฌํญ
์ด๋ค ํ์
์ด ์ฒจ์์ ๋ํด ์ ๋ฒํ๊ฐ?
์ฒจ์ ์์ ๋ํ ๋ฒ์๊ฐ ๊ฒ์ฌ๋๋๊ฐ? (C, ๊ฒ์ฌ ์ํจ)
์ฒจ์ ๋ฒ์๋ ์ธ์ ๋ฐ์ธ๋ฉ ๋๋๊ฐ?
๋ฐฐ์ด ํ ๋น์ ์ธ์ ์ผ์ด๋๋๊ฐ?
๋ฐฐ์ด์ ๊ธฐ์ต ๊ณต๊ฐ์ด ํ ๋น๋ ๋ ์ด๊ธฐํ๋ฅผ ํ ์ ์๋๊ฐ?
์ฌ๋ผ์ด์ค ์ ๋ฌด์ ํํ
๐ซง ๋ฐฐ์ด๊ณผ ์์ธ
๋ฐฐ์ด์ ํน์ ์์๋ ๋ฐฐ์ด์ ์ด๋ฆ๊ณผ ์ฒจ์(subscript) ํน์ ์์ธ(index)์ ์ํด ์ฐธ์กฐ
๋ฐฐ์ด์ด๋ฆ(์ฒจ์/์์ธ - Subscript/Index) โ ํน์ ์์
์์ ์ฐธ์กฐ๋ฅผ ์ํด ๋๊ดํธ []
๋ฅผ ์ฌ์ฉ
์ฒจ์๋ ๋ณดํต ์ ์ ํ์
์ ์ฌ์ฉ
์ฒจ์์ ๋ฒ์ ์ค๋ฅ๋ ํ๋ก๊ทธ๋จ์ ์์ฃผ ๋ํ๋๋ ํ์, ๋ฒ์ ๊ฒ์ฌ๋ฅผ ์ ๊ณตํ๋ ๊ฒ์ ์ธ์ด์ ์ ๋ขฐ์ฑ์ ํฅ์
@ C, ๋ฐฐ์ด ๋ฒ์ ๊ฒ์ฌ๋ฅผ ํ์ง ์์
@ Java, Python : ๋ฐฐ์ด ๋ฒ์๋ฅผ ๋์ด์๋ ๊ฒฝ์ฐ ์คํ์๊ฐ์ ์ค๋ฅ๋ฅผ ๋ฐ์
๐ซง ์ฒจ์ ๋ฐ์ธ๋ฉ๊ณผ ๋ฐฐ์ด ์ ํ
- ๋ฐฐ์ด ๋ณ์์ ๋ํ ์ฒจ์ ๋ฐ์ธ๋ฉ์ ๋ณดํต ์ ์ ์ด๋, ์ฒจ์ ๊ฐ ๋ฒ์๋ ๋๋๋ก ๋์ ์ผ๋ก ๋ฐ์ธ๋ฉ
- ์ฒจ์ ๋ฒ์์ ํํ์ 0์ผ๋ก ๊ณ ์ @
- ๋ฐฐ์ด์ ์ข
๋ฅ (์ฒจ์ ๊ฐ ๋ฒ์์ ๋ํ ๋ฐ์ธ๋ฉ, ๊ธฐ์ต๊ณต๊ฐ ๋ฐ์ธ๋ฉ, ๊ธฐ์ต๊ณต๊ฐ์ ํ ๋น ์ฅ์์ ๋ฐ๋ฅธ)
- ์ ์ ๋ฐฐ์ด
- ๊ณ ์ ์คํ-๋์ ๋ฐฐ์ด
- ์คํ-๋์ ๋ฐฐ์ด
- ๊ณ ์ ํ-๋์ ๋ฐฐ์ด
- ํ-๋์ ๋ฐฐ์ด
๋์ : ๋ฐฐ์ด์ด ํน์ ์ํฉ์ ํ ๋น๋จ (i.e. ์ ์ธ ํฌํจ๋ ํจ์๊ฐ ํธ์ถ๋ ๋)
1. ์ ์ ๋ฐฐ์ด
1
2
3
4
5
int tempA[5] = { 1, 2, 3, 4, 5 };
void main()
{
static int tempB[5] = { 1, 2, 3, 4, 5 };
}
- ์ฒจ์ ๋ฒ์๊ฐ ์ ์ ์ผ๋ก ๋ฐ์ธ๋ฉ (์ปดํ์ผ ํ์์)
- ๊ธฐ์ต๊ณต๊ฐ ํ ๋น์ด ์ ์ ์ผ๋ก (ํ๋ก๊ทธ๋จ์ด ๋๋ ๋ ๊น์ง) ์ด๋ฃจ์ด์ง๋ค.
- ๋์ ์ผ๋ก ํ ๋น์ด๋ ํ์๊ฐ ๋์ง ์์ผ๋ฏ๋ก ํจ์จ์ด ์ข์ง๋ง, ๊ธฐ์ต๊ณต๊ฐ์ด ํ๋ก๊ทธ๋จ์ ์คํ์๊ฐ ์ ์ฒด์ ๊ณ ์ ๋๋ค.
2. ๊ณ ์ ์คํ-๋์ ๋ฐฐ์ด
1
2
3
4
void main()
{
int temp[5] = { 1, 2, 3, 4, 5 };
}
์ฒจ์ ๋ฒ์๊ฐ ์ ์ ์ผ๋ก ๋ฐ์ธ๋ฉ ๋์ง๋ง, ํ ๋น์ด ์คํ์๊ฐ์ค์ ์ผ์ด๋๋ค.
๊ธฐ์ต๊ณต๊ฐ์ ํจ์จ์ฑ์ด ์ข๋ค.
3. ์คํ-๋์ ๋ฐฐ์ด
1
2
3
4
5
6
7
8
9
10
void main()
{
int n;
scanf("%d", &n);
int temp[n];
for (int i = 0; i < n; i++)
temp[i] = i;
}
- ์ฒจ์ ๋ฒ์์ ๊ธฐ์ต๊ณต๊ฐ ํ ๋น ๋ชจ๋๊ฐ ์คํ์๊ฐ์ค์ ๋ฐ์ธ๋ฉ๋๋ ๋ฐฐ์ด
- Variable Length Array๋ C99, C11์์ ์ง์ํ๋ ํ์ค C์์๋ ์ง์ํ์ง ์์
- ์ผ๋จ ์ฒจ์ ๋ฒ์๊ฐ ๋ฐ์ธ๋ฉ๋๊ณ ๊ธฐ์ต๊ณต๊ฐ์ด ํ ๋น๋๋ฉด ์ด ๋ฐ์ธ๋ฉ์ ๋ณ์์ ์กด์ ๊ธฐ๊ฐ์ ๊ณ ์
- ์ฅ์ : ๋ฐฐ์ด์ ํฌ๊ธฐ๋ ๊ทธ ๋ฐฐ์ด์ด ์ฌ์ฉ๋๊ธฐ ์ ๊น์ง ๋ชฐ๋ผ๋ ๋๋ฏ๋ก ์ ์ฐ์ฑ์ด ์ข๋ค
- ๋จ์ : ์ด๋ฅผ ์ํด ๋ง์ ์ฝ๋๋ฅผ ์์ฑํ๋ฉฐ, ์๋๊ฐ ๋๋ ค์ง๊ณ ๋ถ์ํ ์ฝ๋๋ฅผ ์์ฑํ ์ ์๋ค.
4. ๊ณ ์ ํ-๋์ ๋ฐฐ์ด
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void main()
{
int n;
scanf("%d", &n);
int *temp = NULL;
temp = (int *)malloc(sizeof(int) * n);
for (int i = 0; i < n; i++)
temp[i] = i;
free(temp);
temp = NULL;
}
1
2
3
4
5
6
public static void main(String[] args)
{
int[] nums = {0, 1, 2, 3, 4, 5};
for(int i=0; i < nums.length; i++)
System.out.println(nums[i]);
}
- ์ฒจ์ ๋ฒ์์ ๊ธฐ์ต๊ณต๊ฐ์ ๋ฐ์ธ๋ฉ์ด ๊ธฐ์ต๊ณต๊ฐ์ด ํ ๋น๋ ํ์ ๊ณ ์ ๋จ
- ์ฒจ์ ๋ฒ์์ ๊ธฐ์ต๊ณต๊ฐ์ ๋ํ ๋ฐ์ธ๋ฉ์ด ์ฌ์ฉ์๊ฐ ์์ฒญํ ๋ ๋ฐ์
- ๊ธฐ์ต ๊ณต๊ฐ์ด ์คํ์ด ์๋ ํ์ ํ ๋น
- ์ฅ์ : ์ ์ฐ์ฑ
- ๋จ์ : ์คํ๋ณด๋ค ๋๋ฆผ
5. ํ-๋์ ๋ฐฐ์ด
1
2
3
4
5
6
7
8
9
10
11
12
13
nums = [1, 2, 3, 4, 5]
for item in nums:
print(item)
nums.append(6)
nums.append(7)
nums.append(8)
nums.append(9)
nums.append(10)
for item in nums:
print(item)
- ์ฒจ์ ๋ฒ์์ ๊ธฐ์ต๊ณต๊ฐ์ ํ ๋น์ด ๋์ ์ผ๋ก ์ผ์ด๋๋ฉฐ ๋ฐฐ์ด์ ์กด์๊ธฐ๊ฐ์ ๋ฐ๋์ ์์
- ์ฅ์ : ์ ์ฐ์ฑ์ด ์ข์
- ๋จ์ : ํ ๋น๊ณผ ํ์์ ์๊ฐ์ด ๊ธธ๋ค
๐ซง ๋ฐฐ์ด ์ด๊ธฐํ
๋ฐฐ์ด์ด ๊ธฐ์ต๊ณต๊ฐ์ ํ ๋น๋๋ ์์ ์ ๊ทธ ๋ฐฐ์ด์ ์ด๊ธฐํ ํ ์ ์๋ ์๋จ์ ์ ๊ณต
- ๋ฐฐ์ด์ ์ด๊ธฐํ ํ์ฉ
- ๊ฐ์ฅ ์ข์ธก ์์์ ํฌ๊ธฐ๋ ์๋ต ๊ฐ๋ฅ, ์ด ๊ฒฝ์ฐ ์ปดํ์ผ๋ฌ๊ฐ ํฌ๊ธฐ๋ฅผ ์ค์
- ์๋ฌต์ ์ค์ ์ด๋ฏ๋ก ์ค์๋ก ํญ๋ชฉ์ ๋นผ๋ฒ๋ฆด ์ ์์
- int list[] = {4, 5, 7, 8};
- char name[] = โfreddieโ;ย ย // name๋ฐฐ์ด์ ํฌ๊ธฐ๋?
- charย *names[] = {โBobโ, โJakeโ, โDarcieโ};
- ๊ฐ์ฅ ์ข์ธก ์์์ ํฌ๊ธฐ๋ ์๋ต ๊ฐ๋ฅ, ์ด ๊ฒฝ์ฐ ์ปดํ์ผ๋ฌ๊ฐ ํฌ๊ธฐ๋ฅผ ์ค์
๐ซง ๋ฐฐ์ด ์ฐ์ฐ
๋ฐฐ์ด ์ฐ์ฐ์ ๋ฐฐ์ด ๋จ์๋ก ์ฐ์ฐ์ ์ํํ๋ ์ฐ์ฐ
๋ฐฐ์ , ์ ํฉ, ๋น๊ต, ์ฌ๋ผ์ด์ค ๋ฑ
C์ ๊ฒฝ์ฐ ๋ฐฐ์ด ์ฐ์ฐ์ ์ ๊ณตํ์ง ์์ -> ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ํตํด ํ์ํ ๊ธฐ๋ฅ ์ฌ์ฉ
Java, C++, C#์ ๋ฐฐ์ด์ด ๊ฐ์ฒด๋ก ์ ๊ณต๋๋ฉฐ ๋ฉ์๋๋ก ์ํ
Python์ ๋ฆฌ์คํธ ํํ์ ์์๋ฅผ ์ ๊ณตํ๋ฉฐ ์ด์ง์ ์ธ ์์๋ฅผ ํฌํจํ ์ ์์
- ๋ฐฐ์ , ์ ํฉ(+), ์์ ๋ฉค๋ฒ์ฝ(in), ๋์ผ์ฑ ๋น๊ต(is), ๋๋ฑ์ฑ ๋น๊ต(==)
@ APL : ๊ฐ๋ ฅํ ๋ฐฐ์ด ์ฒ๋ฆฌ ์ธ์ด
๐ซง ๋ฐฐ์ด๊ณผ ์ฌ๋ผ์ด์ค
์ฌ๋ผ์ด์ค๋ ๋ฐฐ์ด์ ์ด๋ค ๋ถ๋ถ ๊ตฌ์กฐ(substructure)์ด๋ค.
Python, Ruby, Perl ๋ฑ์ ์ธ์ด์์ ๋ฐฐ์ด์ ์ฌ๋ผ์ด์ค ์ฐ์ฐ์ ์ ๊ณต
1
2
3
4
5
6
7
nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(nums[0:7])
print(nums[2:])
print(nums[:6])
print(nums[::2])
print(nums[1::2])
๐ซง ํ๊ฐ
FORTRAN I์์ ์๊ฐ๋ ํ ๋ฐฐ์ด์ ๊ฑฐ์ ๋ชจ๋ ์ธ์ด์ ํฌํจ ๋จ
๋ชจ๋ ์์ ํ์
์ ์ฒจ์๋ก ํ์ฉํ๊ฑฐ๋, ์ฌ๋ผ์ด์ค ์ฐ์ฐ๋ฑ์ ์ง๋ณด๊ฐ ์์์
ํนํ ์ต๊ทผ ์ฐ์ ๋ฐฐ์ด๋ก ํฅ์๋ ํน์ง์ ์ ๊ณต
๐ซ ์ฐ์ ๋ฐฐ์ด - Associative array
์์ ๊ฐ์์ ๋์ผํ ๊ฐ์์ ๊ฐ(ํค)๋ค๋ก ์ธ๋ฑ์ฑ๋๋, ์์๋ฅผ ๊ฐ์ง ์๋ ๋ฐ์ดํฐ ์์์ ๋ชจ์
ํค(key)-๊ฐ(value) ๊ตฌ์กฐ
- ๊ตฌ์กฐ์ ์ฐ์
- ๊ตฌํ์์ ์์๋ค์ด ํด์(hash) ํจ์๋ก ์ ์ฅ๋๊ณ ์ธ์ถ๋จ
- ์ฅ์ (vs ๋ฐฐ์ด)
- ๊ฐ๋ ์ฑ๊ณผ ์์ฑ๋ ฅ์ ๋์ธ๋ค.
- (ํด์ ํจ๋ฅผ ์จ์) ์์๋ค์ ์ ๊ทผ ์๋๊ฐ ๋น ๋ฅด๋ค.
- ๋ชจ๋ ์์๋ค์ ํ๋์ฉ ์ฒ๋ฆฌํด์ผํ๋ ๊ฒฝ์ฐ ๋ฐฐ์ด์ด ํจ์จ์ ์
- Python : ๊ธฐ๋ณธ ๋ฐ์ดํฐ, ์ฌ์ (dictionary)
- ํค(key)๋ hashable ํด์ผํ๋ค. โ immutableํ ๊ฐ์ด์ด์ผ ํจ
- ํค์ ๊ฐ์ฌ์ด๋ ์ฝ๋ก (:)์ผ๋ก ๊ตฌ๋ถ