๐ฆ 3. Binary Search & Bitwise Operations
05. ๋นํธ ์กฐ๊ฐ
2์ ๋ณด์์ ์์
์ปดํจํฐ๋ ์ ์๋ฅผ ์ ์ฅํ ๋ 2์ ๋ณด์ ํํ๋ก ์ ์ฅํ๋ค.
์์๋ฅผ ํํํ ๋๋ ์๋ฌด ๋ฌธ์ ๊ฐ ์์ง๋ง ์์๋ฅผ ํํํ ๋๋ ๊ทธ ์์ ์ ๋๊ฐ์ ๋ถํธ๋นํธ๋ฅผ 1๋ก ์ธํ ํ ๋ค 2์ ๋ณด์๋ฅผ ์ทจํ ํํ๋ก ํํํ๋ค.
4๋นํธ๋ก ํํ๋ ์ ์ -3 ์์ ๋นํธ 1๊ฐ๋ ๋ถํธ, ๋๋จธ์ง 3๊ฐ๊ฐ ๊ฐ์ ํํํ ๊ฒ์ด๋ค.
๊ทธ๋ฌ๋ฉด 2^3 ์ ๋ํ ๋ณด์๋ฅผ ๊ตฌํ๋ฉด | -3 | ์ 8์ ๋ํ ๋ณด์๋ 5์ด๋ค. |
๋ฐ๋ผ์ -3 ์ 4๋นํธ์ 2์ง์๋ก ํํํ๋ฉด 1101 ์ด๋ค.
๋ค์ ๋งํด -K ๋ฅผ N ๋นํธ์ 2์ง์๋ก ํํํ๋ฉด concat(1, 2^(N-1) - K) ๊ฐ ๋๋ค.
๋ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ ์์๋ก ํํ๋ 2์ง์๋ฅผ ๋ค์ง์ ๋ค 1์ ๋ํ๋ ๋ฐฉ๋ฒ์ด๋ค.
3์ 011์ธ๋ฐ ๋ค์ง์ผ๋ฉด 100์ด ๋๊ณ 1์ ๋ํ๋ฉด 101์ด ๋๋ค.
๋ง์ง๋ง์ผ๋ก ๋ถํธ๋นํธ๋ฅผ ์์ ๋ถ์ด๋ฉด 1011์ด๋ค
์ฐ์ ์ฐ์ธก ์ํํธ vs. ๋ ผ๋ฆฌ ์ฐ์ธก ์ํํธ
์ฐ์ธก ์ํํธ ์ฐ์ฐ์๋ ๋ ๊ฐ์ง ์ข ๋ฅ๊ฐ ์๋ค.
์ฐ์ ์ฐ์ธก ์ํํธ๋ 2๋ก ๋๋ ๊ฒฐ๊ณผ์ ๊ฐ๋ค.
๋นํธ๋ฅผ ์์ผ๋ก ์ฎ๊ธฐ์ง๋ง ์ต์์ ๋ถํธ๋นํธ๋ ๋ฐ๋์ง ์๋๋ค.
๋ ผ๋ฆฌ ์ฐ์ธก ์ํผํธ๋ ๋นํธ๋ฅผ ์ฎ๊ธธ ๋ ๋ณด์ด๋ ๊ฒ์ฒ๋ผ ์์ง์ธ๋ค.
๋นํธ๋ฅผ ์์ผ๋ก ์ฎ๊ธด ๋ค์ ์ต์์ ๋นํธ์ 0์ ๋ฃ๋๋ค.
๊ธฐ๋ณธ์ ์ธ ๋นํธ ์กฐ์: ๋นํธ๊ฐ ํ์ธ ๋ฐ ์ฑ์๋ฃ๊ธฐ
๋นํธ๊ฐ ํ์ธ
์ด ๋ฉ์๋๋ 1์ i ๋นํธ๋งํผ ์ํํธํด์ 00010000๊ณผ ๊ฐ์ ๊ฐ์ ๋ง๋ ๋ค.
๊ทธ ๋ค์ AND ์ฐ์ฐ์ผ๋ก num ์ i ๋ฒ์งธ ๋นํธ๋ฅผ ๋บ ๋๋จธ์ง ๋นํธ๋ฅผ ๋ชจ๋ ์ญ์ ํ ๋ค, ์ด ๊ฐ์ 0๊ณผ ๋น๊ตํ๋ค.
์ด ๊ฐ์ด 0 ์ด ์๋๋ฉด i ๋ฒ์งธ ๋นํธ๋ 1์ด๊ณ , 0 ์ด๋ผ๋ฉด i ๋ฒ์งธ ๋นํธ๋ 0์ด์ด์ผ ํ๋ค.
1
2
3
boolean getBit(int num, int i) {
return ((num & (i << i)) != 0);
}
๋นํธ๊ฐ ์ฑ์๋ฃ๊ธฐ
1์ i ๋นํธ๋งํผ ์ํํธํ ํ OR ์ฐ์ฐ์ ํตํด num ์ i ๋ฒ์งธ ๋นํธ๊ฐ์ ๋ฐ๊พผ๋ค.
i ๋ฒ์งธ๋ฅผ ์ ์ธํ ๋๋จธ์ง ๋นํธ๋ค์ 0 ๊ณผ OR ์ฐ์ฐ์ ํ๊ฒ ๋์ด num ๊ฐ์ ์ํฅ์ ๋ฏธ์น์ง ๋ชปํ๋ค.
1
2
3
int setBit(int num, int i) {
return num | (1 << i);
}
๋นํธ๊ฐ ์ญ์ ํ๊ธฐ
NOT ์ฐ์ฐ์๋ฅผ ์ด์ฉํด num ๊ณผ AND ์ฐ์ฐ์ ์ํํ๋ค.
๊ทธ๋ฌ๋ฉด ๋๋จธ์ง ๋นํธ์ ๊ฐ์ ๋ณํ์ง ์๊ณ i ๋ฒ์งธ ๋นํธ๊ฐ๋ง ์ญ์ ๋๋ค.
1
2
3
4
int clearBit(int num, int i) {
int mask = ~(1 << i);
return num & mask;
}
์ต์์ ๋นํธ์์ i ๋ฒ์งธ ๋นํธ๊น์ง ์ญ์ ํ๋ ค๋ฉด?
i ๋ฒ์งธ ๋นํธ๋ฅผ 1๋ก ์ธํ ํ๋ค ์ด ๊ฐ์์ 1์ ๋นผ๋ฉด i ๋ฒ์งธ ๋นํธ ๋ฐ์ด ๋ชจ๋ 1๋ก ์ธํ ๋๋ค.
ํ์ i ๋ฒ์งธ ๋นํธ๋ฅผ ๋บ ๋๋จธ์ง ๋นํธ๋ฅผ ๋ชจ๋ ์ญ์ ํ ์ ์๋ค.
1
2
3
4
int clearBitMSBthroughI(int num, int i) {
int mask = (1 << i) - 1;
return num & mask;
}
๋ฐ๋๋ก i ๋ฒ์งธ ๋นํธ์์ 0 ๋ฒ์งธ ๋นํธ๊น์ง ์ญ์ ํ๋ ค๋ฉด?
๋ชจ๋ ๋นํธ๊ฐ 1๋ก ์ธํ ๋ -1์ ์ผ์ชฝ์ผ๋ก i + 1 ๋งํผ ์ํํธ ํ๋ค.
๊ทธ๋ฌ๋ฉด i ๋ฒ์งธ ๋นํธ ์๋ก๋ ๋ชจ๋ 1, ํ์ i๊ฐ ๋นํธ๋ ๋ชจ๋ 0์ด ๋๋ค.
1
2
3
4
int clearBitMSBthroughI(int num, int i) {
int mask = (-1 << (i + 1));
return num & mask;
}
๋นํธ๊ฐ ๋ฐ๊พธ๊ธฐ
i ๋ฒ์งธ ๋นํธ๊ฐ์ v ๋ก ๋ฐ๊พธ๊ณ ์ถ๋ค๋ฉด, i ๋ฒ์งธ ๋นํธ๊ฐ์ ์ญ์ ํ ํ
v ๋ฅผ ์ผ์ชฝ์ผ๋ก i ๋ฒ ์ฌํํธํ ๊ฐ์ OR ์ฐ์ฐ์ผ๋ก ๋์ ํ๋ค.
1
2
3
4
5
int updateBit(int num, int i, boolean bitIs1) {
int value = bitIs1 ? 1 : 0;
int mask = ~(1 << i);
return (num & mask) | (value << i);
}
10. ์ ๋ ฌ๊ณผ ํ์ - ํ์ ์๊ณ ๋ฆฌ์ฆ
์ด์ง ํ์(Binary Search)์ ์ ๋ ฌ๋ ๋ฐฐ์ด์์ ์์ x๋ฅผ ์ฐพ๊ณ ์ ํ ๋ ์ฌ์ฉํ๋ค.
x๋ฅผ ์ค๊ฐ์ ์์นํ ์์์ ๋น๊ตํ ๋ค, x๊ฐ ์ค๊ฐ์ ์์นํ ๊ฐ๋ณด๋ค ์๋ค๋ฉด ๋ฐฐ์ด์ ์ผ์ชฝ ์ ๋ฐ์ ์ฌํ์ํ๊ณ ,
ํฌ๋ค๋ฉด ๋ฐฐ์ด์ ์ค๋ฅธ์ชฝ ์ ๋ฐ์ ์ฌํ์ ํ๋ค.
์ด ๊ณผ์ ์ x๋ฅผ ์ฐพ๊ฑฐ๋ ๋ถ๋ถ๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ 0์ด ๋ ๋๊น์ง ๋ฐ๋ณตํ๋ค.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
int binarySearch(int[] a, int x) {
int low = 0;
int high = a.length - 1;
int mid;
while (low <= high) {
mid = (low + high) / 2;
if (a[mid] < x) {
low = mid + 1;
} else if (a[mid] > x) {
high = mid - 1;
} else {
return mid;
}
}
return -1;
}