അറേയെ സിഗ്-സാഗ് ഫാഷനായി പരിവർത്തനം ചെയ്യുക


വൈഷമ്യ നില എളുപ്പമായ
പതിവായി ചോദിക്കുന്നു ഓട്ടോമോട്ടീവ് ആമസോൺ ഫോർകൈറ്റുകൾ തെരദത സോം
അറേ

പ്രശ്നം പ്രസ്താവന

“അറേയെ സിഗ്-സാഗ് ഫാഷനായി പരിവർത്തനം ചെയ്യുക” എന്ന പ്രശ്നം നിങ്ങൾക്ക് ഒരു നൽകിയിട്ടുണ്ടെന്ന് പറയുന്നു - പൂർണ്ണസംഖ്യകളുടെ. പ്രശ്ന പ്രസ്താവന അറേയെ ഒരു സിഗ്-സാഗ് രീതിയിൽ അടുക്കാൻ ആവശ്യപ്പെടുന്നു, അതായത് അറേയിലെ ഘടകങ്ങൾ like പോലെ കാണപ്പെടും  a <b> സി <d> ഇ <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 പൂർണ്ണസംഖ്യകൾ. അറേ ഒരു സിഗ്‌സാഗ് രീതിയിൽ പുന ar ക്രമീകരിക്കുക എന്നതാണ് ഞങ്ങളുടെ ചുമതല. സംഖ്യ ഘടകങ്ങൾ പോലും അതിന്റെ സമീപത്തുള്ള രണ്ട് മൂലകങ്ങളേക്കാൾ വലുതായിരിക്കേണ്ട ഒരു വ്യവസ്ഥ ഞങ്ങൾ നൽകിയിട്ടുണ്ട്.a <b> സി <d> ഇ <f '. B, d എന്നിവ അതിന്റെ രണ്ട് സമീപ മൂലകങ്ങളേക്കാൾ വലുതാണെന്ന് നമുക്ക് ഇവിടെ കാണാൻ കഴിയും, 'a', 'c' എന്നിവ അതിന്റെ രണ്ട് സമീപ മൂലകങ്ങളേക്കാൾ കുറവാണ്. തന്നിരിക്കുന്ന അറേ ഇതുപോലെ ക്രമീകരിക്കുക എന്നതാണ് ഞങ്ങളുടെ ചുമതല. ഇതിനായി, ഞങ്ങൾ മൂല്യങ്ങൾ സ്വാപ്പ് ചെയ്യാൻ പോകുന്നു, അറേയിലൂടെ സഞ്ചരിക്കുമ്പോൾ, അത് ഒരു സിഗ്സാഗ് രീതിയിൽ ക്രമീകരിച്ചിരിക്കുന്നു.

ഞങ്ങളെ ഒന്ന് അടയാളപ്പെടുത്തും ബൂളിയൻ മൂല്യം മുതൽ ശരി വരെ, തുടർന്ന് ഞങ്ങൾ ലൂപ്പിലൂടെ സഞ്ചരിക്കാൻ തുടങ്ങും, കൂടാതെ ഫ്ലാഗ് ശരിയാണോ എന്ന് പരിശോധിക്കുക. ഇത് ശരിയാണെങ്കിൽ, നിലവിലെ മൂല്യം അതിന്റെ അടുത്ത മൂല്യത്തേക്കാൾ വലുതാണോയെന്ന് ഞങ്ങൾ നിലവിലെ മൂല്യത്തിനായി പരിശോധിക്കും. അപ്പോൾ ഞങ്ങൾ ആ മൂല്യങ്ങൾ സ്വാപ്പ് ചെയ്യാൻ പോകുന്നു. ബൂളിയൻ മൂല്യങ്ങൾ തെറ്റാണെന്ന് അടയാളപ്പെടുത്തുക. നമ്മൾ അതിന്റെ മൂല്യം പഴയപടിയാക്കേണ്ടതുണ്ട്, അത് ശരിയാണെങ്കിൽ, അത് തെറ്റായി അപ്‌ഡേറ്റുചെയ്യുക, അത് തെറ്റാണെങ്കിൽ, അത് സത്യത്തിലേക്ക് അപ്‌ഡേറ്റുചെയ്യുക. അതിനാൽ ഓരോ ഇതര ട്രാവെർസലിലും, ഓരോ ആവർത്തനത്തിനും വ്യത്യസ്ത ഫ്ലാഗ് മൂല്യങ്ങൾ ഉണ്ടാകും. അതിനാൽ, ഇതുപയോഗിച്ച്, ഒരു ഭാഗം മാത്രമേ നടപ്പിലാക്കാൻ പോകുകയുള്ളൂ.

മൂല്യങ്ങൾ സ്വാപ്പ് ചെയ്യുന്നതിന്, മറ്റേ ഭാഗവുമായി ഞങ്ങൾ ചെയ്യും. ഒരു ട്രാവെർസലിലെ അറേയുടെ നിലവിലെ മൂല്യം അടുത്ത മൂല്യത്തേക്കാൾ കുറവാണെങ്കിൽ. ട്രാവെർസലിനുശേഷം, ഞങ്ങൾ അപ്‌ഡേറ്റുകൾ വരുത്തിയ അറേ പ്രിന്റുചെയ്യേണ്ടതുണ്ട്.

അറേയെ സിഗ്-സാഗ് ഫാഷനായി പരിവർത്തനം ചെയ്യുക

 

കോഡ്

അറേയെ സിഗ്-സാഗ് ഫാഷനായി പരിവർത്തനം ചെയ്യുന്നതിനുള്ള സി ++ കോഡ്

#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]

സങ്കീർണ്ണത വിശകലനം

സമയ സങ്കീർണ്ണത

O (n) എവിടെ “N” അറേയിലെ ഘടകങ്ങളുടെ എണ്ണം. അറേയിലെ ഘടകങ്ങളെ മറികടന്ന് ഞങ്ങൾ സഞ്ചരിച്ചതിനാൽ. സമയ സങ്കീർണ്ണത രേഖീയമാണ്.

ബഹിരാകാശ സങ്കീർണ്ണത

O (1) അധിക ഇടം ആവശ്യമില്ലാത്തതിനാൽ. ഞങ്ങൾ അധിക സ്ഥലമൊന്നും ഉപയോഗിച്ചിട്ടില്ലാത്തതിനാൽ, സ്ഥല സങ്കീർണ്ണത സ്ഥിരമാണ്.