Computer >> कंप्यूटर >  >> प्रोग्रामिंग >> C++

C++ में 2D मैट्रिक्स (पुनरावृत्तीय दृष्टिकोण) से एक लिंक्ड सूची का निर्माण करें


मान लीजिए कि हमारे पास एक मैट्रिक्स है, हमें इसे पुनरावृत्त दृष्टिकोण का उपयोग करके 2d लिंक्ड सूची में बदलना होगा। सूची में दाएँ और नीचे सूचक होंगे।

तो, अगर इनपुट पसंद है

10 20 30
40 50 60
70 80 90

तब आउटपुट होगा

C++ में 2D मैट्रिक्स (पुनरावृत्तीय दृष्टिकोण) से एक लिंक्ड सूची का निर्माण करें

इसे हल करने के लिए, हम इन चरणों का पालन करेंगे -

  • real_head :=NULL

  • एक सरणी को परिभाषित करें head_arr आकार का:मी.

  • इनिशियलाइज़ करने के लिए मैं :=0, जब i

    • head_arr[i] :=NULL

    • इनिशियलाइज़ j :=0 के लिए, जब j

      • p :=मान मैट के साथ नया ट्री नोड[i, j]

      • अगर real_head शून्य है, तो -

        • real_head :=p

      • अगर head_arr[i] शून्य है, तो -

        • head_arr[i] :=p

      • अन्यथा

        • right_ptr का अधिकार:=p

      • right_ptr :=p

  • इनिशियलाइज़ करने के लिए i:=0, जब i करें

    • p:=head_arr[i], q =head_arr[i + 1]

    • जबकि (p और q दोनों शून्य नहीं हैं), करते हैं -

      • पी के नीचे:=क्यू

      • p :=p के दाएँ

      • q :=q के दाएँ

  • real_head लौटाएं

उदाहरण

आइए बेहतर समझ पाने के लिए निम्नलिखित कार्यान्वयन देखें -

#include <bits/stdc++.h>
using namespace std;
class TreeNode {
   public:
   int data;
   TreeNode *right, *down;
   TreeNode(int d){
      data = d;
      right = down = NULL;
   }
};
void show_2d_list(TreeNode* head) {
   TreeNode *right_ptr, *down_ptr = head;
   while (down_ptr) {
      right_ptr = down_ptr;
      while (right_ptr) {
         cout << right_ptr->data << " ";
         right_ptr = right_ptr->right;
      }
      cout << endl;
      down_ptr = down_ptr->down;
   }
}
TreeNode* make_2d_list(int mat[][3], int m, int n) {
   TreeNode* real_head = NULL;
   TreeNode* head_arr[m];
   TreeNode *right_ptr, *p;
   for (int i = 0; i < m; i++) {
      head_arr[i] = NULL;
      for (int j = 0; j < n; j++) {
         p = new TreeNode(mat[i][j]);
         if (!real_head)
            real_head = p;
         if (!head_arr[i])
            head_arr[i] = p;
         else
            right_ptr->right = p;
         right_ptr = p;
      }
   }
   for (int i = 0; i < m - 1; i++) {
      TreeNode *p = head_arr[i], *q = head_arr[i + 1];
      while (p && q) {
         p->down = q;
         p = p->right;
         q = q->right;
      }
   }
   return real_head;
}
int main() {
   int m = 3, n = 3;
   int mat[][3] = {
      { 10, 20, 30 },
      { 40, 50, 60 },
      { 70, 80, 90 } };
   TreeNode* head = make_2d_list(mat, m, n);
   show_2d_list(head);
}

इनपुट

{ { 10, 20, 30 },
{ 40, 50, 60 },
{ 70, 80, 90 } }

आउटपुट

10 20 30
40 50 60
70 80 90

  1. सी ++ में एक लिंक्ड सूची को समतल करना

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

  1. C++ में एक बहुस्तरीय लिंक्ड सूची को समतल करें

    इस समस्या में, हमें एक बहुस्तरीय लिंक्ड सूची दी गई है। हमारा काम एक बहुस्तरीय लिंक्ड सूची को समतल करने के लिए एक प्रोग्राम बनाना है। फ़्लैटनिंग ऑपरेशन इस तरह से किया जाता है कि पहले स्तर के नोड्स पहले लिंक की गई सूची में होंगे और फिर दूसरे स्तर के नोड होंगे। बहुस्तरीय लिंक की गई सूची एक बहु-आयामी

  1. C++ में 2D मैट्रिक्स से एक लिंक्ड सूची का निर्माण करें

    मान लीजिए कि हमारे पास एक मैट्रिक्स है, हमें इसे पुनरावर्ती दृष्टिकोण का उपयोग करके 2d लिंक्ड सूची में बदलना होगा। सूची में दाएँ और नीचे सूचक होंगे। तो, अगर इनपुट पसंद है 10 20 30 40 50 60 70 80 90 तब आउटपुट होगा इसे हल करने के लिए, हम इन चरणों का पालन करेंगे - फ़ंक्शन को परिभाषित करें