C++ का उपयोग करके सॉर्टेड एरे को अधिकतम-न्यूनतम रूप में पुनर्व्यवस्थित करना

हमें एक सॉर्टेड एरे दिया गया है। हमें इस एरे को अधिकतम-न्यूनतम रूप में व्यवस्थित करना है, यानी पहला तत्व अधिकतम तत्व होगा, दूसरा तत्व न्यूनतम तत्व, तीसरा तत्व दूसरा अधिकतम, चौथा तत्व दूसरा न्यूनतम, और इसी तरह। उदाहरण के लिए:

इनपुट: arr[] = {10, 20, 30, 40, 50, 60}
आउटपुट: {60, 10, 50, 20, 40, 30}
व्याख्या: एरे को {1st max, 1st min, 2nd max, 2nd min, 3rd max, 3rd min} रूप में पुनर्व्यवस्थित किया गया है।

इनपुट: arr[] = {15, 17, 19, 23, 36, 67, 69}
आउटपुट: {69, 15, 67, 17, 36, 19, 23}

समाधान का दृष्टिकोण

टू-पॉइंटर दृष्टिकोण

दो वेरिएबल min और max का उपयोग करें जो क्रमशः न्यूनतम और अधिकतम तत्व की ओर इंगित करेंगे। साथ ही, पुनर्व्यवस्थित एरे को स्टोर करने के लिए समान आकार का एक नया खाली एरे बनाएं। अब एरे पर पुनरावृति करें, और यदि पुनरावृत्त तत्व सम इंडेक्स पर है, तो खाली एरे में arr[max] तत्व जोड़ें और max को 1 से घटाएं। यदि तत्व विषम इंडेक्स पर है, तो arr[min] तत्व जोड़ें और min को 1 से बढ़ाएं। इसे तब तक करें जब तक max, min से छोटा न हो जाए।

उदाहरण

#include <bits/stdc++.h>
using namespace std;

int main() {
    int arr[] = {1, 2, 3, 4, 5, 6};
    int n = sizeof(arr) / sizeof(arr[0]);
    
    // पुनर्व्यवस्थित एरे को स्टोर करने के लिए नया एरे बनाना
    int final[n];
    
    // प्रारंभिक और अंतिम तत्व इंडेक्स की ओर इंगित करने वाले वेरिएबल
    int min = 0, max = n - 1;
    int count = 0;
    
    // एरे पर तब तक पुनरावृति जब तक max, min से कम या बराबर है
    for (int i = 0; min <= max; i++) {
        // यदि count सम है तो max इंडेक्स का तत्व स्टोर करें
        if (count % 2 == 0) {
            final[i] = arr[max];
            max--;
        }
        // अन्यथा min इंडेक्स का तत्व स्टोर करें
        else {
            final[i] = arr[min];
            min++;
        }
        count++;
    }
    
    // अंतिम पुनर्व्यवस्थित एरे प्रिंट करना
    for (int i = 0; i < n; i++)
        cout << final[i] << " ";
    
    return 0;
}

आउटपुट

6 1 5 2 4 3

कोड की व्याख्या

• वेरिएबल इनिशियलाइज़ किए गए: min=0 और max = एरे_लंबाई(n) - 1।
• for (int i = 0; min <= max; i++) लूप एरे पर तब तक पुनरावृति करता है जब तक max, min से बड़ा नहीं हो जाता।
• यदि count सम है, तो max इंडेक्स का तत्व अंतिम एरे में जोड़ा जाता है, और max 1 से घटाया जाता है।
• यदि count विषम है, तो min इंडेक्स का तत्व अंतिम एरे में जोड़ा जाता है, और min 1 से बढ़ाया जाता है।
• अंत में, परिणामी एरे final[] में स्टोर हो जाता है।

निष्कर्ष

इस लेख में, हमने दिए गए एरे को मैक्स-मिन रूप में पुनर्व्यवस्थित करने के समाधान पर चर्चा की। हमने समाधान के दृष्टिकोण पर चर्चा की और इसे O(n) समय जटिलता के साथ एक इष्टतम समाधान के साथ हल किया। हमने इसके लिए C++ प्रोग्राम भी लिखा। इसी तरह, हम इस प्रोग्राम को C, Java, Python आदि किसी भी अन्य भाषा में लिख सकते हैं। आशा है कि आपको यह लेख मददगार लगा होगा।