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

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

एल्गोरिदम और डेटा संरचनाओं की समझ वह नींव है जो एक पेशेवर डेवलपर को शौकिया से अलग करती है। यदि आप अभी TypeScript में प्रोग्रामिंग की अपनी यात्रा शुरू कर रहे हैं, तो यह लेख आपको प्रमुख अवधारणाओं को समझने में मदद करेगा। हम बुनियादी डेटा संरचनाओं (arrays, stack, queue) और सरल एल्गोरिदम (linear और binary search) पर चर्चा करेंगे, और साथ ही दिखाएंगे कि सख्त टाइपिंग को ध्यान में रखते हुए उन्हें TypeScript में कैसे लागू किया जाए।

1. TypeScript में Arrays और उनके साथ काम करना

Array सबसे सरल और सबसे अधिक उपयोग की जाने वाली डेटा संरचना है। TypeScript में, arrays को सख्ती से टाइप किया जा सकता है, जो कंपाइलेशन चरण में त्रुटियों से बचने में मदद करता है।

// टाइप किए गए numbers array की घोषणा\nconst numbers: number[] = [5, 12, 8, 130, 44];\n\n// strings का array\nconst fruits: Array<string> = ['apple', 'banana', 'cherry'];\n\n// इंडेक्स द्वारा पहुँच\nconsole.log(numbers[0]); // 5\n\n// अंत में तत्व जोड़ना\nnumbers.push(100);\n\n// अंतिम तत्व हटाना\nconst last = numbers.pop();

महत्वपूर्ण: TypeScript कंपाइलेशन चरण में प्रकारों की जाँच करता है। यदि आप numbers array में एक string जोड़ने का प्रयास करते हैं, तो कंपाइलर एक त्रुटि देगा। यह कोड को अधिक विश्वसनीय बनाता है।

2. Stack और Queue: LIFO और FIFO सिद्धांत

Stack LIFO (Last In, First Out — अंतिम में आया, पहले बाहर) सिद्धांत पर काम करता है। Queue FIFO (First In, First Out — पहले आया, पहले बाहर) सिद्धांत पर काम करता है।

TypeScript में Stack का कार्यान्वयन

class Stack<T> {\n    private items: T[] = [];\n\n    push(element: T): void {\n        this.items.push(element);\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\n// उपयोग\nconst stack = new Stack<number>();\nstack.push(10);\nstack.push(20);\nconsole.log(stack.pop()); // 20\nconsole.log(stack.peek()); // 10

TypeScript में Queue का कार्यान्वयन

class Queue<T> {\n    private items: T[] = [];\n\n    enqueue(element: T): void {\n        this.items.push(element);\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\n// उपयोग\nconst queue = new Queue<string>();\nqueue.enqueue('कार्य 1');\nqueue.enqueue('कार्य 2');\nconsole.log(queue.dequeue()); // 'कार्य 1'

जेनेरिक <T> के उपयोग पर ध्यान दें। यह सख्त टाइपिंग बनाए रखते हुए, किसी भी प्रकार के साथ काम करने वाली डेटा संरचनाएँ बनाने की अनुमति देता है।

3. खोज एल्गोरिदम: Linear और Binary

खोज सबसे सामान्य संक्रियाओं में से एक है। आइए दो बुनियादी एल्गोरिदम देखें।

Linear Search

जब तक वांछित तत्व नहीं मिल जाता, array के सभी तत्वों से गुज़रता है। जटिलता: O(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 data = [3, 7, 1, 9, 4];\nconsole.log(linearSearch(data, 9)); // 3\nconsole.log(linearSearch(data, 10)); // -1

Binary Search (केवल सॉर्ट किए गए arrays के लिए)

प्रत्येक चरण पर array को आधा विभाजित करता है। जटिलता: O(log n)। यह बड़े arrays के लिए linear search की तुलना में काफी तेज़ है।

function binarySearch(arr: number[], target: number): number {\n    let left = 0;\n    let right = arr.length - 1;\n\n    while (left <= right) {\n        const mid = Math.floor((left + right) / 2);\n\n        \n