வரிசையை ஜிக்-ஜாக் பாணியில் மாற்றவும்  


சிரமம் நிலை எளிதாக
அடிக்கடி கேட்கப்படுகிறது அக்சன்சர் அமேசான் ஃபோர்கைட்டுகள் டெரடாட்டா Xome
அணி

சிக்கல் அறிக்கை  

“வரிசையை ஜிக்-ஜாக் பாணியாக மாற்று” என்ற சிக்கல் உங்களுக்கு வழங்கப்பட்டுள்ளது என்று கூறுகிறது - முழு எண்களின். சிக்கல் அறிக்கையானது வரிசையை ஒரு ஜிக்-ஜாக் முறையில் வரிசைப்படுத்த கேட்கிறது, அதாவது வரிசையில் உள்ள கூறுகள் like போல இருக்கும்  a <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 முழு. எங்கள் பணி வரிசையை ஒரு ஜிக்ஜாக் முறையில் மறுசீரமைப்பதாகும். எண் கூறுகள் கூட அதன் இரண்டு அருகிலுள்ள உறுப்புகளை விட அதிகமாக இருக்க வேண்டும் என்ற நிபந்தனையை நாங்கள் வழங்கியுள்ளோம்.a <b> c <d> e <f '. பி மற்றும் டி அதன் இரண்டு அருகிலுள்ள உறுப்புகளை விட பெரியவை என்பதை இங்கே காணலாம், 'அ' மற்றும் 'சி' அதன் இரண்டு அருகிலுள்ள உறுப்புகளை விட குறைவாக உள்ளன. கொடுக்கப்பட்ட வரிசையை இதுபோன்று ஏற்பாடு செய்வதே எங்கள் பணி. இதற்காக, வரிசைகளை கடந்து செல்லும்போது, ​​மதிப்புகளை மாற்றப் போகிறோம், இது ஒரு ஜிக்ஜாக் முறையில் ஏற்பாடு செய்யப்பட்டுள்ளது.

மேலும் காண்க
கொடுக்கப்பட்ட விரும்பிய வரிசையைப் பெற குறைந்தபட்ச படிகளை எண்ணுங்கள்

நாங்கள் ஒன்று குறிக்கப்படுவோம் பூலியன் உண்மைக்கு மதிப்பு, பின்னர் நாம் சுழற்சியைக் கடக்கத் தொடங்குவோம், மேலும் கொடி உண்மையா, இல்லையா என்பதைச் சரிபார்க்கவும். அது உண்மையாக இருந்தால், தற்போதைய மதிப்பு அதன் அடுத்த மதிப்பை விட அதிகமாக இருந்தால் தற்போதைய மதிப்பை சரிபார்க்கிறோம். நாம் அந்த மதிப்புகளை மாற்றப் போகிறோம். பூலியன் மதிப்புகளை தவறானதாகக் குறிக்கவும். நாம் அதன் மதிப்பை மாற்றியமைக்க வேண்டும், அது உண்மையாக இருந்தால், அதை பொய்யாக புதுப்பிக்கவும், அது தவறானதாக இருந்தால், அதை உண்மைக்கு புதுப்பிக்கவும். எனவே ஒவ்வொரு மாற்று பயணத்திலும், ஒவ்வொரு மறு செய்கைக்கும் வெவ்வேறு கொடி மதிப்புகள் இருக்கும். எனவே, இதன் மூலம், ஒரு பகுதி அல்லது வேறு பகுதியாக இருந்தால் மட்டுமே ஒரு பகுதி செயல்படுத்தப்படும்.

மதிப்புகளை மாற்றுவதற்கு, மற்ற பகுதியுடன் நாங்கள் செய்யப்படுவோம். ஒரு பயணத்தின் வரிசையின் தற்போதைய மதிப்பு அடுத்த மதிப்பை விட குறைவாக இருந்தால். பயணத்திற்குப் பிறகு, நாங்கள் புதுப்பித்தல்களை உருவாக்கிய வரிசையை அச்சிட வேண்டும்.

வரிசையை ஜிக்-ஜாக் பாணியில் மாற்றவும்முள்

 

குறியீடு  

வரிசையை ஜிக்-ஜாக் பாணியாக மாற்ற சி ++ குறியீடு

#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

வரிசையை ஜிக்-ஜாக் பாணியாக மாற்ற ஜாவா குறியீடு

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) எங்கே “N” என்பது வரிசையில் உள்ள உறுப்புகளின் எண்ணிக்கை. வரிசையில் உள்ள உறுப்புகளுக்கு மேல் நாம் பயணித்திருப்பதால். நேர சிக்கலானது நேரியல்.

மேலும் காண்க
அதிகரித்து வரும் அடுத்தடுத்த அதிகபட்ச தயாரிப்பு

விண்வெளி சிக்கலானது

ஓ (1) கூடுதல் இடம் தேவையில்லை என்பதால். நாங்கள் எந்த கூடுதல் இடத்தையும் பயன்படுத்தவில்லை என்பதால், இட சிக்கலானது நிலையானது.