हमें एक पॉजिटिव इंटीजर टाइप ऐरे दिया गया है, मान लीजिए arr[] किसी भी दिए गए आकार का। कार्य ऐरे को इस तरह पुनर्व्यवस्थित करना है कि विषम इंडेक्स पर मौजूद सभी तत्वों का मान सम इंडेक्स पर मौजूद तत्व से बड़ा होना चाहिए और परिणाम प्रिंट करना है।
विभिन्न इनपुट आउटपुट परिदृश्य देखें
इनपुट - int arr[] = {2, 1, 5, 4, 3, 7, 8}
आउटपुट - व्यवस्था से पहले ऐरे: 2 1 5 4 3 7 8 इस तरह ऐरे का पुनर्व्यवस्थित करना कि प्रत्येक विषम इंडेक्स वाला तत्व अपने पिछले से बड़ा है: 1 4 2 5 3 8 7
व्याख्या - हमें आकार 7 का एक इंटीजर ऐरे दिया गया है। अब, हम सम इंडेक्स पर तत्वों को विषम इंडेक्स पर तत्वों के साथ स्वैप करेंगे यदि सम इंडेक्स वाले तत्व बड़े हैं यानी
Arr[0] > arr[1] = स्वैप कॉल करें = {1, 2, 5, 4, 3, 7, 8}
Arr[2] > arr[3] = स्वैप कॉल करें = {1, 2, 4, 5, 3, 7, 8}
Arr[6] > arr[5] = स्वैप कॉल करें = {1, 2, 4, 5, 3, 8, 7}
Arr[2] > arr[1] = स्वैप कॉल करें = {1, 4, 2, 5, 3, 8, 7}
इनपुट - int arr[] = {3, 2, 6, 9}
आउटपुट - व्यवस्था से पहले ऐरे: 3 2 6 9 इस तरह ऐरे का पुनर्व्यवस्थित करना कि प्रत्येक विषम इंडेक्स वाला तत्व अपने पिछले से बड़ा है: 2 3 6 9
व्याख्या - हमें आकार 4 का एक इंटीजर ऐरे दिया गया है। अब, हम सम इंडेक्स पर तत्वों को विषम इंडेक्स पर तत्वों के साथ स्वैप करेंगे यदि सम इंडेक्स वाले तत्व बड़े हैं यानी Arr[0] > arr[1] = स्वैप कॉल करें = {2, 3, 6, 9}। स्वैप मेथड को आगे कॉल करने की आवश्यकता नहीं है क्योंकि सभी तत्व स्थितियों पर शर्तों को संतुष्ट करते हैं।
नीचे दिए गए प्रोग्राम में प्रयुक्त दृष्टिकोण
इंटीजर टाइप तत्वों का एक ऐरे इनपुट करें और ऐरे का आकार गणना करें।
व्यवस्था से पहले ऐरे प्रिंट करें और फंक्शन Rearrangement(arr, size) कॉल करें
फंक्शन Rearrangement(arr, size) के अंदर
एक इंटीजर टाइप वेरिएबल बनाएं, मान लीजिए ptr और इसे size-1 से सेट करें।
फॉर लूप शुरू करें, i से 0 तक जब तक i, ptr से कम है और i = i + 2। लूप के अंदर, जांचें कि क्या arr[i], arr[i+1] से बड़ा है तो swap(arr[i], arr[i+1]) कॉल करें।
जांचें IF size & 1 तो फॉर लूप शुरू करें i से ptr तक जब तक i, 0 से बड़ा है और i = i - 2। लूप के अंदर, जांचें IF arr[i], arr[i-1] से बड़ा है तो swap(arr[i], arr[i-1]) कॉल करें
ऐरे के मानों के पुनर्व्यवस्थित होने के बाद ऐरे प्रिंट करें।
उदाहरण
#include <iostream>
using namespace std;
void Rearrangement(int arr[], int size) {
int ptr = size - 1;
for (int i = 0; i < ptr; i = i + 2) {
if (arr[i] > arr[i+1]) {
swap(arr[i], arr[i+1]);
}
}
if (size & 1) {
for (int i = ptr; i > 0; i = i - 2) {
if (arr[i] > arr[i-1]) {
swap(arr[i], arr[i-1]);
}
}
}
}
int main() {
// ऐरे इनपुट करें
int arr[] = {2, 1, 5, 4, 3, 7, 8};
int size = sizeof(arr) / sizeof(arr[0]);
// मूल ऐरे प्रिंट करें
cout << "व्यवस्था से पहले ऐरे: ";
for (int i = 0; i < size; i++) {
cout << arr[i] << " ";
}
// ऐरे को पुनर्व्यवस्थित करने के लिए फंक्शन कॉल करना
Rearrangement(arr, size);
// मानों को पुनर्व्यवस्थित करने के बाद ऐरे प्रिंट करें
cout << "\nइस तरह ऐरे का पुनर्व्यवस्थित करना कि प्रत्येक विषम इंडेक्स वाला तत्व अपने पिछले से बड़ा है: ";
for (int i = 0; i < size; i++) {
cout << arr[i] << " ";
}
return 0;
}
आउटपुट
यदि हम उपरोक्त कोड चलाते हैं तो यह निम्नलिखित आउटपुट उत्पन्न करेगा
व्यवस्था से पहले ऐरे: 2 1 5 4 3 7 8 इस तरह ऐरे का पुनर्व्यवस्थित करना कि प्रत्येक विषम इंडेक्स वाला तत्व अपने पिछले से बड़ा है: 1 4 2 5 3 8 7