सरणी को जिग-ज़ैग फैशन में परिवर्तित करें


कठिनाई स्तर आसान
में अक्सर पूछा एक्सेंचर वीरांगना चौपाई Teradata ज़ोम
ऐरे

समस्या का विवरण

समस्या "ज़िग-ज़ैग फैशन में सरणी बदलें" बताती है कि आपको ए - पूर्णांकों का। समस्या का विवरण सरणी को एक zig-zag तरीके से क्रमबद्ध करने के लिए कहता है, ताकि सरणी के तत्व एए जैसे दिखेंगे  <b> c <d> e <f.

उदाहरण

arr[] = {2,4,5,1,7,6,8}
[2, 5, 1, 7, 4, 8, 6]

व्याख्या

5 1 और 2 (इसके आसन्न तत्वों) दोनों से अधिक है, 7 अपने आसन्न तत्वों दोनों से अधिक है, इसलिए 8 है।

कलन विधि

1. Mark flag is equal to true.
2. Traverse the array from 0 to n-2, where n is the length of the array.
  1. Check if the flag is true
    1. Check if the current element is greater than the next element.
      1. Swap those values.
    2. Else, check if the current element is greater than the next element,
      1. Check if the current element is lesser than the next element.
        1. Swap those values.
3. Flip the value of the flag.

व्याख्या

हमने ए सरणी of पूर्णांकों। हमारा काम एक ज़िग तरीके से सरणी को पुनर्व्यवस्थित करना है। हमने ऐसी स्थिति दी है कि संख्या तत्व भी इसके दो समीपवर्ती तत्वों से अधिक होने चाहिए, '<b> c <d> e <f '। हम यहाँ देख सकते हैं कि b और d इसके दो आसन्न तत्वों से अधिक हैं, 'a' और 'c' इसके दो आसन्न तत्वों की तुलना में कम हैं। हमारा काम इस तरह दिए गए एरे को व्यवस्थित करना है। इसके लिए, हम एरेस को ट्रेस करते हुए मानों को स्वैप करने जा रहे हैं, जैसे कि ज़िगज़ैग तरीके से व्यवस्थित किया गया हो।

हमें एक चिह्नित किया जाएगा बूलियन मान के लिए सही है, तो हम लूप का पता लगाने शुरू करने जा रहे हैं, और जांच लें कि झंडा सही है या नहीं। यदि यह सत्य है, तो हम वर्तमान मूल्य की जांच करेंगे यदि वर्तमान मूल्य उसके अगले मूल्य से अधिक है। फिर हम उन मूल्यों की अदला-बदली करने जा रहे हैं। और बूलियन मूल्यों को झूठे को चिह्नित करें। हमें बस इसके मूल्य को वापस लाना है, यदि यह सत्य है, तो इसे गलत पर अपडेट करें, यदि यह गलत है, तो इसे सच में अपडेट करें। इसलिए प्रत्येक वैकल्पिक ट्रैवर्सल के साथ, प्रत्येक पुनरावृत्ति के लिए अलग-अलग ध्वज मान होंगे। तो इसके साथ, केवल एक भाग निष्पादित होने वाला है, या तो भाग या अन्य भाग।

मूल्यों को स्वैप करने के लिए एक ही चीज हम दूसरे भाग के साथ करेंगे। यदि ट्रैवर्सल में सरणी का वर्तमान मान अगले मान से कम है। और ट्रैवर्सल के बाद, हमें केवल उस सरणी को प्रिंट करना होगा जिसमें हमने अपडेशन किए हैं।

सरणी को जिग-ज़ैग फैशन में परिवर्तित करें

 

कोड

C ++ कोड को Zig-Zag फैशन में सरणी में परिवर्तित करें

#include <iostream>

using namespace std;

void sortZigZag(int arr[], int n)
{
    bool flag = true;

    for (int i=0; i<=n-2; i++)
    {
        if (flag)
        {
            if (arr[i] > arr[i+1])
                swap(arr[i], arr[i+1]);
        }
        else
        {
            if (arr[i] < arr[i+1])
                swap(arr[i], arr[i+1]);
        }
        flag = !flag;
    }
}
int main()
{
    int arr[] = {2,4,5,1,7,6,8};
    int n = sizeof(arr)/sizeof(arr[0]);
    sortZigZag(arr, n);
    for (int i=0; i<n; i++)
        cout << arr[i] << " ";
    return 0;
}
2 5 1 7 4 8 6

जावा कोड को Zig-Zag फैशन में कन्वर्ट करें

import java.util.Arrays;

class zigzagArray
{
    public static void sortZigZag(int arr[])
    {
        boolean flag = true;

        int temp =0;

        for (int i=0; i<=arr.length-2; i++)
        {
            if (flag)
            {
                if (arr[i] > arr[i+1])
                {
                    temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }

            }
            else
            {
                if (arr[i] < arr[i+1])
                {
                    temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
            if(flag==true)
                flag=false;
            else
                flag=true;
        }
    }
    public static void main(String[] args)
    {
        int arr[] = {2,4,5,1,7,6,8};
        sortZigZag(arr);
        System.out.println(Arrays.toString(arr));
    }
}
[2, 5, 1, 7, 4, 8, 6]

जटिलता विश्लेषण

समय जटिलता

पर) जहां "N" सरणी में तत्वों की संख्या है। चूँकि हमने सरणी में तत्वों के बारे में पता लगाया है। समय जटिलता रैखिक है।

अंतरिक्ष जटिलता

ओ (1) के रूप में कोई अतिरिक्त स्थान की आवश्यकता है। चूंकि हमने किसी अतिरिक्त स्थान का उपयोग नहीं किया है, इसलिए अंतरिक्ष की जटिलता स्थिर है।