मैं एक सरल और प्रभावी तकनीक समझाना चाहता हूं जिसका उपयोग आप एक साक्षात्कार में ऐरे, स्ट्रिंग्स, लिंक्ड सूचियों आदि से निपटने के दौरान कर सकते हैं। इससे इन डेटा के बारे में आपके मौलिक ज्ञान में भी सुधार होगा संरचनाएं.

आइए सिद्धांत से शुरू करते हैं। इस एल्गोरिथम के दो सामान्य उपयोग के मामले हैं:

• बाएं/दाएं इस एल्गोरिदम की केंद्रीय अवधारणा दो पूर्णांक चर रखने की है जो एक स्ट्रिंग या सरणी के दोनों ओर से चलेंगी। आमतौर पर लोग इसे बाएँ और दाएँ कहते हैं। बायां 0 सूचकांक से लंबाई - 1 की ओर बढ़ेगा, और दायां इसके विपरीत है।

• धीमे/तेज़ पॉइंटर एक ही दिशा में चलते हैं, उदाहरण के लिए, शुरू से अंत तक, लेकिन एक पॉइंटर दूसरे की तुलना में तेज़ चलता है। इस मामले में, लोग आमतौर पर वेरिएबल को धीमा और तेज़ कहते हैं।

एल्गोरिदम प्राथमिक हैं, और उन्हें समझने का सबसे अच्छा तरीका कुछ उदाहरणों पर गौर करना है।

सबसे पहले, आइए बाएँ और दाएँ संकेतक वाले एक मामले को देखें। यहां एक समस्या का प्राथमिक उदाहरण दिया गया है जिसे हम इस एल्गोरिथम का उपयोग करके हल कर सकते हैं। लक्ष्य स्पष्ट है: हम एक ऐसा जोड़ा ढूंढना चाहते हैं जिसका योग दी गई संख्या के बराबर हो।
क्रूर बल दृष्टिकोण नेस्टेड लूप बनाएगा, लेकिन इसका उपयोग करके साक्षात्कार पास करने की संभावना कम है।
एक बेहतर तरीका यह होगा कि दो पॉइंटर्स एल्गोरिदम का उपयोग करें और इसे O(n²) के बजाय O(n) जटिलता के लिए एक लूप में ढूंढें

const findPair = (arr, target) => {
    let left = 0;                 // Start with two pointers left from start, right, from the end
    let right = arr.length - 1;

    while (left 

आइए एक ऐसे दृष्टिकोण पर स्विच करें जहां पॉइंटर्स की गति अलग-अलग हो। यह एक आम समस्या है जिसका सामना आपको इंटरव्यू में करना पड़ सकता है। आपको दी गई लिंक्ड सूची के मध्य को ढूंढना होगा।

क्रूर बल दृष्टिकोण पिछले उदाहरण जितना बुरा नहीं है, लेकिन साक्षात्कारकर्ता बेहतर दृष्टिकोण की उम्मीद करता है।

दो पॉइंटर्स एल्गोरिदम के साथ, आप इस समस्या को O(n) जटिलता के साथ हल करेंगे, जबकि यदि आप दो अनुक्रमिक लूप का उपयोग करते हैं तो क्रूर बल दृष्टिकोण O(2n) लेगा।


class ListNode {
    constructor(value) {
        this.value = value;
        this.next = null;
    }
}

const findMiddle = (head) => {
    if (!head) return null;

    let slow = head;
    let fast = head;

    while (fast && fast.next) {
        slow = slow.next;           // Move slow pointer one step
        fast = fast.next.next;      // Move fast pointer two steps
    }

    return slow;  // Slow pointer will be at the middle
}

// Creating a linked list 1 -> 2 -> 3 -> 4 -> 5
const head = new ListNode(1);
const node2 = new ListNode(2);
const node3 = new ListNode(3);
const node4 = new ListNode(4);
const node5 = new ListNode(5);

head.next = node2;
node2.next = node3;
node3.next = node4;
node4.next = node5;

findMiddle(head).value);  // Output: 3 (middle node)