- ์์นญ ์๊ณ ๋ฆฌ์ฆ์ด ๋ฌด์์ธ์ง ์ค๋ช ํ๋ค.
- ๋ฐฐ์ด์์
Linear Searching์๊ณ ๋ฆฌ์ฆ์ ์ ์ฉํด๋ณธ๋ค. - ์ ๋ ฌ๋ ๋ฐฐ์ด์์
Binary Searching์๊ณ ๋ฆฌ์ฆ์ ์ ์ฉํด๋ณธ๋ค. - ๋ฐฐ์ด์์
KMP String Searching์๊ณ ๋ฆฌ์ฆ์ ์ ์ฉํด๋ณธ๋ค.
๊ฐ์ฅ ๊ฐ๋จํ๊ฒ ์ํ๋ ๊ฐ์ ์ฐพ๋ ๋ฐฉ๋ฒ์ ์ฃผ์ด์ง ๋ฐฐ์ด์ ์๋ ๋ชจ๋ ์์๋ฅผ ํ๋ฒ์ฉ ํ์ธ ํด๋ณด๋ ๊ฒ์ด๋ค.
์๋ฐ์คํฌ๋ฆฝํธ๋ ๋ช ๊ฐ์ง Linear Searching ๋ฉ์๋๋ฅผ ๊ฐ์ง๊ณ ์๋ค
- IndexOf
- includes
- find
- ใ findIndex
- ํจ์์ ๋ค์ด๊ฐ๋ ์ธ์๋ ๋ฐฐ์ด๊ณผ ์ฐพ๊ณ ์ ํ๋ ๊ฐ์ด๋ค.
Loop๋ฅผ ํตํด ํ์ฌ ๋ฐฐ์ด ์์์ ๊ฐ๊ณผ ์ฐพ๊ณ ์ ํ๋ ๊ฐ์ด ๊ฐ์์ง ์ฒดํฌํ๋ค.- ๊ฐ์ผ๋ฉด ๊ทธ ๊ฐ์
return - ๋ค๋ฅด๋ฉด
-1์return
- ๊ฐ์ผ๋ฉด ๊ทธ ๊ฐ์
- Best Case : O(1) ์ ์ผ ์ฒ์์ ์๋ ๊ฒฝ์ฐ
- Worst Case : O(n) ์ ์ผ ๋ง์ง๋ง์ ์๋ ๊ฒฝ์ฐ
- Average Case : O(n)
Binary Search๋ ๋ ๋น ๋ฅธ ์์นญ ํํ์ด๋ค.- ํ๋ฒ์ ํ๋ฒ์ฉ ์์๋ค์ ์ ๊ฑฐํ๋ ๊ฒ์ด ์๋๋ผ ์ ์ฒด์ ๋ฐ์ฉ ์ ๊ฑฐ ํด ๋๊ฐ ์ ์๋ค.
Binary Search๋ ์ ๋ ฌ๋ ๋ฐฐ์ด์์๋ง ์ฌ์ฉํ ์ ์๋ค.
Binary Searchํจ์๋ ์ ๋ ฌ๋ ๋ฐฐ์ด๊ณผ ์ฐพ๊ณ ์ ํ๋ ๊ฐ์ ์ธ์๋ก ๋ฐ๋๋ค.- ๋ฐฐ์ด ์์์ ์
Leftํฌ์ธํฐ๋ฅผ ๋ง๋ค๊ณ ๋ฐฐ์ด ๋์Rightํฌ์ธํฐ๋ฅผ ๋ง๋ ๋ค. Leftํฌ์ธํฐ๊ฐRightํฌ์ธํฐ ์ค๊ธฐ์ ์- ์ค๊ฐ์ ํฌ์ธํฐ๋ฅผ ํ๋ ๋ ๋ง๋ ๋ค.
- ๋ง์ฝ ์ฐพ๊ณ ์ ํ๋ ๊ฐ์ ์ฐพ์ผ๋ฉด ๊ทธ ๊ฐ์
index๋ฅผreturnํ๋ค. - ๋ง์ฝ ๊ฐ์ด ๋๋ฌด ์์ผ๋ฉด,
left ํฌ์ธํฐ๋ฅผ์ฌ๋ฆฐ๋ค. - ๊ฐ์ด ๋๋ฌด ํฌ๋ฉด,
Rightํฌ์ธํฐ๋ฅผ ๋ด๋ฆฐ๋ค.
- ๋ง์ฝ ์ฐพ๋ ๊ฐ์ด ์์ผ๋ฉด
return -1๋ฅผ ํ๋ค.
- ํจ์๋ ์ ๋ ฌ๋ ๋ฐฐ์ด๊ณผ ์ฐพ๊ณ ์ ํ๋ ๊ฐ์ ์ธ์๋ก ๋ฐ๋๋ค.
- ์ผ์ชฝ ํฌ์ธํฐ๋ฅผ ๋ฐฐ์ด์ ์ฒซ๋ฒ์งธ
index๋ก, ์ค๋ฅธ์ชฝ ํฌ์ธํฐ๋ฅผ ๋ฐฐ์ด์ ๋ง์ง๋งindex์ ๋ง๋ ๋ค. - ์ผ์ชฝ ํฌ์ธํฐ๊ฐ ์ค๋ฅธ์ชฝ ํฌ์ธํฐ ์ค๊ธฐ ์ ์
while๋ฐ๋ณต๋ฌธ์ ์คํํ๋ค.- ์ค๊ฐ์
middleํฌ์ธํฐ๋ฅผ ๋ง๋ ๋ค. - ๋ง์ฝ ์ฐพ๊ณ ์ ํ๋ ๊ฐ์ ์ฐพ์ผ๋ฉด ์ด
index๋ฅผ ๋ฆฌํดํ๋ค. - ๋ง์ฝ ๊ฐ์ด ์์ผ๋ฉด ์ผ์ชฝ ํฌ์ธํฐ๋ฅผ ์ค๊ฐ๊น์ง ์ฎ๊ธด๋ค
- ๋ฐ๋๋ก ๊ฐ์ด ํฌ๋ฉด ์ค๋ฅธ์ชฝ ํฌ์ธํฐ๋ฅผ ์ค๊ฐ๊น์ง ์ฎ๊ธด๋ค.
- ์ค๊ฐ์
- ๋ง์ฝ ์ฐพ๊ณ ์ ํ๋ ๊ฐ์ด ์์ผ๋ฉด
return -1์ ํ๋ค.
- Worst and Average Case : O(log n)
- Best Case : O(1)
- ๊ธด ๋ฌธ์์ด ์์ ์์ ๋ฌธ์์ด์ด ๋ช๋ฒ ์๋์ง ์ธ๋ ๊ณผ์ ์ ๊ฐ์ ํด๋ณด์.
- ๊ฐ๋จํ ์ ๊ทผ ๋ฐฉ๋ฒ์ ๊ฐ๊ฐ์ ๋ฌธ์ ์์ด ๋ช๋ฒ ํฌํจ๋์ด ์๋์ง ์ฒดํฌํ๋ ๊ฒ์ด๋ค.
- ๊ธด ๋ฌธ์์ด์
Loop๋ฅผ ๋ง๋ ๋ค. - ์งง์ ๋ฌธ์์ด์๋
Loop๋ฅผ ๋ง๋ ๋ค -
- ๋ง์ฝ ๊ธ์๊ฐ ๋ง์ง ์์ผ๋ฉด ์์ ์๋ ๋ฃจํ๋ฅผ ๋น ์ ธ๋์จ๋ค.
- ๋ง์ฝ ๊ธ์๊ฐ ๋ง์ผ๋ฉด
Loop๋ฅผ ๊ณ์ ์งํํ๋ค.
- ๋ง์ฝ ์์
Loop์ ๋ชจ๋ ์ผ์นํ๋ฉด ์นด์ดํฐ๋ฅผ 1 ์ฆ๊ฐํ๋ค. count๋ฅผ ๋ฆฌํดํ๋ค.
const naiveSearch = (long, short) => {
let count = 0;
for (let i = 0; i < long.length; i++) {
for (let j = 0; j < short.length; j++) {
if (short[j] !== long[i + j]) break;
if (j === short.length - 1) count++;
}
}
return count;
};
naiveSearch('lorie loled','lol')