์ ์
- ํฌ ํฌ์ธํฐ(Two Pointer) ์๊ณ ๋ฆฌ์ฆ์ด๋, ๋ฐฐ์ด์ด๋ ์ปฌ๋ ์
์์ ๋ ๊ฐ์ ํฌ์ธํฐ๋ฅผ ์ด์ฉํ์ฌ ๋ฒ์๋ฅผ ์กฐ์ ํด๊ฐ๋ฉฐ ํน์ ํ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๋ถ๋ถ์ ์ฐพ๋ ๊ธฐ๋ฒ์ด๋ค.
- ํนํ ์ ๋ ฌ๋ ๋ฐฐ์ด์ด๋ ์ปฌ๋ ์
๊ณผ ๊ด๋ จ๋ ๋ฌธ์ ์์ ํจ๊ณผ์ ์ผ๋ก ์ฌ์ฉ๋๋ค.
- ํต์ฌ ์์ด๋์ด๋ ๋ฐฐ์ด์ ์๋ก ๋ค๋ฅธ ๋ ๋ถ๋ถ์ ๋์์ ๋ฐ๋ณตํ๋ ๊ฒ์ด๋ค.
- ์ผ๋ฐ์ ์ผ๋ก ์๊ฐ ๋ณต์ก๋๋
O(n), ๊ณต๊ฐ ๋ณต์ก๋๋ O(1)์ด ๋๋ค.
๋ฐํ์์ ์ต์ ํํ๊ณ ๊ณต๊ฐ์ ์ ์ฝํ๊ณ ์ถ์ ๋ ์ฌ์ฉํ๋ค.
๊ณ ๋ คํด์ผ ํ ์
- ํฌ์ธํฐ์ ์ด๊ธฐ ์์น ์ค์
- ํฌ์ธํฐ๋ฅผ ์ด๋์ ์์ํ๊ณ ์ด๋ค ์ธ๋ฑ์ค๋ฅผ ๋น๊ตํ ๊ฒ์ธ๊ฐ?
- ํฌ์ธํฐ์ ์ด๋ ๋ฐฉํฅ๊ณผ ์กฐ๊ฑด
- ๊ฐ์ ๋ฐฉํฅ์ผ๋ก ์ด๋ํ ๊ฒ์ธ๊ฐ, ๋ค๋ฅธ ๋ฐฉํฅ์ผ๋ก ์ด๋ํ ๊ฒ์ธ๊ฐ?
- ํฌ์ธํฐ๋ฅผ ์ธ์ ์์ง์ผ ๊ฒ์ธ๊ฐ?
- ํฌ์ธํฐ์ ์ค์ง ์กฐ๊ฑด
- ํฌ์ธํฐ๋ฅผ ์ธ์ ๋ฉ์ถ ๊ฒ์ธ๊ฐ?
- ์ผ๋ฐ์ ์ผ๋ก ๋ฐฐ์ด์ ๋ฐ๋ณต์ด ๋๋ ๋๋ ๋ ํฌ์ธํฐ๊ฐ ๊ต์ฐจํ ๋ ์ค์ง๋๋ค.
๋์ ๋ฐฉ์
1. ๊ฐ์ ๋ฐฉํฅ ํฌ์ธํฐ
- ๋ ํฌ์ธํฐ ์ค ํ๋๋ ๋๋ฆฐ ์๋๋ก, ๋ค๋ฅธ ํ๋๋ ๋น ๋ฅธ ์๋๋ก ์ด๋ํ๋ค.
- e.g. ์ ๋ ฌ๋ ๋ฐฐ์ด์์ ์ค๋ณต ์์ ์ ๊ฑฐ, ์ฐ๊ฒฐ ๋ฆฌ์คํธ ์ฌ์ดํด
https://cdragon.medium.com/basics-of-two-pointers-technique-e1a0df57ba7e
2. ์ญ๋ฐฉํฅ ํฌ์ธํฐ
- ๋ ํฌ์ธํฐ ์ค ํ๋๋ ๋งจ ์ฒ์๋ถํฐ, ๋ค๋ฅธ ํ๋๋ ๋งจ ๋๋ถํฐ ์ด๋ํ๋ค.
- e.g. ํฐ๋ฆฐ๋๋กฌ(ํ๋ฌธ)
https://cdragon.medium.com/basics-of-two-pointers-technique-e1a0df57ba7e
์์ค ์ฝ๋ (JS)
1. ์ ๋ ฌ๋ ๋ฐฐ์ด์์ ์ค๋ณต๋๋ ์์ ์ ๊ฑฐํ๊ธฐ
- ๊ฐ์ ๋ฐฉํฅ์ผ๋ก ์ด๋ํ๋ ํฌ์ธํฐ๋ฅผ ์ด์ฉํ๋ค.
- ์ ๋ ฌ๋ ๋ฐฐ์ด์ด ์ฃผ์ด์ง๋ ๊ฒฝ์ฐ์๋ง ์๋ํ๋ค.
/**
* @param {number[]} nums
* @return {number}
*/
var removeDuplicates = function (nums) {
let j = 0;
for (let i = 1; i < nums.length; i++) {
if (nums[j] !== nums[i]) {
j += 1;
nums[j] = nums[i];
}
}
return j + 1;
};
2. ์ฐ๊ฒฐ ๋ฆฌ์คํธ ์ฌ์ดํด
- ๊ฐ์ ๋ฐฉํฅ์ผ๋ก ์ด๋ํ๋ ํฌ์ธํฐ๋ฅผ ์ด์ฉํ๋ค.
- ๋ ์ค ํ๋์ ํฌ์ธํฐ๋ ๋๋ฆฌ๊ณ , ๋ค๋ฅธ ํ๋์ ํฌ์ธํฐ๋ ๋น ๋ฅด๋ค.
/**
* Definition for singly-linked list.
* function ListNode(val) {
* this.val = val;
* this.next = null;
* }
*/
/**
* @param {ListNode} head
* @return {boolean}
*/
var hasCycle = function (head) {
let slow = head;
let fast = head;
while (fast && fast.next) {
slow = slow.next;
fast = fast.next.next;
if (slow === fast) {
return true;
}
}
return false;
};
3. ํฐ๋ฆฐ๋๋กฌ
- ์ญ๋ฐฉํฅ์ผ๋ก ์ด๋ํ๋ ํฌ์ธํฐ๋ฅผ ์ด์ฉํ๋ค.
- ๋ ์ค ํ๋์ ํฌ์ธํฐ๋ ๋ฌธ์์ด์ ๋งจ ์ฒ์๋ถํฐ ์์ํ๊ณ , ๋ค๋ฅธ ํ๋์ ํฌ์ธํฐ๋ ๋ฌธ์์ด์ ๋งจ ๋๋ถํฐ ์์ํ๋ค.
/**
* @param {string} s
* @return {boolean}
*/
var isPalindrome = function (s) {
// ๊ณต๋ฐฑ์ ๊ฑฐ, ์๋ฌธ์ ์๋ฌธ์ผ๋ก ๋ณํ, ์์ซ์๋ง ๊ฐ๋ฅ
const formatted = s
.split("")
.filter((ch) => isAlphabetOrNumeric(ch))
.join("")
.toLowerCase();
let left = 0;
let right = formatted.length - 1;
while (left <= right) {
if (formatted[left] !== formatted[right]) {
return false;
}
left++;
right--;
}
return true;
};
function isAlphabetOrNumeric(ch) {
const code = ch.charCodeAt(0);
return (
(code >= 48 && code <= 57) ||
(code >= 65 && code <= 90) ||
(code >= 97 && code <= 122)
);
}
์ฐธ๊ณ
- Geeks for Geeks
- ๋ธ๋ก๊ทธ
- Basics of Two Pointers Technique
- Two Pointers & Sliding Window
- ๊ด๋ จ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์
- ๋ฆฌํธ์ฝ๋ 26๋ฒ Remove Duplicates from Sorted Array
- ๋ฆฌํธ์ฝ๋ 125๋ฒ Valid Palindrome
- ๋ฆฌํธ์ฝ๋ 141๋ฒ Linked List Cycle