์ ํ ๊ฒ์๊ณผ ๋ณด์ด๋ฒ
๐๊ฒ์ ์๊ณ ๋ฆฌ์ฆ์ ๋ฌด์์ธ๊ฐ?
๊ฒ์ ์๊ณ ๋ฆฌ์ฆ์ ์๋ฏธ๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค ๋ด ์์ง ๋ ์ฌ๋ฌ ์์ดํ ์ค์์ ํน์ ์ฑ์ง ํน์ ํค ๊ฐ์ ๊ตฌ์ฑํ ๋ฐ์ดํฐ๋ฅผ ์ฐพ์๋ด๋ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค. ์ด๋ฌํ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ ๋ ์ฃผ์ํ ์ ์
- ์๋์ ์ธ ์๊ณ ๋ฆฌ์ฆ์ ์ํ ์๊ฐ
- ํ์ฉ ์ฉ๋๋ ๋ชฉ์ , ์๋ฃ๊ตฌ์กฐ ๋ฑ ์ฒด๊ณ์ ์ธ ๋ถ๋ถ
- ๋ฐ์ดํฐ์ ์ถ๊ฐ, ์์ , ์ญ์ ๋ฑ ์์ ์ ์์๋๋ ๋น์ฉ
๋ง์ฝ ์ด๋ค ๋ชฉ์ ์ ์ด๋ฃจ๊ธฐ ์ํด ์ ํํ ์ ์๋ ์๊ณ ๋ฆฌ์ฆ์ ๊ฐ์๊ฐ ์ฌ๋ฌ ๊ฐ์ง์ธ ๊ฒฝ์ฐ ์ฉ๋๋ ๋ชฉ์ , ์คํ ์๋, ์๋ฃ๊ตฌ์กฐ ๋ฑ์ ์ ๊ณ ๋ คํ์ฌ ์์ ์ ์์๋๋ ๋น์ฉ์ ์ข ํฉ์ ์ผ๋ก ํ๊ฐํ์ฌ ํจ์จ์ ์ธ ์๊ณ ๋ฆฌ์ฆ์ ์ ํํ์ฌ ๊ทธ ์ํฉ์ ๋ฌธ์ ์ ์ ์ฉ์ ์ํด์ผ ํฉ๋๋ค.
๐์ ํ ๊ฒ์์ ๋ํด ์์๋ณด์
์ ํ ๊ฒ์์ ๊ฒ์ ์๊ณ ๋ฆฌ์ฆ์์์ ๊ฐ์ฅ ๊ธฐ๋ณธ์ด ๋๋ค๊ณ ๋งํ ์ ์๋ ๊ฒ์ ์๊ณ ๋ฆฌ์ฆ ์ ๋๋ค. ์์๊ฐ ์ง์ ๋ชจ์์ผ๋ก ๋์ด์ ๋ฐฐ์ด์์ ์ํ๋ ํค ๊ฐ์ ๊ฐ๋ ์์๋ฅผ ๋ง๋ ๋๊น์ง ๋งจ ์์์ ์์๋๋ก ์์๋ฅผ ๊ฒ์ํฉ๋๋ค. ์ ํ ๊ฒ์ ๋๋ ์์ฐจ ๊ฒ์์ด๋ผ๊ณ ๋ถ๋ฅด๊ธฐ๋ ํฉ๋๋ค.

์์ ์ฌ์ง์ ์ ํ ๊ฒ์ ์๊ณ ๋ฆฌ์ฆ์ ํ์ฉํ์ฌ ๋ฐฐ์ด ์์์ ์ซ์ '2'๋ฅผ ์ฐพ๋ ๊ณผ์ ์ ๋๋ค. ์์ฐจ์ ์ผ๋ก 0๋ฒ์งธ ์ธ๋ฑ์ค๋ถํฐ ๋์ ์ธ๋ฑ์ค ๊ฐ์ผ๋ก ์ด๋ํ๋ฉด์ '2'๋ฅผ ์ฐพ๊ณ ์์ต๋๋ค. ์์ ์ฌ์ง์ ๋ฐฐ์ด์ ์ฐพ๋ ๊ฐ์ธ '2'๊ฐ ์กด์ฌํ๋ฏ๋ก ์ ํ ๊ฒ์ ์ฑ๊ณต์ ๋๋ค. ํ์ง๋ง ๋ฐฐ์ด ์์์ ์ฐพ๋ ๊ฐ์ด ์กด์ฌํ์ง ์์ผ๋ฉด ์ด๋ป๊ฒ ๋ ๊น์? ์ด๋ฒ์๋ ์์ ๋ฐฐ์ด์์ ์ซ์ '5'๋ฅผ ์ฐพ์๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.

์์ํ ๊ฒฐ๊ณผ์ ๊ฐ์ด ์์ ๋ฐฐ์ด์๋ ์ฐพ๊ณ ์ ํ๋ ๊ฐ์ธ 5๊ฐ ์กด์ฌํ์ง ์๊ธฐ ๋๋ฌธ์ ๋ฐฐ์ด ์ธ๋ฑ์ค์ ๊ฐ์ ๋ชจ๋ ์ฐพ์๋ณด์๋ ๊ทธ ๊ฐ์ด ์กด์ฌํ์ง ์๋๋ค๋ ๊ฒ์ ์ ์ ์์ต๋๋ค. ์ฆ ํ ์นธ์ฉ ์ฎ๊ธฐ๋ฉด์ ๊ตฌ์ฑํ๋ ์ธ๋ฑ์ค์ ๊ฐ์ด ๋ฐฐ์ด์ ํฌ๊ธฐ์ ๊ฐ์ด ๊ฐ๊ฒ ๋์์ผ๋ฉฐ ๊ฒ์ ์คํจ์ ๋๋ค.
๐ ์ ํ ๊ฒ์์ ์ข ๋ฃ ์กฐ๊ฑด์?
์ ํ ๊ฒ์์ ์ข ๋ฃ ์กฐ๊ฑด
1. ๊ฒ์ํ ๊ฐ๊ณผ ๊ฐ์ ์์๋ฅผ ๋ฐ๊ฒฌํ ๊ฒฝ์ฐ(๊ฒ์ ์ฑ๊ณต)
2. ๊ฒ์ํ ๊ฐ์ ๋ฐ๊ฒฌํ์ง ๋ชปํ๊ณ ๋ฐฐ์ด์ ๋์ ์ง๋๊ฐ ๊ฒฝ์ฐ(๊ฒ์ ์คํจ)
์ ํ ๊ฒ์์ ์ข ๋ฃ ์กฐ๊ฑด 1๊ณผ 2๋ฅผ ํ๋จํ๋ ์ ํ ๊ฒ์์ ๊ฒ์ ํ๋จ ํ์๋ ๋ฐฐ์ด์ ์์์๊ฐ n๊ฐ์ผ ๋ ํ๊ท n/2ํ์ ๋๋ค.
๐ป ์ ํ ๊ฒ์์ ๊ตฌํํด๋ณด์!
public class SeqSearch {
public static Scanner scanner = new Scanner(System.in);
public static void main(String[] args) {
System.out.print("์์์๋ฅผ ์
๋ ฅํด์ฃผ์ธ์ : "); int input = scanner.nextInt();
int[] arr = new int[input];
setArr(arr);
System.out.print("๋ฐฐ์ด์์ ๊ฒ์ํ ๊ฐ์ ์
๋ ฅํด์ฃผ์ธ์ : "); int searchInput = scanner.nextInt();
int index = findArr(arr, searchInput);
if(index == -1) System.out.println("์ฐพ์ผ์๋ ๊ฐ์ ๋ฐฐ์ด์ ์กด์ฌํ์ง ์์ต๋๋ค.");
else System.out.println("์ฐพ์ผ์๋ ๊ฐ์ ๋ฐฐ์ด x[" + index + "]์ ์กด์ฌํฉ๋๋ค.");
}
public static void setArr(int[] arr){
for(int i = 0; i < arr.length; i++){
System.out.print("๋ฐฐ์ด์ x[" + i + "]์ ๊ฐ์ ์
๋ ฅํด์ฃผ์ธ์ : ");
arr[i] = scanner.nextInt();
}
}
public static int findArr(int[] arr, int searchInput){
for(int i = 0; i < arr.length; i++) if(arr[i] == searchInput) return i;
return -1;
}
}
๋จผ์ , ์ฌ์ฉ์์๊ฒ ๋ฐฐ์ด์ ์์์ ์ฆ ํฌ๊ธฐ๋ฅผ ์ ๋ ฅ๋ฐ๊ณ ๊ทธ ํฌ๊ธฐ์ ๋ง๊ฒ int ์ ์ํ ๋ฐฐ์ด์ ์์ฑํ์์ต๋๋ค. ๊ทธ ํ ๋ฐฐ์ด์ ์์๋ฅผ ๊ฐ๊ฐ ์ ๋ ฅ์ ํ์ฌ ๋ฐฐ์ด์ ์ ์ฅ์ ํ์์ต๋๋ค. ๋ฐฐ์ด์ ์์๋ฅผ ๋ชจ๋ ์ ๋ ฅ์ ๋ฐ์๋ค๋ฉด ์ต์ข ์ ์ผ๋ก ์ฌ์ฉ์์๊ฒ ๋ฐฐ์ด์์ ๊ฒ์ํ ๊ฐ์ ์ ๋ ฅ๋ฐ์ต๋๋ค. ๊ทธ๋ฌ๋ฉด ํ๋ก๊ทธ๋จ ๋ด์์๋ ์ ํ ๊ฒ์ ์๊ณ ๋ฆฌ์ฆ์ ํตํด ๋ฐฐ์ด์ ์ธ๋ฑ์ค 0๋ฒ์งธ๋ถํฐ ๊ทธ ๊ฐ์ ์์ฐจ์ ์ผ๋ก ๊ฒ์ํ๊ธฐ ์์ํฉ๋๋ค.
๋ง์ฝ ์ฌ์ฉ์๊ฐ ์ ๋ ฅํ ๊ฐ์ด ๋ฐฐ์ด์ ์กด์ฌํ๋ค๋ฉด ๊ทธ ๊ฐ์ ์ธ๋ฑ์ค ๊ฐ์ ๋ฐํํ๊ณ ๋ง์ฝ ๋ฐฐ์ด์ ์ฒ์๋ถํฐ ๋๊น์ง ๋ชจ๋ ๊ฒ์์ ์ํํ์์ผ๋ ๊ฐ์ด ์กด์ฌํ์ง ์๋๋ค๋ฉด findArr ๋งค์๋์ for๋ฌธ์ ํ์ถํ์ฌ ์ต์ข ์ ์ผ๋ก ์ซ์ -1์ ๋ฐํํ์ฌ ๊ฒ์ ์คํจ๋ฅผ ์๋ฏธํ๊ณ ์์ต๋๋ค.
๐ฏ ๋ณด์ด ๋ฒ์ด ๋์ฒด ๋ญ์ผ?
๋ณด์ด ๋ฒ์ ์ ํ ๊ฒ์ ์๊ณ ๋ฆฌ์ฆ์ ํ์ฉํ ๋ ํจ๊ป ์ฌ์ฉ์ ํ๋ค๋ฉด ํจ์จ์ฑ์ด ์๋ ๊ธฐ์ ?, ๋ฐฉ๋ฒ?์ด๋ผ๊ณ ํ ์ ์๋ค. ์์์ ์ ํ ๊ฒ์ ์๊ณ ๋ฆฌ์ฆ์ ์ข ๋ฃ ์กฐ๊ฑด์ ์ด 2๊ฐ์ง์๋ค. ์ด๋ป๊ฒ ๋ณด๋ฉด ์ ๋ค๊ณ ํ ์ ์์ง๋ง ์ข ๋ฃ ์กฐ๊ฑด์ ๊ฒ์ฌํ๋ ๋น์ฉ์ ๊ฒฐ์ฝ ๋ฌด์ํ ์ ์๋ค. ๊ทธ๋์ ๊ทธ ์ข ๋ฃ ์กฐ๊ฑด์ ๊ฒ์ฌํ๋ ๋น์ฉ์ ์ค์ฌ์ฃผ๊ธฐ ์ํ ๋ฐฉ๋ฒ์ผ๋ก ๋ณด์ด ๋ฒ์ ํ์ฉํ๋ฉด ๋๋ค. ์๋์ ๊ทธ๋ฆผ์ ํตํด ๋ณด์ด๋ฒ์ ์ค๋ช ํ๊ฒ ์ต๋๋ค.
๊ธฐ์กด์ ๋ฐฐ์ด์ ๋ณด์ด ๊ฐ์ด ์ถ๊ฐ ๋์ด์๋ ๋ชจ์ต์ ๋๋ค. (๊ธฐ์กด์ ๋ฐ์ดํฐ ๊ฒ์ ์ฑ๊ณต)


๋ณด์ด ๋ฒ์ ์ฌ์ฉํ๋ ๊ฐ๋จํ ๋ฐฉ๋ฒ์ ์๋ ค๋๋ฆฌ๋๋ก ํ๊ฒ ์ต๋๋ค. ๊ธฐ์กด์ ๋ฐฐ์ด์์ ์์์๋ฅผ 1์ ์ถ๊ฐํ์ฌ ๋ฐฐ์ด ๋ง์ง๋ง ์ธ๋ฑ์ค์ ์ฌ์ฉ์๊ฐ ์ฐพ๋ ๊ฐ์ ์ ์ฅํด๋ก๋๋ค. ๊ทธ๋ฌ๋ฉด ์ ํ ๊ฒ์์ ํตํด ์์ฐจ์ ์ผ๋ก ๊ฐ์ ์ฐพ๊ฒ ๋ ๊ฒ์ด๋ฉฐ ๊ฒ์ ์กฐ๊ฑด 2๋ฒ ๋ฐฐ์ด์์ ๊ฐ์ ๋ฐ๊ฒฌํ์ง ๋ชปํ๊ณ ๋ฐฐ์ด์ ๋์ ์ง๋๊ฐ ๊ฒฝ์ฐ๋ ์ด์ ์กด์ฌํ์ง ์๊ฒ ๋ ๊ฒ์ ๋๋ค. ์ฆ ๊ฒ์ ์คํจ์ ๊ฒฝ์ฐ๋ ์์ผ๋ก ์กด์ฌํ ์๊ฐ ์๋ ๊ฒ์ ์ ์ ์์ต๋๋ค.
์ต์ข ์ ์ผ๋ก ์ ํฌ๋ ์ด์ ์ ํ ๊ฒ์์ ํตํด ์ฐพ์ ๊ฐ์ด ๊ธฐ์กด์ ๋ฐฐ์ด์ ์กด์ฌํ๋ ๋ฐ์ดํฐ์ธ์ง ๋๋ ๋ณด์ด๋ก ์ค์ ํด๋ ํน์ ์ ๊ฐ์ธ์ง ๊ตฌ๋ณ๋ง ํ ์ ์๋๋ก ์ฝ๋๋ฅผ ์์ฑํ๋ค๋ฉด ์ ํ ๊ฒ์ ์๊ณ ๋ฆฌ์ฆ์ ์ข ๋ฃ ์กฐ๊ฑด์ ๊ฒ์ฌํ๋ ๋น์ฉ์ 50%๋ ์ค์ผ ์ ์์ด ๋์ฑ ํจ์จ์ ์ ๋๋ค.
๐ ๋ณด์ด๋ฒ์ ์ฌ์ฉํด๋ณด์!
์๋์ ์ฝ๋๋ ์์์ ์๊ธฐํ ๊ฒ๊ณผ ๊ฐ์ด ์ฌ์ฉ์๋ก๋ถํฐ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ์ ๋ ฅ๋ฐ์ ๊ฒ์์ 1 ํฌ๊ฒ ๋ฐฐ์ด์ ๊ตฌ์ฑํฉ๋๋ค. ๊ทธ ํ ๋ฐฐ์ด ๋ง์ง๋ง ์ธ๋ฑ์ค์ ์ฌ์ฉ์๊ฐ ์ฐพ๋ ๊ฐ์ ์ถ๊ฐํฉ๋๋ค. ๊ทธ๋ ๋ค๋ฉด ๊ฒ์ ์คํจ๋ ์ ๋ ๋ฐ์ํ์ง ์๊ณ ๋งค๋ฒ ๊ฒ์ ์ฑ๊ณต์ ํฉ๋๋ค. ๊ทธ๋ฌ๋ฉด ์ด์ ๊ทธ ๊ฒ์ ์ฑ๊ณต์ ๊ฐ์ด ๊ธฐ์กด์ ๋ฐฐ์ด์ ๋ฐ์ดํฐ ๊ฐ์ธ์ง ๋๋ ๋ณด์ด์ ๊ฐ์ธ์ง ํ๋จ์ ํด์ผ ํฉ๋๋ค. ํ๋จ์ ๊ธฐ์ค์ ์ธ๋ฑ์ค ๊ฐ์ผ๋ก ํ๋จํ ์ ์์ต๋๋ค.
๋ง์ฝ ๊ทธ ์ธ๋ฑ์ค์ ๊ฐ์ด ๋ฐฐ์ด์ ๋ง์ง๋ง ์ธ๋ฑ์ค๋ผ๋ฉด ์ฐพ์ ๊ฐ์ ๋ณด์ด์ ๊ฐ์ด๋ฉฐ -1์ ๋ฐํํฉ๋๋ค. ๊ทธ๋ฌ๋ ๊ทธ๋ ์ง ์๋ค๋ฉด ๊ธฐ์กด์ ๋ฐฐ์ด์ ๋ฐ์ดํฐ ๊ฐ์ด๋ฏ๋ก ๊ทธ ๊ฐ์ ์ธ๋ฑ์ค๋ฅผ ์ ๋ฌํฉ๋๋ค. ์ ๋ฌ๋ฐ์ ๊ฐ์ ํตํด ์ ํฌ๋ ์ฐพ์ ๊ฐ์ ๊ฒ์ ์ฑ๊ณต, ์คํจ ์ฌ๋ถ๋ฅผ ํ์ธํ ์ ์์ต๋๋ค.
public class SeqSearchSen {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("์์์๋ฅผ ์
๋ ฅํด์ฃผ์ธ์ : "); int num = scanner.nextInt();
int arr[] = new int[num + 1];
for(int i = 0; i < num; i++){
System.out.println("๋ฐฐ์ด x[" + i + "] : ");
arr[i] = scanner.nextInt();
}
System.out.println("๊ฒ์ํ ๊ฐ์ ์
๋ ฅํด์ฃผ์ธ์ : "); int ky = scanner.nextInt();
int idx = seqSearchSen(arr, num, ky);
if(idx == -1) System.out.println("๋ฐฐ์ด์์ ๊ฒ์ํ์ ๊ฐ์ ์กด์ฌํ์ง ์์ต๋๋ค.");
else System.out.println(ky + "์(๋) ๋ฐฐ์ด x[" + idx + "]์ ์กด์ฌํฉ๋๋ค.");
}
public static int seqSearchSen(int arr[], int num, int key){
int i = 0;
arr[num] = key;
while(true){
if(arr[i] == key) break;
i++;
}
return i == num ? -1 : i;
}
}