TypeScript में एल्गोरिदम और डेटा संरचनाएँ: एक संपूर्ण गाइड

TypeScript में एल्गोरिदम और डेटा संरचनाएँ: शुरुआत से पेशेवर तक

एल्गोरिदम और डेटा संरचनाएँ वह नींव हैं जिस पर संपूर्ण आधुनिक सॉफ्टवेयर विकास टिका है। चाहे आप React पर फ्रंटएंड, Node.js पर बैकएंड या मोबाइल एप्लिकेशन लिख रहे हों, इन अवधारणाओं की गहरी समझ आपको कुशल, स्केलेबल और तेज़ एप्लिकेशन बनाने में सक्षम बनाती है। इस लेख में, हम TypeScript में प्रमुख एल्गोरिदम और डेटा संरचनाओं का विस्तार से विश्लेषण करेंगे - एक ऐसी भाषा जो JavaScript के लचीलेपन और स्थिर टाइपिंग की कठोरता को जोड़ती है।

TypeScript एल्गोरिदम सीखने के लिए आदर्श है: सख्त टाइपिंग कंपाइलेशन चरण में त्रुटियों से बचने में मदद करती है, और जेनेरिक (generics) का समर्थन सार्वभौमिक और पुन: प्रयोज्य डेटा संरचनाएँ बनाने की अनुमति देता है। हम सरल अवधारणाओं से शुरू करेंगे और धीरे-धीरे अधिक जटिल विषयों की ओर बढ़ेंगे, प्रत्येक चरण को स्पष्ट कोड उदाहरणों के साथ प्रस्तुत करेंगे।

1. मूल डेटा संरचनाएँ: स्टैक और क्यू

स्टैक (Stack) और क्यू (Queue) बुनियादी रैखिक डेटा संरचनाएँ हैं जिनका उपयोग सर्वव्यापी है: ब्राउज़र इतिहास प्रबंधन से लेकर ऑपरेटिंग सिस्टम में कार्य शेड्यूलिंग तक। आइए TypeScript में उनके कार्यान्वयन पर विचार करें।

स्टैक (LIFO — लास्ट इन, फर्स्ट आउट)

स्टैक "अंतिम आया, पहला गया" सिद्धांत पर काम करता है। मुख्य संचालन: push (तत्व जोड़ना) और pop (अंतिम तत्व निकालना)।

class Stack<T> {    private items: T[] = [];

    push(element: T): void {        this.items.push(element);    }

    pop(): T | undefined {        return this.items.pop();    }

    peek(): T | undefined {        return this.items[this.items.length - 1];    }

    isEmpty(): boolean {        return this.items.length === 0;    }

    size(): number {        return this.items.length;    }}

// उपयोग का उदाहरणconst stack = new Stack<number>();stack.push(1);stack.push(2);stack.push(3);console.log(stack.pop()); // 3console.log(stack.peek()); // 2

क्यू (FIFO — फर्स्ट इन, फर्स्ट आउट)

क्यू "पहला आया, पहला गया" सिद्धांत पर काम करता है। मुख्य संचालन: enqueue (अंत में जोड़ना) और dequeue (शुरुआत से निकालना)।

class Queue<T> {    private items: T[] = [];

    enqueue(element: T): void {        this.items.push(element);    }

    dequeue(): T | undefined {        return this.items.shift();    }

    front(): T | undefined {        return this.items[0];    }

    isEmpty(): boolean {        return this.items.length === 0;    }

    size(): number {        return this.items.length;    }}

// उपयोग का उदाहरणconst queue = new Queue<string>();queue.enqueue("पहला");queue.enqueue("दूसरा");queue.enqueue("तीसरा");console.log(queue.dequeue()); // "पहला"console.log(queue.front()); // "दूसरा"

2. खोज एल्गोरिदम: रैखिक और बाइनरी खोज

डेटा खोज प्रोग्रामिंग में सबसे सामान्य संक्रियाओं में से एक है। हम दो मुख्य दृष्टिकोणों पर विचार करेंगे: रैखिक खोज (सरल लेकिन धीमी) और बाइनरी खोज (तेज़ लेकिन क्रमबद्ध डेटा की आवश्यकता)।

रैखिक खोज

एल्गोरिदम क्रमिक रूप से सरणी के प्रत्येक तत्व की जाँच करता है जब तक कि वह लक्ष्य न मिल जाए। समय जटिलता: O(n)।

function linearSearch<T>(arr: T[], target: T): number {    for (let i = 0; i < arr.length; i++) {        if (arr[i] === target) {            return i; // मिले तत्व का सूचकांक लौटाएँ        }    }    return -1; // तत्व नहीं मिला}

// उदाहरणconst numbers = [10, 20, 30, 40, 50];console.log(linearSearch(numbers, 30)); // 2console.log(linearSearch(numbers, 60)); // -1

बाइनरी खोज

बाइनरी खोज केवल क्रमबद्ध सरणियों पर काम करता है। यह प्रत्येक चरण पर सरणी को आधा विभाजित करता है, आधे को हटाता है