ਐਰੇ ਨੂੰ ਦੁਬਾਰਾ ਪ੍ਰਬੰਧ ਕਰੋ ਜਿਵੇਂ ਕਿ ਪੋਜੀਸ਼ਨਡ ਵੀ ਅਜੀਬ ਤੋਂ ਵੱਡਾ ਹੁੰਦਾ ਹੈ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਸੌਖੀ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ ਐਮਾਜ਼ਾਨ ਸਬੰਧਤ ਓਏ ਕਮਰੇ ਟਾਈਮਜ਼ ਇੰਟਰਨੈੱਟ ਜੋਹੋ
ਅਰੇ ਦੁਬਾਰਾ ਪ੍ਰਬੰਧ ਕਰੋ ਲੜੀਬੱਧ

ਸਮੱਸਿਆ ਦਾ ਬਿਆਨ

ਮੰਨ ਲਓ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ਪੂਰਨ ਅੰਕ ਹੈ. ਸਮੱਸਿਆ ਨੂੰ “ਐਰੇਰੇਜ ਐਰੇ ਜਿਵੇਂ ਕਿ ਪੋਜੀਸ਼ਨਡ ਵੀ ਅਜੀਬ ਨਾਲੋਂ ਵੱਡਾ ਹੁੰਦਾ ਹੈ” ਐਰੇ ਨੂੰ ਪੁਨਰ ਪ੍ਰਬੰਧਿਤ ਕਰਨ ਲਈ ਕਹਿੰਦਾ ਹੈ ਐਰੇ ਵਿਚਲੀ ਸਥਿਤੀ ਤੇ ਐਲੀਮੈਂਟਸ ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਦੇ ਤੱਤ ਤੋਂ ਵੀ ਵੱਡਾ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ.

ਅਰਰ [i-1] <= ਅਰਰ [i], ਜੇ ਸਥਿਤੀ 'i' ਅਜੀਬ ਹੈ.

ਅਰਰ [i-1]> = ਅਰਰ [i], ਜੇ ਸਥਿਤੀ 'i' ਸਮਾਨ ਹੈ.

ਉਦਾਹਰਨ

Arr[] = {1, 4, 5, 2, 7}
1 7 2 5 4

ਵਿਆਖਿਆ: ਇਥੋਂ ਤਕ ਕਿ ਸਥਾਨਾਂ 'ਤੇ ਹਰੇਕ ਤੱਤ ਪਿਛਲੀ ਸਥਿਤੀ (ਜਿਵੇਂ ਕਿ ਅਜੀਬ ਸਥਿਤੀ) ਦੇ ਤੱਤਾਂ ਨਾਲੋਂ ਵੱਡਾ ਹੁੰਦਾ ਹੈ.

ਐਲਗੋਰਿਥਮ

1. Traverse the array from 0 to n (length of the array).
    1. Check if the position is even or odd if it is even,
        2. If arr[i] is greater than the arr[i-1], then swap the array elements.
    2. Else, if arr[i] is smaller than the arr[i-1], then swap the array elements.
2. Print the array.

ਕਥਾ

ਅਸੀਂ ਇੱਕ ਦਿੱਤਾ ਹੈ ਪੂਰਨ ਅੰਕ ਐਰੇ. ਅਸੀਂ ਦੁਬਾਰਾ ਪ੍ਰਬੰਧ ਕਰਨ ਲਈ ਕਿਹਾ ਹੈ ਐਰੇ ਇਸ ਤਰੀਕੇ ਨਾਲ ਕਿ ਸਮਾਨ ਸਥਿਤੀ 'ਤੇ ਤੱਤ ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਦੇ ਤੱਤਾਂ ਨਾਲੋਂ ਵੱਡਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ. ਯਾਦ ਰੱਖੋ ਕਿ ਅਸੀਂ 0-ਅਧਾਰਤ ਇੰਡੈਕਸਿੰਗ 'ਤੇ ਵਿਚਾਰ ਨਹੀਂ ਕਰਾਂਗੇ. ਇਸ ਲਈ ਐਰੇ ਦੇ ਪਹਿਲੇ ਤੱਤ ਨੂੰ ਅਜੀਬ ਸਥਿਤੀ ਵਿੱਚ ਮੰਨਿਆ ਜਾਵੇਗਾ. ਅਤੇ ਦੂਜਾ ਜਿਵੇਂ ਕਿ ਸਥਿਤੀ ਵਿੱਚ ਅਤੇ ਇਸ ਤਰਾਂ ਹੀ. ਵਿਚਾਰ ਐਰੇ ਨੂੰ ਪਾਰ ਕਰਨਾ ਅਤੇ ਐਰੇ ਦੀ ਅਜੀਬ ਅਤੇ ਇੱਥੋਂ ਤਕ ਦੀ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਕਰਨਾ ਹੈ. ਜਿਵੇਂ ਪਹਿਲਾਂ ਦੱਸਿਆ ਗਿਆ ਹੈ, 0-ਅਧਾਰਿਤ ਇੰਡੈਕਸਿੰਗ ਸਥਿਤੀ 'ਤੇ ਵਿਚਾਰ ਨਹੀਂ ਕਰਨਾ. ਇਸ ਲਈ ਅਸੀਂ 0 ਵੇਂ ਸਥਾਨ ਤੋਂ ਪਹਿਲੇ ਤੱਤ ਨੂੰ ਚੁਣ ਰਹੇ ਹਾਂ ਅਤੇ ਇਸਨੂੰ ਇਕ ਅਜੀਬ ਸਥਿਤੀ ਤੇ ग्रहण ਕਰਾਂਗੇ ਕਿਉਂਕਿ ਇਹ ਪਹਿਲੀ ਸਥਿਤੀ ਤੇ ਹੈ ਅਤੇ 1 ਇਕ ਅਜੀਬ ਸੰਖਿਆ ਹੈ. ਹੋਰ ਰਸਮੀ ਤੌਰ 'ਤੇ, ਅਸੀਂ ਇਸ ਪ੍ਰਸ਼ਨ ਵਿਚ 1-ਅਧਾਰਤ ਇੰਡੈਕਸਿੰਗ ਦੀ ਪਾਲਣਾ ਕਰ ਰਹੇ ਹਾਂ.

ਅਸੀਂ ਕੀ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ, ਸਾਨੂੰ ਅਰੇ ਨੂੰ ਸਥਿਤੀ 1 ਤੋਂ ਪਾਰ ਕਰਨਾ ਹੈ ਅਤੇ ਜਾਂਚ ਕਰਨਾ ਹੈ ਕਿ ਕੀ ਇਹ ਸਥਿਤੀ ਇਕਸਾਰ ਹੈ ਜਾਂ ਨਹੀਂ. ਜੇ ਇਹ ਸਹੀ ਹੈ ਤਾਂ ਅਸੀਂ ਜਾਂਚ ਕਰਾਂਗੇ ਕਿ ਕੀ ਇਕੋ ਸਥਿਤੀ ਵਾਲੇ ਤੱਤ ਪਿਛਲੇ ਸਥਿਤੀ ਵਾਲੇ ਤੱਤ ਨਾਲੋਂ ਵੱਡਾ ਹੈ. ਜੇ ਇਹ ਸਹੀ ਹੈ, ਤਾਂ ਮੁੱਲਾਂ ਨੂੰ ਸਵੈਪ ਕਰੋ. ਅਸੀਂ ਇਹ ਵੀ ਜਾਂਚ ਕਰ ਸਕਦੇ ਹਾਂ ਕਿ ਤੱਤ ਦੀਆਂ ਅਹੁਦਿਆਂ odਖੀਆਂ ਨਹੀਂ ਹਨ, ਇਹ ਕੰਮ ਵੀ ਕਰ ਸਕਦੀਆਂ ਹਨ. ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਇਵਜ ਪੋਲੀਸ਼ਨ ਤੱਤ ਦੀ ਜਾਂਚ ਕਰਨਾ ਪਹਿਲਾਂ ਵਾਲੀ ਸਥਿਤੀ ਨਾਲੋਂ ਵੱਡਾ ਹੈ.

ਸਾਨੂੰ ਸਿਰਫ ਕੁਝ ਚੀਜ਼ਾਂ ਯਾਦ ਰੱਖਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ, ਜੇ ਇਕੋ ਸਥਿਤੀ ਵਿਚ ਇਕ ਤੱਤ ਉਸ ਤੱਤ ਦੇ ਮੁੱਲ ਨਾਲੋਂ ਵੱਡਾ ਨਹੀਂ ਹੁੰਦਾ ਜੋ ਮੌਜੂਦਾ ਤੱਤ ਦੇ ਸਥਿਤੀ ਤੋਂ ਬਿਲਕੁਲ ਪਹਿਲਾਂ ਸਥਿਤੀ ਵਿਚ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ, ਤਦ ਸਾਨੂੰ ਉਨ੍ਹਾਂ ਕਦਰਾਂ ਕੀਮਤਾਂ ਨੂੰ ਬਦਲਣਾ ਜਾਂ ਉਸ ਵਿਚ ਤਬਦੀਲੀ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ. ਤਾਂ ਕਿ, ਉਹ ਕ੍ਰਮ ਵਿੱਚ ਆ ਸਕਣ ਜਿਵੇਂ ਕਿ ਸਥਿਤੀ ਵਾਲੇ ਤੱਤ ਪਹਿਲਾਂ ਵਾਲੇ ਸਥਿਤੀ ਨਾਲੋਂ ਵੱਡੇ ਹੁੰਦੇ ਹਨ ਜਾਂ ਸਿਰਫ ਅਜੀਬ ਸਥਿਤੀ ਵਾਲੇ ਤੱਤ ਤੇ. ਅੰਤ ਵਿੱਚ, ਐਰੇ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰੋ, ਜਿਸ ਵਿੱਚ ਸਵੈਪਿੰਗ ਕੀਤੀ ਗਈ ਸੀ.

ਐਰੇ ਨੂੰ ਦੁਬਾਰਾ ਪ੍ਰਬੰਧ ਕਰੋ ਜਿਵੇਂ ਕਿ ਪੋਜੀਸ਼ਨਡ ਵੀ ਅਜੀਬ ਤੋਂ ਵੱਡਾ ਹੁੰਦਾ ਹੈ

ਕੋਡ

ਐਰੇ ਨੂੰ ਫਿਰ ਤੋਂ ਵਿਵਸਥਿਤ ਕਰਨ ਲਈ ਸੀ ++ ਕੋਡ, ਜੋ ਕਿ ਬਿਹਤਰ ਤੋਂ ਵੀ ਵੱਡੇ ਹੁੰਦੇ ਹਨ

#include<iostream>

using namespace std;

void swap(int* a, int* b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

void rearrangeEvenPositioned(int arr[], int n)
{
    for (int i = 1; i < n; i++)
    {
        if (i % 2 == 0)
        {
            if (arr[i] > arr[i - 1])
                swap(&arr[i - 1], &arr[i]);
        }
        else
        {
            if (arr[i] < arr[i - 1])
                swap(&arr[i - 1], &arr[i]);
        }
    }
}

int main()
{
    int arr[] = {1, 4, 5, 2, 7};
    int n = sizeof(arr)/sizeof(arr[0]);
    rearrangeEvenPositioned(arr, n);
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
    return 0;
}
1 5 2 7 4

ਜਾਵਾ ਕੋਡ ਐਰੇ ਨੂੰ ਪੁਨਰ ਵਿਵਸਥਿਤ ਕਰਨ ਲਈ, ਜੋ ਕਿ ਬਿਹਤਰ ਤੋਂ ਵੀ ਵੱਡਾ ਹੈ

class rearrangeArray1
{
    public static void rearrangeEvenPositioned(int arr[], int n)
    {
        for (int i = 1; i < n; i++)
        {
            if (i % 2 == 0)
            {
                if (arr[i] > arr[i - 1])
                {
                    int temp=arr[i-1];
                    arr[i-1]=arr[i];
                    arr[i]=temp;
                }
            }
            else
            {
                if (arr[i] < arr[i - 1])
                {
                    int temp=arr[i-1];
                    arr[i-1]=arr[i];
                    arr[i]=temp;
                }
            }
        }
    }
    public static void main(String args[])
    {
        int arr[] = {1, 4, 5, 2, 7};
        int n = arr.length;
        rearrangeEvenPositioned(arr, n);
        for (int i = 0; i < n; i++)
            System.out.print(arr[i]+" ");

    }
}

1 5 2 7 4

ਜਟਿਲਤਾ ਵਿਸ਼ਲੇਸ਼ਣ

ਟਾਈਮ ਜਟਿਲਤਾ

ਓ (ਐਨ)  ਜਿੱਥੇ ਕਿ “ਐਨ” ਐਰੇ ਵਿਚਲੇ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਹੈ. ਅਸੀਂ ਸਿਰਫ ਐਰੇ ਨੂੰ ਪਾਰ ਕੀਤਾ ਹੈ ਜੋ ਲੰਬੇ ਸਮੇਂ ਦੀ ਜਟਿਲਤਾ ਵਿੱਚ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ.

ਸਪੇਸ ਦੀ ਜਟਿਲਤਾ

ਐਲਗੋਰਿਦਮ ਹੈ ਓ (1) ਸਪੇਸ ਗੁੰਝਲਤਾ. ਇਹ ਐਲਗੋਰਿਦਮ ਇੱਕ ਅੰਦਰੂਨੀ ਪਹੁੰਚ ਹੈ ਇਸ ਲਈ ਇਹ ਨਿਰੰਤਰ ਜਗ੍ਹਾ ਲੈਂਦਾ ਹੈ. ਪਰ ਇੰਪੁੱਟ ਦੇ ਕਾਰਨ ਪੂਰੇ ਪ੍ਰੋਗਰਾਮ ਵਿਚ ਓ (ਐਨ) ਸਪੇਸ ਗੁੰਝਲਦਾਰਤਾ ਹੈ.