Swap(๊ตํ)
๋จผ์ ์๋์ ์ฝ๋๋ฅผ ๋ณด๊ณ a
์ b
๋ฅผ ๊ตํํด๋ด
์๋ค.
#include <iostream>
using namespace std;
int main()
{
// Swap
{
int a = 3;
int b = 2;
cout << a << " " << b << endl;
// TODO:
cout << a << " " << b << endl;
}
return 0;
}
์คํ ๊ฒฐ๊ณผ
3 2
3 2
โTODOโ ์๋ ์ด๋ค ์ฝ๋๊ฐ ๋ค์ด๊ฐ์ผ ํ ๊น์?
โ์ฐ๋ฆฌ๊ฐ ์ ์์ ์ฌ๊ณผ๐์ ๋ ๋ชฌ๐์ ๋ค๊ณ ์๋ค๊ณ ์๊ฐํด๋ด ์๋ค.โ
- ๊ทธ๋ผ ์ผ์์๋ ์ฌ๊ณผ๐์ ์ค๋ฅธ์์๋ ๋ ๋ชฌ๐์ ๋ค๊ณ ์์ ๋ ์ฌ๊ณผ๐์ ๋ ๋ชฌ๐์ ๋ฐ๊พธ๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผํ ๊น์?
- ์ ๋ ํ๋์ ์ ์๋ฅผ ๊ฐ์ ธ์ ๊ทธ ์ ์์ ์ฌ๊ณผ ๋๋ ๋ ๋ชฌ์ ์ ์ ์ฌ๋ ค๋๊ณ ๋น์ด์๋ ์์ผ๋ก ๊ณผ์ผ์ ์ฎ๊ธด ๋ค ์ ์์ ์๋ ๊ณผ์ผ์ ์ง์๊ฒ ์
๋๋ค.
- ๊ทธ๋ผ ์ฝ๋๋ ๋๊ฐ์ด ๋ง๋ค ์ ์์ง ์์๊น์?
- ์ ๋ ํ๋์ ์ ์๋ฅผ ๊ฐ์ ธ์ ๊ทธ ์ ์์ ์ฌ๊ณผ ๋๋ ๋ ๋ชฌ์ ์ ์ ์ฌ๋ ค๋๊ณ ๋น์ด์๋ ์์ผ๋ก ๊ณผ์ผ์ ์ฎ๊ธด ๋ค ์ ์์ ์๋ ๊ณผ์ผ์ ์ง์๊ฒ ์
๋๋ค.
#include <iostream>
using namespace std;
int main()
{
// Swap
{
int a = 3;
int b = 2;
cout << a << " " << b << endl;
// TODO:
// ๋จผ์ a๋ฅผ ์ฌ๊ณผ b๋ฅผ ๋ ๋ชฌ์ด๋ผ๊ณ ์๊ฐํ๊ณ ,
// temp๋ผ๋ ์ ์๋ฅผ ๋ง๋ค์ด๋ณด๊ฒ ์ต๋๋ค.
// ๊ทธ ์ ์์ a๋ผ๋ ์ฌ๊ณผ๋ฅผ ์ฌ๋ ค๋ณด๊ฒ ์ต๋๋ค.
int temp = a;
// ๊ทธ๋ผ ๋น์ด์๋ ์์ผ๋ก ๋ ๋ชฌ์ ์ฎ๊ธธ ์ ์๊ฒ๋์๋ค์.
// ๋น์ด์๋ ์์ผ๋ก ๋ ๋ชฌ์ ์ฎ๊ฒจ๋ณด๊ฒ ์ต๋๋ค.
// a๊ฐ ์๋ ์์ผ๋ก b๋ฅผ ์ฎ๊น๋๋ค.
a = b;
// ์ด๋ฒ์๋ b๊ฐ ์๋ ์์ด ๋น์๋ค์.
// b๊ฐ ์๋ ์์ผ๋ก ์ ์(temp)์ ์๋ a๋ฅผ ๋ค์ด๋ณด๊ฒ ์ต๋๋ค.
temp = a;
cout << a << " " << b << endl;
}
return 0;
}
์คํ ๊ฒฐ๊ณผ
3 2
2 3
- ์ ์์ ์๋ ์ฌ๊ณผ(3)๊ณผ ๋ ๋ชฌ(2)์ ์๋ฆฌ๊ฐ ๋ฐ๋์์ต๋๋ค
- โ์ฆ, ๊ตํ(Swap)์ด ์ด๋ฃจ์ด์ก์ต๋๋ค.โ
ํ์ง๋ง ํญ์ ์ด๋ ๊ฒ 3์ค์ ๋ผ์ธ์ธ
int temp = a;
a = b;
b = temp;
- ์ ์ฝ๋์ฒ๋ผ ์ฝ๋๋ฅผ ๋ง๋ค์ด์ ์ฌ์ฉํ ๊ฒฝ์ฐ์๋ ๋งค์ฐ ๋ง์ ๊ตํ(Swap)์ ํด์ผํ ๊ฒฝ์ฐ ์ฝ๋์ ์๋ ๋์ด๋๊ณ ๊ฐ๋ ์ฑ๋ ์ข์ง ์์ ๊ฒ ์ ๋๋ค.
โ๊ทธ๋ผ ์ด๋ฒ์๋ ํจ์๋ฅผ ์ด์ฉํด์ ๋ ์ซ์๋ฅผ ๊ตํํด๋ด ์๋ค.โ
๋จผ์ , ์ ๊ตํ ์ฝ๋๋ฅผ ๊ทธ๋๋ก ๊ฐ์ ธ๋ค๊ฐ ์ฌ์ฉํด๋ณผ๊น์?
void MySwap(int a, int b) {
int temp = a;
a = b;
b = temp;
}
- ์ด ๊ฒฝ์ฐ์๋ ๋ฆฌํด ๊ฐ์ด ์๊ธฐ ๋๋ฌธ์ ๋ถ๊ฐ๋ฅํฉ๋๋ค.
- ๋ง์ฝ ๋ฆฌํด๊ฐ์ด int ํ์ด๋ผ๊ณ ํด๋ ๋ฆฌํด์ 1๊ฐ๋ง ๊ฐ๋ฅํ๊ธฐ ๋๋ฌธ์ ์ด๋ ต์ต๋๋ค.
- cpp์ ๋ค๋ฅธ ๊ธฐ๋ฅ์ธ ๊ตฌ์กฐ์ฒด๋ ์ฌ๋ฌ ๊ธฐ๋ฅ์ ์ฌ์ฉํด์ผ ํ ๊ฒ์ ๋๋ค.
- ๋ง์ฝ ๋ฆฌํด๊ฐ์ด int ํ์ด๋ผ๊ณ ํด๋ ๋ฆฌํด์ 1๊ฐ๋ง ๊ฐ๋ฅํ๊ธฐ ๋๋ฌธ์ ์ด๋ ต์ต๋๋ค.
๊ทธ๋ฌ๋ฉด ์ด๋ป๊ฒ ํด์ผํ ๊น์?
- โC์ ํฌ์ธํฐ์ CPP์ ๋ ํผ๋ฐ์ค๋ฅผ ํ์ฉํ๋ฉด๋ฉ๋๋ค.โ
1. C์ ํฌ์ธํฐ ํ์ฉ
#include <iostream>
using namespace std;
void MySwapPtr(int* a, int* b) {
int temp = *a;
*a = *b;
*b = temp;
}
int main()
{
// Swap
{
int a = 3;
int b = 2;
cout << a << " " << b << endl;
MySwapPtr(&a, &b);
cout << a << " " << b << endl;
}
return 0;
}
์คํ ๊ฒฐ๊ณผ
3 2
2 3
์คํ ๊ฒฐ๊ณผ๋ ์ฌ๋ฐ๋ฅด๊ฒ ๋์์ต๋๋ค.
โC ์คํ์ผ์ ํฌ์ธํฐ ์ฌ์ฉ์ *(๋ณ)
์ ์ฌ์ฉํ๋ฉด ๋ฉ๋๋ค.โ
void MySwapPtr(int* a, int* b) {
int temp = *a;
*a = *b;
*b = temp;
}
- temp์ ๋จผ์ a์ ์ฃผ์๊ฐ์ ๋ฃ์ด ์ค๋๋ค.
- ์ดํ a์ ์ฃผ์๊ฐ์ b์ ์ฃผ์๊ฐ์ ๋ฃ์ด ์ค๋๋ค.
- b์ ์ฃผ์๊ฐ์๋ temp(a์ ์ฃผ์๊ฐ)์ ๋ฃ์ด์ค๋๋ค.
- ์ดํ a์ ์ฃผ์๊ฐ์ b์ ์ฃผ์๊ฐ์ ๋ฃ์ด ์ค๋๋ค.
โ์ด๋ ๊ฒ ๋๋ฉด ๊ฐ ์ฃผ์๊ฐ์ด ๊ตํ์ด ๋ฉ๋๋ค.โ
C ์คํ์ผ์ ๋จ์ ์ ์ ์ธ๊ณผ ํธ์ถ์์ ๋ํ๋ฉ๋๋ค.
- ์ ์ธ์์๋ ์์ ๊ฐ์ด
*
์ ๋ชจ๋ ๋ถ์ฌ์ค์ผ ํฉ๋๋ค. - ํธ์ถ์์๋ ์๋์ ๊ฐ์ด
&
๋ฅผ ๋ถ์ฌ์ค์ผ ํฉ๋๋ค.
MySwapPtr(&a, &b);
โํ์ง๋ง CPP ์คํ์ผ์ ๋ํผ๋ฐ์ค ๊ตํ์ ๋จ์ํฉ๋๋ค.โ
// ์ ์ธ์
void MySwapRef(int& a, int& b) {
int temp = a;
a = b;
b = temp;
}
// ํธ์ถ์
MySwapRef(a, b);
- ๋ด๋ถ ๊ตฌํ์ ๋๊ฐ์ง๋ง ๋ณ๋ค๋ฅธ ์ด๋ ธํ ์ด์ ์์ด ์ผ๋ฐ์ ์ธ ๋ณ์ ํ ๋น๊ณผ ๊ฐ์ด ํด์ฃผ๋ฉด ๋ํผ๋ฐ์ค ๋์ ๋๊ณ ๊ตํ์ด ์ด๋ฃจ์ด์ง๋ ๊ฒ์ ๋ณผ ์ ์์ต๋๋ค.
- ํธ์ถ์์๋ ์ด๋ ธํ ์ด์ ์ ๋ฐ๋ก ๋ถ์ผ ํ์์์ด ์ผ๋ฐ์ ์ธ ๋งค๊ฐ๋ณ์(parameter)๋ฅผ ๋ฃ์ด์ฃผ๋ฏ์ด ๋ฃ์ด์ฃผ๋ฉด ๋ฉ๋๋ค.
#include <iostream>
using namespace std;
void MySwapRef(int& a, int& b) {
int temp = a;
a = b;
b = temp;
}
int main()
{
// Swap
{
int a = 3;
int b = 2;
cout << a << " " << b << endl;
MySwapRef(a, b);
cout << a << " " << b << endl;
}
return 0;
}
์คํ ๊ฒฐ๊ณผ
3 2
2 3
โ์ด๋ฒ์๋ ๊ตํ์ ํ์ฉํด์ ์ ๋ ฌ์ ํด๋ณด๊ฒ ์ต๋๋ค.โ
- ๊ฐ๊ณผ ์๊ด ์์ด ํญ์ ์์ ๊ฐ์ด ๋จผ์ ์ถ๋ ฅ๋๊ฒ ํ๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผํ ๊น์?
- ์ฆ, ๋ ๊ฐ์ด ๊ฐ์ ๋๋ ์์๊ฐ ์๊ด์ด ์์ง๋ง ํฐ ๊ฐ์ด ๋จผ์ ์ถ๋ ฅ๋์ง ์๊ฒ ํด์ผํฉ๋๋ค.
๋จผ์ ๋ ๊ฐ์ด ๊ฐ์ง ์๊ฑฐ๋ ํฐ ๊ฐ์ด ๋จผ์ ์ถ๋ ฅ ๋์์ ๊ฒฝ์ฐ์ false๋ฅผ ์ถ๋ ฅํ๊ณ ๊ทธ์๋ ๋ฐ๋์ผ ๊ฒฝ์ฐ์๋ true๋ฅผ ์ถ๋ ฅํ๋ ์ฝ๋๋ฅผ ์์ฑํด๋ณด๊ฒ ์ต๋๋ค.
#include <iostream>
using namespace std;
// ์ ๋ ฌ(sorting)
int main() {
int arr[2];
// TODO:
for (int j = 0; j < 5; j++) {
for (int i = 0; i < 5; i++) {
arr[0] = i;
arr[1] = j;
cout << boolalpha;
cout << arr[0] << " " << arr[1] << " "
<< (arr[0] <= arr[1]) << endl;
}
}
return 0;
}
- ๋จผ์ ๋ฐฐ์ด์ ์ ์ธํฉ๋๋ค. ๋ฐฐ์ด์ ์์๊ฐ ์๊ธฐ ๋๋ฌธ์
๋๋ค.
- ๊ทธ๋ฆฌ๊ณ 2์ค for๋ฌธ์ ์ฌ์ฉํฉ๋๋ค. ์ฒซ ๋ฒ์งธ for๋ฌธ์ด 1๋ฒ ๋ ๋ ๋ ๋ฒ์งธ for๋ฌธ์ 5๋ฒ ๋๊ฒ๋ฉ๋๋ค.
- ๊ทธ๋ ๊ฒ ๊ฐ๊ฐ์ i์ j์ ๋ผ๋ ๋ณ์์ ์ด๋ฆ์ผ๋ก arr ๋ฐฐ์ด ์ธ๋ฑ์ค 0๋ฒ์งธ์ 1๋ฒ์งธ์ ๋ฃ์ด์ค๋๋ค.
- ๊ทธ๋ฆฌ๊ณ 2์ค for๋ฌธ์ ์ฌ์ฉํฉ๋๋ค. ์ฒซ ๋ฒ์งธ for๋ฌธ์ด 1๋ฒ ๋ ๋ ๋ ๋ฒ์งธ for๋ฌธ์ 5๋ฒ ๋๊ฒ๋ฉ๋๋ค.
์คํ ๊ฒฐ๊ณผ
0 0 true
1 0 false
2 0 false
3 0 false
4 0 false
0 1 true
1 1 true
2 1 false
3 1 false
4 1 false
0 2 true
1 2 true
2 2 true
3 2 false
4 2 false
0 3 true
1 3 true
2 3 true
3 3 true
4 3 false
0 4 true
1 4 true
2 4 true
3 4 true
4 4 true
- ์คํ ๊ฒฐ๊ณผ ๊ฐ์ด ์๊ฑฐ๋ ๊ฐ์ ๊ฐ์ด ์ธ๋ฑ์ค 0๋ฒ ์ฆ ์ค๋ฆ์ฐจ์์ผ ๊ฒฝ์ฐ์๋ true ์
๋๋ค.
- ๊ทธ์๋ ๋ฐ๋๋ก ํฐ ๊ฐ์ด ์ธ๋ฑ์ค 0๋ฒ ์ฆ ๋ด๋ฆผ์ฐจ์์ผ ๊ฒฝ์ฐ์๋ false ์ ๋๋ค.
โ์ด์ ๋ ๊ฐ์ ๋น๊ตํ์ฌ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋๋ ๊ฒ์ ํ์ธํ๋ ํจ์๋ฅผ ๋ง๋ค์์ผ๋ ์ด๋ฒ์๋ ์ค์ ์ ๋ ฌ์ ํด๋ณด๋๋กํ๊ฒ ์ต๋๋ค.โ
#include <iostream>
using namespace std;
bool CheckSorted(int a, int b) {
// TODO: ...
if (a <= b) {
return true;
} else {
return false;
}
}
// ์ ๋ ฌ(sorting)
int main() {
int arr[2];
// TODO:
for (int j = 0; j < 5; j++) {
for (int i = 0; i < 5; i++) {
arr[0] = i;
arr[1] = j;
// swap ์๊ฐ
if (arr[0] > arr[1]) {
swap(arr[0], arr[1]);
}
cout << boolalpha;
cout << arr[0] << " " << arr[1] << " "
<< (CheckSorted(arr[0], arr[1])) << endl;
}
}
return 0;
}
์คํ ๊ฒฐ๊ณผ
0 0 true
0 1 true
0 2 true
0 3 true
0 4 true
0 1 true
1 1 true
1 2 true
1 3 true
1 4 true
0 2 true
1 2 true
2 2 true
2 3 true
2 4 true
0 3 true
1 3 true
2 3 true
3 3 true
3 4 true
0 4 true
1 4 true
2 4 true
3 4 true
4 4 true
- CPP์๋
swap
์ด๋ผ๋ ํจ์๊ฐ ์์ต๋๋คswap
์ ์ฌ์ฉํ ๊ฒฝ์ฐ์๋ ๋งค๊ฐ๋ณ์๋ก ๋ฐ์ ๋ ๊ฐ์ ๋ฐ๊ฟ์ค๋๋ค.- ๋ฐ๋ผ์ ์์ ๊ฐ์ ์คํ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํฉ๋๋ค.