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

शुरुआती लोगों के लिए ऑनलाइन Python प्रशिक्षक

Python आसानी से सीखें बिना सिद्धांत के बोझ के। स्वचालित जांच के साथ व्यावहारिक कार्य हल करें और ब्राउज़र में सीधे कोड लिखें।

पाठ्यक्रम शुरू करें

```html

परिचय: TypeScript में एल्गोरिदम और डेटा संरचनाएँ क्यों महत्वपूर्ण हैं?

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

1. टाइपिंग के साथ बुनियादी डेटा संरचनाएँ

TypeScript आपको सख्ती से परिभाषित करने की अनुमति देता है कि संरचना में किस प्रकार का डेटा संग्रहीत किया जा सकता है। यह संकलन चरण में त्रुटियों को रोकता है। आइए तीन मूलभूत संरचनाओं पर विचार करें।

1.1. स्टैक (Stack) — LIFO सिद्धांत

स्टैक "लास्ट इन, फर्स्ट आउट" (Last In, First Out) सिद्धांत पर काम करता है। यह उन कार्यों के लिए आदर्श है जहाँ क्रियाओं को पूर्ववत करने की आवश्यकता होती है (जैसे, ब्राउज़र में इतिहास)।

// जेनेरिक T के साथ स्टैक का कार्यान्वयनclass Stack<T> {    private items: T[] = [];

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

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

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

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

// उपयोग का उदाहरणconst numberStack = new Stack<number>();numberStack.push(10);numberStack.push(20);console.log(numberStack.pop()); // 20

1.2. कतार (Queue) — FIFO सिद्धांत

कतार "फर्स्ट इन, फर्स्ट आउट" (First In, First Out) सिद्धांत पर काम करती है। इसका उपयोग कार्यों को उनके आने के क्रम में संसाधित करने के लिए किया जाता है, जैसे संदेश कतार प्रणालियों में।

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

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

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

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

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

// कस्टम प्रकार के साथ उदाहरणinterface Task {    id: number;    name: string;}const taskQueue = new Queue<Task>();taskQueue.enqueue({ id: 1, name: 'ऑर्डर प्रोसेस करें' });taskQueue.enqueue({ id: 2, name: 'ईमेल भेजें' });

1.3. लिंक्ड लिस्ट (Linked List)

लिंक्ड लिस्ट नोड्स से बनी होती है, जिनमें से प्रत्येक अगले नोड को संदर्भित करता है। ऐरे के विपरीत, सूची के बीच में तत्वों को सम्मिलित करने और हटाने के लिए सभी तत्वों को स्थानांतरित करने की आवश्यकता नहीं होती है।

class ListNode<T> {    value: T;    next: ListNode<T> | null = null;

    constructor(value: T) {        this.value = value;    }}

class LinkedList<T> {    private head: ListNode<T> | null = null;

    add(value: T): void {        const newNode = new ListNode(value);        if (!this.head) {            this.head = newNode;            return;        }        let current = this.head;        while (current.next) {            current = current.next;        }        current.next = newNode;    }

    print(): void {        let current = this.head;        while (current) {            console.log(current.value);            current = current.next;        }    }}

// उपयोगconst list = new LinkedList<string>();list.add('TypeScript');list.add('Python');list.print(); // TypeScript, Python

2. सॉर्टिंग और सर्चिंग एल्गोरिदम

डेटा को सॉर्ट करना सबसे सामान्य कार्यों में से एक है। TypeScript आपको सार्वभौमिक फ़ंक्शन बनाने की अनुमति देता है जो किसी भी प्रकार के डेटा के साथ काम करते हैं।