TypeScript में एल्गोरिदम और डेटा संरचनाएँ: व्यावहारिक गाइड

TypeScript में एल्गोरिदम और डेटा संरचनाएँ: थ्योरी से प्रैक्टिस तक

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

1. बुनियादी डेटा संरचनाएँ: स्टैक और क्यू

स्टैक और क्यू सबसे सरल लेकिन अत्यंत उपयोगी संरचनाएँ हैं। स्टैक LIFO (लास्ट इन, फर्स्ट आउट) सिद्धांत पर काम करता है, जबकि क्यू FIFO (फर्स्ट इन, फर्स्ट आउट) पर। TypeScript में, टाइप-सेफ्टी के लिए जेनेरिक का उपयोग करके इन्हें ऐरे के आधार पर लागू करना आसान है।

स्टैक (Stack) का कार्यान्वयन

class Stack<T> {\n    private items: T[] = [];\n\n    push(item: T): void {\n        this.items.push(item);\n    }\n\n    pop(): T | undefined {\n        return this.items.pop();\n    }\n\n    peek(): T | undefined {\n        return this.items[this.items.length - 1];\n    }\n\n    isEmpty(): boolean {\n        return this.items.length === 0;\n    }\n\n    size(): number {\n        return this.items.length;\n    }\n}\n\n// उपयोग का उदाहरण\nconst stack = new Stack<number>();\nstack.push(10);\nstack.push(20);\nconsole.log(stack.pop()); // 20\nconsole.log(stack.peek()); // 10

क्यू (Queue) का कार्यान्वयन

class Queue<T> {\n    private items: T[] = [];\n\n    enqueue(item: T): void {\n        this.items.push(item);\n    }\n\n    dequeue(): T | undefined {\n        return this.items.shift();\n    }\n\n    front(): T | undefined {\n        return this.items[0];\n    }\n\n    isEmpty(): boolean {\n        return this.items.length === 0;\n    }\n\n    size(): number {\n        return this.items.length;\n    }\n}\n\n// उपयोग का उदाहरण\nconst queue = new Queue<string>();\nqueue.enqueue('A');\nqueue.enqueue('B');\nconsole.log(queue.dequeue()); // A\nconsole.log(queue.front()); // B

ध्यान दें: बिल्ट-इन मेथड shift() की जटिलता O(n) है, इसलिए बड़े डेटा के लिए लिंक्ड लिस्ट पर आधारित क्यू का उपयोग करना बेहतर है।

2. सर्च एल्गोरिदम: लीनियर और बाइनरी

एलिमेंट्स की खोज सबसे आम ऑपरेशनों में से एक है। लीनियर सर्च सरल है लेकिन बड़े डेटा पर धीमी होती है। बाइनरी सर्च O(log n) में काम करती है, लेकिन इसके लिए सॉर्टेड ऐरे की आवश्यकता होती है।

लीनियर सर्च

function linearSearch<T>(arr: T[], target: T): number {\n    for (let i = 0; i < arr.length; i++) {\n        if (arr[i] === target) {\n            return i;\n        }\n    }\n    return -1;\n}\n\nconst numbers = [3, 7, 1, 9, 4];\nconsole.log(linearSearch(numbers, 9)); // 3

बाइनरी सर्च (रिकर्सिव वर्जन)

function binarySearch<T>(arr: T[], target: T, left: number = 0, right: number = arr.length - 1): number {\n    if (left > right) {\n        return -1;\n    }\n\n    const mid = Math.floor((left + right) / 2);\n\n    if (arr[mid] === target) {\n        return mid;\n    }\n\n    if (arr[mid] > target) {\n        return binarySearch(arr, target, left, mid - 1);\n    } else {\n        return binarySearch(arr, target, mid + 1, right);\n    }\n}\n\nconst sortedArray = [1, 3, 5, 7, 9, 11];\nconsole.log(binarySearch(sortedArray, 7)); // 3\nconsole.log(binarySearch(sortedArray, 6)); // -1

इटरेटिव वर्जन के लिए while लूप का उपयोग करें। TypeScript टाइप से जुड़ी गलतियों से बचने में मदद करता है: जेनेरिक <T> यह सुनिश्चित करता है कि ऐरे और टार्गेट एलिमेंट एक ही टाइप के हों।

3. सॉर्टिंग: क्विक सॉर्ट (Quick Sort)

क्विक सॉर्ट सबसे कुशल एल्गोरिदम में से एक है जिसकी औसत जटिलता O(n log n) है। यहाँ TypeScript में इसका कार्यान्वयन है: