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

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

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

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

स्टैक और क्यू मूलभूत संरचनाएँ हैं जिनका उपयोग सर्वव्यापी है: फ़ंक्शन कॉल प्रोसेसिंग से लेकर ब्राउज़र में कार्य प्रबंधन तक।

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

स्टैक "अंतिम आया, पहला गया" सिद्धांत पर काम करता है। इसे एरे और TypeScript जेनेरिक का उपयोग करके लागू करते हैं:

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;    }

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

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

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

क्यू "पहला आया, पहला गया" सिद्धांत पर काम करता है। TypeScript में कार्यान्वयन:

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];    }

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

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

// उपयोग का उदाहरणconst stringQueue = new Queue<string>();stringQueue.enqueue('A');stringQueue.enqueue('B');console.log(stringQueue.dequeue()); // 'A'console.log(stringQueue.front());   // 'B'

महत्वपूर्ण: JavaScript में shift() ऑपरेशन की जटिलता O(n) है, क्योंकि यह सभी तत्वों को स्थानांतरित करता है। अधिक कुशल क्यू के लिए, लिंक्ड लिस्ट या सर्कुलर बफर का उपयोग करें।

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

लिंक्ड लिस्ट नोड्स का एक अनुक्रम है, जहाँ प्रत्येक नोड डेटा और अगले नोड के संदर्भ को संग्रहीत करता है। TypeScript में, हम सख्त टाइपिंग के लिए इंटरफेस का उपयोग कर सकते हैं।

interface ListNode<T> {    value: T;    next: ListNode<T> | null;}

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

    append(value: T): void {        const newNode: ListNode<T> = { value, next: null };        if (!this.head) {            this.head = newNode;            return;        }        let current = this.head;        while (current.next) {            current = current.next;        }        current.next = newNode;    }

    prepend(value: T): void {        const newNode: ListNode<T> = { value, next: this.head };        this.head = newNode;    }

    delete(value: T): void {        if (!this.head) return;        if (this.head.value === value) {            this.head = this.head.next;            return;        }        let current = this.head;        while (current.next) {            if (current.next.value === value) {                current.next = current.next.next;                return;            }            current = current.next;        }    }

    print(): void {        let current = this.head;        const values: T[] = [];