सी ++ में समानांतर सरणी

समानांतर सरणी को संरचना सरणी भी कहा जाता है।

परिभाषा - एक समानांतर सरणी को कई सरणियों के रूप में परिभाषित किया जा सकता है जिसमें ith तत्व निकट से संबंधित होते हैं, और साथ में, वे एक इकाई का गठन करते हैं। सी ++ भाषा में एक सरणी एक मौलिक विशेषता है। समानांतर सरणियाँ बनाने से हमें दो या अधिक सरणियों की तुलना करने में मदद मिलती है।

उदाहरण के लिए,

first_name = ['John', 'Dexter', 'Fredd', 'Hank', 'james']
last_name = ['Jocab', 'Jonas', 'smith', 'lee', 'banner']
height = [160, 148, 231, 153, 162]

समानांतर सरणी बनाने का तरीका

समानांतर सरणी बनाने के लिए खोज और छँटाई कुछ आवश्यक सुविधाएँ हैं।

खोज

खोज एक इकाई के विशिष्ट मूल्यों पर आधारित है। उदाहरण के लिए, हमें उस व्यक्ति का पता खोजने की आवश्यकता है जिसकी ऊंचाई 180 सेमी से कम है। इसलिए हम 180 से कम मान वाले ऊंचाई सरणी के मानदंड खोजते हैं। अंत में, जब हमें परिणाम मिलते हैं, तो हम उन्हें प्रिंट कर सकते हैं।

खोज करने के लिए हम इन चरणों का पालन कर सकते हैं।

• संबंधित सरणी में आवश्यक मान खोजें

• इंडेक्स को स्टोर करें जहां मान प्राप्त होते हैं।

• मान प्रिंट करें।

क्रमबद्ध करना

छँटाई, हम सभी सरणियों को एक ही सूचकांक और मूल्यों के साथ क्रमबद्ध करते हैं। उदाहरण के लिए, हमें ऊंचाई सूचकांक को आरोही क्रम में क्रमबद्ध करने की आवश्यकता है। इसलिए जब हम दो ऊंचाइयों की अदला-बदली करते हैं, तो हम उनके मूल्यों को अन्य सरणियों में भी स्वैप करते हैं। हम सरणियों को संख्यात्मक या वर्णानुक्रम में क्रमबद्ध कर सकते हैं।

किसी सरणी को क्रमबद्ध करने के लिए हमें इन चरणों का पालन करना होगा।

• सरणी में अनुक्रमणिका खोजें।

• अब सभी सरणियों के 2 परिकलित सूचकांकों के मानों की अदला-बदली करें।

कार्यान्वयन

• दिया गया कोड नाम, दूसरा नाम और ऊंचाई संग्रहीत करता है।

• दिया गया कोड नाम, दूसरा नाम और ऊंचाई संग्रहीत करता है।

• हमें दूसरे सबसे बड़े छात्र, तीसरे सबसे छोटे छात्र का नाम खोजना होगा।

फिर रिकॉर्ड में छात्र की ऊंचाई 158 सेमी के बराबर है।

उदाहरण

#include <iostream>
using namespace std;
int partition(string first_name[], string
last_name[],
int height[], int low, int high){
   int pivot = height[high]; // pivot
   int i = (low - 1); // Index of smaller element
   for (int j = low; j <= high - 1; j++) {
      if (height[j] <= pivot) {
         i++;
         string temp = first_name[i];
         first_name[i] = first_name[j];
         first_name[j] = temp;
         temp = last_name[i];
         last_name[i] = last_name[j];
         last_name[j] = temp;
         int temp1 = height[i];
         height[i] = height[j];
         height[j] = temp1;
      }
   }
   string temp = first_name[i + 1];
   first_name[i + 1] = first_name[high];
   first_name[high] = temp;
   temp = last_name[i + 1];
   last_name[i + 1] = last_name[high];
   last_name[high] = temp;
   int temp1 = height[i + 1];
   height[i + 1] = height[high];
   height[high] = temp1;
   return (i + 1);
}
void quickSort(string first_name[], string last_name[],
int height[], int low, int high){
   if (low < high) {
      int pi = partition(first_name, last_name, height, low, high);
      quickSort(first_name, last_name, height, low, pi - 1);
      quickSort(first_name, last_name, height, pi + 1, high);
   }
}
void binarySearch(string first_name[], string
last_name[],
int height[], int value, int n){
   int low = 0, high = n - 1;
   int index;
   while (low <= high) {
      index = (high + low) / 2;
      if (height[index] == 158) {
         cout << "Person having height 158"
         " cms is "
         << first_name[index]
         << " " << last_name[index] << endl;
         return;
      }
      else if (height[index] > 158)
         high = index - 1;
      else
         low = index + 1;
   }
   cout << "Sorry, no such person with"
   " height 158 cms";
   cout << "is found in the record";
}
void printParallelArray(string first_name[],
string last_name[], int height[], int n){
   cout << "Name of people in increasing";
   cout << "order of their height: " << endl;
   for (int i = 0; i < n; i++) {
      cout << first_name[i] << " "
      << last_name[i] << " has height "
      << height[i] << " cms\n";
   }
   cout << endl;
}
int main(){
   int n = 4;
   string first_name[] = { "John", "Dexter", "Fredd", "Hank", "james"};
   string last_name[] = { "Jocab", "Jonas", "smith", "lee", "banner"};
   int height[] = {160, 148, 231, 153, 162};
   quickSort(first_name, last_name, height, 0, n - 1);
   printParallelArray(first_name, last_name, height, n);
   cout << "Name of the second tallest person" " is "
   << first_name[n - 2] << " "
   << last_name[n - 2] << endl;
   cout << "Name of the third shortest person is "
   << first_name[2] << " " << last_name[2]
   << endl;
   binarySearch(first_name, last_name, height, 158, n);
   return 0;
}

आउटपुट

Name of people in increasingorder of their height:
Dexter Jonas has height 148 cms
Hank lee has height 153 cms
John Jocab has height 160 cms
Fredd smith has height 231 cms

Name of the second tallest person is John Jocab
Name of the third shortest person is John Jocab
Sorry, no such person with height 158 cmsis found in the record

समानांतर सरणी के लाभ

• कुछ मामलों में, वे संरेखण मुद्दों से बचकर महत्वपूर्ण मात्रा में स्थान बचा सकते हैं। कुछ आर्किटेक्चर, उदाहरण के लिए, सबसे अच्छा काम करते हैं यदि 4-बाइट पूर्णांक हमेशा स्मृति स्थानों पर संग्रहीत होते हैं जो 4 के गुणक होते हैं। यदि पिछला फ़ील्ड एक बाइट था, तो यह 3 बाइट दूर फेंक सकता था। कई आधुनिक कंपाइलर स्वचालित रूप से ऐसे मुद्दों से बच सकते हैं। फिर भी, अतीत में, कुछ प्रोग्रामर स्पष्ट रूप से संरेखण बाधाओं के घटते क्रम में फ़ील्ड घोषित करते थे।

• जब किसी ऐरे में आइटम्स की संख्या कम होती है, तो ऐरे इंडेक्स पूरे पॉइंटर्स की तुलना में बहुत कम जगह ले सकते हैं, खासकर कुछ आर्किटेक्चर पर।

• क्रम में जांच की गई

• सरणी में प्रत्येक रिकॉर्ड के एकल फ़ील्ड की क्रमिक रूप से जांच करना आधुनिक मशीनों पर तेज़ है क्योंकि यह संदर्भ और कैश व्यवहार के आदर्श स्थान के साथ एकल सरणी के रैखिक ट्रैवर्सल के बराबर है।

समानांतर सरणी के नुकसान

• चूंकि विभिन्न सरणियों को बेतरतीब ढंग से दूर-दूर तक संग्रहीत किया जा सकता है, इसलिए गैर-क्रमिक रूप से रिकॉर्ड पर जाने और प्रत्येक रिकॉर्ड के कई क्षेत्रों की जांच करने पर उनके संदर्भ की स्थिति काफी खराब होती है।

• वे एक ही रिकॉर्ड में फ़ील्ड के बीच कनेक्शन को अस्पष्ट करते हैं (उदाहरण के लिए, उनके बीच इंडेक्स से संबंधित कोई जानकारी नहीं है, जिसका दुरुपयोग किया जा सकता है)।

• उनके पास थोड़ी सी सीधी भाषा सहायता है (भाषा और इसका सिंटैक्स आमतौर पर समानांतर सरणी में सरणियों के बीच कोई संबंध नहीं व्यक्त करता है और त्रुटियों को पकड़ नहीं सकता है)।

• क्योंकि खेतों को इकट्ठा करना कोई "चीज" नहीं है, इसे इधर-उधर करना समय लेने वाला और त्रुटि-प्रवण है। उदाहरण के लिए, फ़ंक्शन को एक रिकॉर्ड (या संरचना या ऑब्जेक्ट) पर कार्य करने के लिए फ़ंक्शन को कॉल करने के बजाय फ़ील्ड को अलग तर्क के रूप में स्वीकार करना चाहिए। जब कोई नया फ़ील्ड जोड़ा या बदला जाता है, तो कई पैरामीटर सूचियाँ बदलनी चाहिए। इसके विपरीत, वस्तुओं को समग्र रूप से पास करने से ऐसे परिवर्तनों से पूरी तरह बचा जा सकेगा।

• उनका विस्तार या अनुबंध करना महंगा है क्योंकि कई सरणियों में से प्रत्येक को फिर से आवंटित किया जाना चाहिए। बहु-स्तरीय सरणियाँ इस समस्या में मदद कर सकती हैं, लेकिन वांछित तत्वों को खोजने के लिए आवश्यक अतिरिक्त अप्रत्यक्षता के कारण वे प्रदर्शन को नुकसान पहुँचाते हैं।

निष्कर्ष

इस ट्यूटोरियल में, हमने सीखा कि c++ कोड के साथ समानांतर ऐरे कैसे बनाया जाता है। हम इस कोड को जावा, पायथन और अन्य भाषाओं में भी लिख सकते हैं। Arrays C++ प्रोग्रामिंग लैंग्वेज की मूलभूत और सबसे उपयोगी विशेषताओं में से एक है। उनका उपयोग विभिन्न उद्देश्यों के लिए किया जाता है, जैसे छँटाई और खोज। हमें उम्मीद है कि आपको यह ट्यूटोरियल मददगार लगा होगा।