క్రమంలో శ్రేణిని క్రమాన్ని మార్చండి - చిన్నది, అతిపెద్దది, 2 వ చిన్నది, 2 వ అతిపెద్దది


కఠినత స్థాయి మీడియం
తరచుగా అడుగుతుంది అమెజాన్ సిటాడెల్ Expedia ద్వారా GE హెల్త్ క్వాల్కమ్ Qualtrics Twilio యాత్ర
అర్రే సార్టింగ్

సమస్యల నివేదిక

మీకు పూర్ణాంక శ్రేణి ఉందని అనుకుందాం. “శ్రేణిని క్రమాన్ని క్రమాన్ని మార్చండి - అతిచిన్నది, అతి పెద్దది, 2 వ చిన్నది, 2 వ అతిపెద్దది ..” అనే శ్రేణి శ్రేణిని క్రమాన్ని మార్చమని అడుగుతుంది, తద్వారా అతిచిన్న సంఖ్య మొదట వస్తుంది మరియు తరువాత అతిపెద్ద సంఖ్య, తరువాత రెండవది చిన్నది మరియు రెండవది అతిపెద్ద మరియు మొదలైనవి.

ఉదాహరణ

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

వివరణ: అతిచిన్న సంఖ్య 1 మరియు అతిపెద్దది 9, 2nd 2 మరియు 2 గా చిన్నదిnd 8, 3 గా అతిపెద్దదిrd చిన్నది 3 మరియు 3rd అతిపెద్దది 7, 4 వ చిన్నది 3 మరియు 4 వ అతిపెద్దది 7. అందువల్ల ఫలిత ఉత్పత్తి సమస్యలో చెప్పిన విధంగానే అమర్చబడుతుంది.

క్రమాన్ని క్రమాన్ని క్రమాన్ని మార్చడానికి అల్గోరిథం - చిన్నది, అతి పెద్దది, 2 వ చిన్నది, 2 వ అతిపెద్దది

1. Sort the given array.
2. We have to use a temporary array, so declare one.
3. Set index to 0.
4. Traverse the array from left and from right, with i = 0 and j = n – 1 up the half of the array length.
    1. Store the value of arr[j] to the temporary[index] and increase the value of the index by 1.
    2. Store the value of arr[j] to the temporary[index] and increase the value of the index by 1.
5. Update the original array by storing the value of a temporary array to the original array.
6. At last, the original array should be printed.

వివరణ

యొక్క శ్రేణి ఇవ్వబడింది పూర్ణాంకాల. శ్రేణిని అతిచిన్న మరియు అతి పెద్ద సంఖ్యలో ఉండే విధంగా క్రమాన్ని మార్చమని మేము కోరాము అమరిక మొదటి మరియు రెండవ వరుసగా రావాలి. అప్పుడు 2nd అతిచిన్న మరియు 2 ఎమ్‌డి అతిపెద్ద సంఖ్య వరుసగా తదుపరి రావాలి, తరువాత దానిని కొనసాగించాలి, 3rd చిన్న మరియు 3rd అతిపెద్ద సంఖ్య క్రమంలో తదుపరి రావాలి. ఈ క్రమంలో, మేము శ్రేణిని క్రమాన్ని మార్చాలి. ఈ అవసరాన్ని నెరవేర్చడానికి మేము అదనపు శ్రేణిని ఉపయోగిస్తాము. ఇచ్చిన శ్రేణిని క్రమబద్ధీకరించండి, తద్వారా ప్రతి ఒక్కటి తగ్గని రీతిలో వస్తాయి.

శ్రేణిని క్రమబద్ధీకరించడం ద్వారా, మనకు వరుసగా ఒక సగం లో అతిచిన్న సంఖ్య మరియు శ్రేణిలో మరొక భాగంలో అతిపెద్ద సంఖ్య ఉన్నాయి. మనకు 1 నుండి 10 వరకు సంఖ్య ఉందని, యాదృచ్చికంగా శ్రేణిలో నిల్వ చేయబడిందని అనుకుందాం, మరియు వాటిని క్రమబద్ధీకరిస్తే, 1 నుండి 5 వరకు మొదటి భాగంలో మరియు 6 నుండి 10 రెండవ భాగంలో ఉంటుంది.

అదేవిధంగా ఇక్కడ, మనం ఇప్పుడు ఎడమ నుండి ప్రయాణించి విలువలను మనం సృష్టించిన శ్రేణిలో నిల్వ చేయవచ్చు. మేము ఎడమ నుండి ప్రారంభించినప్పటి నుండి, అతిచిన్న మూలకం మాత్రమే ఉంటుంది కాబట్టి మేము ఆ మూలకాన్ని తాత్కాలిక శ్రేణిలోకి చేర్చగలము. కాబట్టి మొదటి స్థానంలో, అతిచిన్న మూలకం మాత్రమే ఉంది. ఇప్పుడు కుడివైపు నుండి కదలండి, ఎందుకంటే శ్రేణి క్రమబద్ధీకరించబడినందున అతిపెద్ద మూలకం ఉండాలి కాబట్టి ఇప్పుడు మనం ఆ మూలకాన్ని తాత్కాలిక శ్రేణిలో ఉంచాము. మా మొట్టమొదటి చిన్నది మరియు పెద్దది పూర్తయింది, ఇప్పుడు మనం ఇంతకుముందు చేసినట్లుగా మరింత కదులుతున్నాం, మనం ఎడమ తదుపరి మూలకం నుండి కదిలి తాత్కాలిక శ్రేణికి నిల్వ చేయాలి, ఆపై కుడి వైపు నుండి రెండవ అతిపెద్ద మూలకాన్ని ఒక శ్రేణికి నిల్వ చేయాలి, ఈ పద్ధతిలో , మనకు కావలసిన ఫలితాన్ని సాధించవచ్చు. ఇప్పుడు ఆ శ్రేణిని ముద్రించండి.

క్రమంలో శ్రేణిని క్రమాన్ని మార్చండి - చిన్నది, అతిపెద్దది, 2 వ చిన్నది, 2 వ అతిపెద్దది

కోడ్

క్రమాన్ని క్రమాన్ని క్రమాన్ని మార్చడానికి సి ++ కోడ్ - చిన్నది, అతిపెద్దది, 2 వ చిన్నది, 2 వ అతిపెద్దది

#include<iostream>
#include<algorithm>

using namespace std;

void rearrangeInOrderSL(int arr[], int n)
{
    sort(arr, arr + n);

    int temporaryArray[n];

    int Index = 0;

    for (int i = 0, j = n-1; i <= n / 2 ||j > n / 2; i++, j--)
    {
        temporaryArray[Index] = arr[i];
        Index++;
        temporaryArray[Index] = arr[j];
        Index++;
    }
    for (int i = 0; i < n; i++)
        arr[i] = temporaryArray[i];

    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
}
int main()
{
    int arr[] = {1,4,6,2,3,8,9,7};
    int n = sizeof(arr) / sizeof(arr[0]);

    rearrangeInOrderSL(arr, n);

    return 0;
}
1 9 2 8 3 7 4 6

క్రమాన్ని క్రమాన్ని క్రమాన్ని మార్చడానికి జావా కోడ్ - చిన్నది, అతిపెద్దది, 2 వ చిన్నది, 2 వ అతిపెద్దది

import java.util.Arrays;
class rearrangeArraySL
{
    public static void rearrangeInOrderSL(int arr[], int n)
    {
        Arrays.sort(arr);

        int[] temporaryArray = new int[n];

        int Index = 0;

        for (int i = 0, j = n-1; i <= n / 2 || j > n / 2; i++, j--)
        {
            if(Index < n)
            {
                temporaryArray[Index] = arr[i];
                Index++;
            }

            if(Index < n)
            {
                temporaryArray[Index] = arr[j];
                Index++;
            }
        }
        for (int i = 0; i < n; i++)
            arr[i] = temporaryArray[i];
    }
    public static void main(String args[])
    {
        int arr[] = {1,4,6,2,3,8,9,7};
        int n = arr.length;
        rearrangeInOrderSL(arr, n);

        for (int i = 0; i < n; i++)
            System.out.print(arr[i]+" ");
    }
}
1 9 2 8 3 7 4 6

సంక్లిష్టత విశ్లేషణ

సమయం సంక్లిష్టత

O (N లాగ్ N) (ఇక్కడ  “ఎన్” శ్రేణిలోని మూలకాల సంఖ్య. మేము ఈ సమయంలో సంక్లిష్టతను కలిగి ఉన్న ఇన్పుట్ను క్రమబద్ధీకరించాము.

అంతరిక్ష సంక్లిష్టత

పై) (ఇక్కడ  “ఎన్” శ్రేణిలోని మూలకాల సంఖ్య. విధమైన విలీనం O (N) స్థలాన్ని తీసుకుంటుంది.