๐ ๋ค์ด๊ฐ๋ฉฐ
๋ณ์๋ฅผ ์ฌ๋ฌ ๊ฐ ์ ์ธํ๋ฉด ๊ด๋ฆฌ๊ฐ ์ด๋ ต๋ค. ์ด ์ฌ๋ฌ ์ ์ฅ ๊ณต๊ฐ์ ํ๋์ ์ด๋ฆ์ผ๋ก ๋ฌถ๋ ๊ฒ์ด ๋ฐฐ์ด(array)์ด๋ค. C์์๋ ๋ดค์ง๋ง, ์๋ฐ์ ๋ฐฐ์ด์ new๋ก Heap ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น๋๋ค๋ ํน์ง์ด ์๋ค.
๋ฐฐ์ด = ์ ์ฅ ๊ณต๊ฐ์ ๋์ด
- ์ฌ๋ฌ ๋ณ์๋ฅผ ํ๋์ ์ด๋ฆ์ผ๋ก ๋ฌถ์ด ๊ด๋ฆฌ๊ฐ ํธํ๋ค.
- ๊ท์น์ฑ ์๋ ๊ฐ์ ๊ท์น์ฑ(์ธ๋ฑ์ค)์ ๋ถ์ฌํ๋ค.
1. ๋ฐฐ์ด์ ์ ์ธ
1
2
3
4
| ์๋ฃํ[] ๋ฐฐ์ด๋ช
= {๊ฐ1, ๊ฐ2, ๊ฐ3, ...}; // ๊ฐ์ผ๋ก ์ด๊ธฐํ
์๋ฃํ[] ๋ฐฐ์ด๋ช
= new ์๋ฃํ[์นธ์]; // ํฌ๊ธฐ๋ก ์ ์ธ
์๋ฃํ[] ๋ฐฐ์ด๋ช
;
๋ฐฐ์ด๋ช
= new ์๋ฃํ[์นธ์]; // ์ ์ธ๊ณผ ํ ๋น ๋ถ๋ฆฌ
|
C์ ๋ค๋ฅธ ๋ ๊ฐ์ง ํฌ์ธํธ๊ฐ ์๋ค.
| ํญ๋ชฉ | C | Java |
|---|
| ๋๊ดํธ ์์น | ์๋ฃํ ๋ฐฐ์ด๋ช
[] | ์๋ฃํ[] ๋ฐฐ์ด๋ช
|
| ๋ฉ๋ชจ๋ฆฌ | ์คํ ๋ฑ | new๋ก Heap์ ํ ๋น |
๐ก new๋ Heap ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅํ๋ ์ฐ์ฐ์๋ค. ๊ทธ๋ ๋ค๋ฉด { }๋ง ์ฐ๋ฉด Heap์ ์ ๋ค์ด๊ฐ๊น? ์๋๋ค. ์ค๊ดํธ๋ new๋ฅผ ์๋ตํ ๊ฒ๋ฟ์ด๋ค. ๋ฐ๋ผ์ ์๋ฐ์ ๋ฐฐ์ด์ ๋ชจ๋ Heap์ ๋ค์ด๊ฐ๋ ๋์ ๋ฐฐ์ด์ด๋ค.
2. ๋ฐฐ์ด์ ๊ธธ์ด(length)์ ์ถ๋ ฅ
๋ฐฐ์ด ์ ์ธ ์ ๊ธธ์ด๊ฐ length ์์์ ๋ด๊ธด๋ค. ๋ฐฐ์ด๋ช
.length๋ก ์ฌ์ฉํ๋ค.
1
2
3
4
5
6
7
8
9
10
| int[] arData = {3, 4, 6, 7};
System.out.println(arData); // ์ฃผ์๊ฐ (arData[0]์ ์ฃผ์)
System.out.println(arData[0]); // 3 (์ฒซ ๋ฒ์งธ ๊ฐ)
System.out.println(arData[arData.length - 1]); // 7 (๋ง์ง๋ง ์นธ)
System.out.println(arData.length); // 4 (๊ธธ์ด)
for (int i = 0; i < arData.length; i++) {
System.out.println(arData[i]);
}
|
| ์ฝ๋ | ๊ฒฐ๊ณผ | ์๋ฏธ |
|---|
arData | ์ด์ํ ๊ฐ | arData[0]์ ์ฃผ์๊ฐ |
arData[0] | 3 | ์ฒซ ๋ฒ์งธ ๊ฐ |
arData.length - 1 | 3(์ธ๋ฑ์ค) | ๋ง์ง๋ง ์นธ์ ๊ฐ๋ฆฌํด |
arData.length | 4 | ๋ฐฐ์ด ๊ธธ์ด |
index๊ฐ 0๋ถํฐ ์์ํ๋ ์ด์
๋ฐฐ์ด์ ์์ ์ฃผ์๋ฅผ ๊ฐ๊ณ , ๋ค์ ์นธ์ผ๋ก ๊ฐ ๋๋ง๋ค ์์ ์ฃผ์์ +1์ฉ ๋ํ๋ค. ์ฒซ ๋ฒ์งธ ๋ฐฉ์ ์์์ฃผ์ + 0์ด๊ณ , ์ด 0์ด ๊ทธ๋๋ก ์ธ๋ฑ์ค๊ฐ ๋๋ค. ๊ทธ๋์ ์ฒซ ์นธ์ ์ธ๋ฑ์ค๋ 0์ด๋ค. (for๋ฌธ์ i=0์ด ์ฌ๊ธฐ์ ์ ๋ํ๋ค.)
3. ๋ฐฐ์ด์ ๊ฐ ์
๋ ฅํ๊ธฐ
1
2
3
4
5
6
7
8
| int[] arData = new int[5];
for (int i = 0; i < arData.length; i++) {
arData[i] = 5 - i; // 5, 4, 3, 2, 1
}
for (int i = 0; i < arData.length; i++) {
System.out.println(arData[i]);
}
|
4. ์ค์ต
โ 100~1 ๋์ ํฉ
1
2
3
4
5
6
7
| int[] arData = new int[100];
int sum = 0;
for (int i = 0; i < arData.length; i++) {
arData[i] = 100 - i; // 100, 99, ..., 1
sum += arData[i]; // ๋์
}
System.out.println(sum);
|
โก ์ต๋๊ฐยท์ต์๊ฐ
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| int[] arData = new int[5];
Scanner sc = new Scanner(System.in);
int max = 0, min = 0;
for (int i = 0; i < arData.length; i++) {
System.out.print((i + 1) + "๋ฒ์งธ ์ ์ : ");
arData[i] = sc.nextInt(); // 5๊ฐ ์
๋ ฅ๋ฐ๊ธฐ
}
max = arData[0]; // ์ฒซ ๊ฐ์ ํ๋ณด๋ก
min = arData[0];
for (int i = 1; i < arData.length; i++) { // ์ธ๋ฑ์ค 1๋ถํฐ ๋น๊ต
if (max < arData[i]) max = arData[i];
if (min > arData[i]) min = arData[i];
}
System.out.println("์ต๋๊ฐ : " + max);
System.out.println("์ต์๊ฐ : " + min);
|
๐ก for๊ฐ 1๋ถํฐ ์์ํ๋ ์ด์ : ์ฒซ ๋ฒ์งธ ๊ฐ(arData[0])์ ์ด๋ฏธ max/min์ ๋ฃ์์ผ๋ฏ๋ก, ์ธ๋ฑ์ค 1๋ถํฐ ๋น๊ตํ๋ฉด ๋๋ค.
โข ์ ์๋ฅผ ํ๊ธ๋ก ๋ณํ (์: 1024 โ ์ผ๊ณต์ด์ฌ)
1
2
3
4
5
6
7
8
9
10
11
12
13
| String hangle = "๊ณต์ผ์ด์ผ์ฌ์ค์ก์น ํ๊ตฌ";
Scanner sc = new Scanner(System.in);
int num = 0;
String result = "";
System.out.print("์ ์ ์
๋ ฅ : ");
num = sc.nextInt();
while (num != 0) {
result = hangle.charAt(num % 10) + result; // ๋ค์์๋ถํฐ ์์ผ๋ก ๋ถ์
num /= 10;
}
System.out.println(result);
|
๋์ ์๋ฆฌ๋ฅผ ๋ฏ์ด๋ณด๋ฉด ์ด๋ ๋ค.
| ์์ | ์ค๋ช
|
|---|
charAt(i) | ๋ฌธ์์ด์ ํด๋์ค๋ผ [i] ๋์ charAt(i)๋ก ๋ฌธ์ ์ ๊ทผ |
num % 10 | ์ผ์ ์๋ฆฌ ์ถ์ถ (1024 โ 4 โ charAt(4) = โ์ฌโ) |
+ result | ์์ ๋ถ์ฌ ์์๋ฅผ ๋ง์ถค (์ ๊ทธ๋ฌ๋ฉด โ์ฌ์ด๊ณต์ผโ) |
num /= 10 | ์๋ฆฌ ํ๋ ์ ๊ฑฐ (1024 โ 102), num์ด 0์ด๋ฉด ์ข
๋ฃ |
๐ ์ ๋ฆฌ
1
2
3
4
5
6
| Java ๋ฐฐ์ด
โโ ์ ์ธ ์๋ฃํ[] ์ด๋ฆ = {...} ๋๋ new ์๋ฃํ[n]
โโ ๋ฉ๋ชจ๋ฆฌ new๋ก Heap์ ํ ๋น (๋์ ๋ฐฐ์ด)
โโ length ๋ฐฐ์ด๋ช
.length (๋ง์ง๋ง ์นธ = length-1)
โโ ์ธ๋ฑ์ค 0๋ถํฐ ์์ (์์์ฃผ์ + 0)
โโ ํ์ฉ ๋์ ํฉ, ์ต๋/์ต์, charAt๋ก ๋ฌธ์ ์ ๊ทผ
|
| ๊ฐ๋
| ํ ์ค ์ ์ |
|---|
| length | ๋ฐฐ์ด ๊ธธ์ด๋ฅผ ๋ด๋ ์์ |
| new | Heap ๋ฉ๋ชจ๋ฆฌ์ ๋ฐฐ์ด์ ํ ๋นํ๋ ์ฐ์ฐ์ |
| charAt(i) | ๋ฌธ์์ด์ i๋ฒ์งธ ๋ฌธ์์ ์ ๊ทผ |
๋ฐฐ์ด์ ์ฌ๋ฌ ์ ์ฅ ๊ณต๊ฐ์ ํ๋๋ก ๋ฌถ๋ ๊ธฐ๋ณธ ์๋ฃ๊ตฌ์กฐ๋ค. ์๋ฐ์์๋ new๋ก Heap์ ํ ๋น๋๋ค๋ ์ , ๊ทธ๋ฆฌ๊ณ ์ธ๋ฑ์ค๊ฐ 0๋ถํฐ ์์ํ๋ ์ด์ (์์ ์ฃผ์ + 0)๋ฅผ ์ดํดํ๋ฉด ์์ฉ ๋ฌธ์ ๋ ์ฐจ๊ทผ์ฐจ๊ทผ ํ ์ ์๋ค.
Comments powered by Disqus.