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

C++ में एल्गोरिदम और डेटा संरचनाएँ: बुनियादी से उन्नत तकनीकों तक

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

हम तीन मुख्य समूहों पर विचार करेंगे: रैखिक डेटा संरचनाएँ (arrays, lists, stacks, queues), पदानुक्रमिक संरचनाएँ (trees) और प्रसंस्करण एल्गोरिदम (sorting और searching)। प्रत्येक अनुभाग में C++ में तैयार कोड और स्पष्टीकरण शामिल हैं।

1. रैखिक डेटा संरचनाएँ: arrays, linked lists, stack और queue

रैखिक संरचनाएँ वह आधार हैं जहाँ से डेटा के साथ काम शुरू होता है। C++ में, वे अंतर्निहित साधनों और उपयोगकर्ता-परिभाषित क्लासेस दोनों के माध्यम से कार्यान्वित की जाती हैं।

Arrays और dynamic arrays (std::vector)

Array निश्चित आकार वाली सबसे सरल संरचना है। लचीलेपन के लिए std::vector का उपयोग करें:

#include <iostream>#include <vector>

int main() {    std::vector<int> numbers = {5, 2, 8, 1, 9};        // एलिमेंट जोड़ना    numbers.push_back(3);        // इंडेक्स द्वारा एक्सेस    std::cout << "तीसरा एलिमेंट: " << numbers[2] << std::endl;        // ट्रैवर्सल    for (int num : numbers) {        std::cout << num << " ";    }    return 0;}

लाभ: तेज़ एक्सेस O(1), कैश-लोकैलिटी। नुकसान: बीच में इन्सर्शन/डिलीट — O(n)।

Singly linked list

लिस्ट नोड्स से बनी होती है, प्रत्येक डेटा और अगले एलिमेंट का पॉइंटर संग्रहीत करता है। C++ में कार्यान्वयन:

struct Node {    int data;    Node* next;        Node(int val) : data(val), next(nullptr) {}};

class LinkedList {private:    Node* head;public:    LinkedList() : head(nullptr) {}        void pushFront(int val) {        Node* newNode = new Node(val);        newNode->next = head;        head = newNode;    }        void print() {        Node* current = head;        while (current) {            std::cout << current->data << " -> ";            current = current->next;        }        std::cout << "nullptr" << std::endl;    }        ~LinkedList() {        Node* current = head;        while (current) {            Node* next = current->next;            delete current;            current = next;        }    }};

कब उपयोग करें: लिस्ट की शुरुआत में बार-बार इन्सर्शन/डिलीट। सर्च — O(n)।

Stack और Queue

Stack (LIFO) और Queue (FIFO) विशेष संरचनाएँ हैं। C++ में तैयार एडेप्टर हैं:

#include <stack>#include <queue>

int main() {    // Stack    std::stack<int> st;    st.push(10);    st.push(20);    std::cout << "स्टैक का शीर्ष: " << st.top() << std::endl; // 20    st.pop();        // Queue    std::queue<int> q;    q.push(1);    q.push(2);    std::cout << "क्यू में पहला: " << q.front() << std::endl; // 1    q.pop();        return 0;}

2. पदानुक्रमिक संरचनाएँ: बाइनरी सर्च ट्री

ट्री पदानुक्रमिक डेटा को कुशलतापूर्वक संग्रहीत करने की अनुमति देते हैं। बाइनरी सर्च ट्री (BST) C++ में एल्गोरिदम का एक क्लासिक है।

BST का कार्यान्वयन

struct TreeNode {    int key;    TreeNode* left;    TreeNode* right;        TreeNode(int k) : key(k), left(nullptr), right(nullptr) {}};

TreeNode* insert(TreeNode* root, int key) {    if (!root) return new TreeNode(key);        if (key < root->key)        root->left =
```