ריעריינדזש מענגע אַזאַ אַז אפילו אינדעקס עלעמענטן זענען קלענערער און מאָדנע אינדעקס עלעמענטן זענען גרעסער  


שוועריקייט לעוועל גרינג
אָפט געבעטן אין אַוואַלאַראַ עפּאָס סיסטעמען פאָורקיטעס ראָבלאָקס טעסלאַ
מענגע

פּראָבלעם סטאַטעמענט  

איר האָט געגעבן אַן מענגע of ינטאַדזשערז. די פּראָבלעם "ריעריינדזש מענגע אַזוי אַז אפילו אינדעקס עלעמענטן זענען קלענערער און מאָדנע אינדעקס עלעמענטן זענען גרעסער" פרעגט צו ריעריינדזש די מענגע אין אַזאַ אַ שטייגער אַז די אפילו אינדעקס עלעמענטן זאָל זיין קלענערער ווי די מאָדנע אינדעקס עלעמענטן אין אַ מאַדאַפייד מענגע.

בייַשפּיל  

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

דערקלערונג: 2 איז אין גלייך אינדעקס שטעלע (0 אינדעקס) אַזוי עס איז קלענערער ווי דער ווייַטער מאָדנע ינדעקסט עלעמענט, 1 איז קלענערער ווי 5 וואָס איז אויף די מאָדנע ינדעקסט עלעמענט.

אַלגערידאַם צו ריעריינדזש מענגע אַזאַ אַז אפילו ינדעקסט עלעמענטן זענען קלענערער ווי מאָדנע ינדעקסט  

1. Traverse the array from 0 to n-1(less than the length of the array).
2. Check if the index is even and the next element is smaller than the current element then swap both of the numbers.
3. Check if the index is odd and the next element is greater than the current element, then swap both of the numbers.
4. Print the array.

דערקלערונג

געגעבן אַ מענגע פון ​​לענג n. מיר ווערן געבעטן צו ריעריינדזש די מענגע אַזוי אַז די גלייך אינדעקס עלעמענטן זענען קלענערער ווי די מאָדנע ינדעקסט עלעמענטן. מיר וועלן טאָן דאָס דורך ויסבייַטן די עלעמענטן אויב די באדינגונגען זענען נישט צופֿרידן. ערשטער, מיר מוזן קאָנטראָלירן די טיפּ אָדער גלייך אָדער מאָדנע, און מיר מוזן מאָדיפיצירן די מענגע.

זע אויך
פֿראגן וועגן מאַשמאָעס פון אפילו אָדער מאָדנע נומער אין געגעבן ראַנגעס

אַריבער די מענגע פֿון 0 צו ווייניקער ווי n-1, ווען n איז די לענג פון די מענגע. נעמען איין ווייניקער ווי N-1 צו די דורך ווייַל מיר וועלן פאַרגלייכן עס מיט די ווייַטער עלעמענט אויב עס איז פאָרשטעלן אין די מענגע. אַזוי מיר האָבן צו פאַרלאָזן דעם אָרט פֿאַר פאַרגלייַך, אַנדערש עס וועט זיין דורך אַ טעות. אויב מיר שלייפן ביז ווייניקער ווי n, עס וועט שלאָגן די אינדעקס וואָס טוט נישט עקסיסטירן אין די מענגע. אַז ס וואָס מיר גענומען 0 צו ווייניקער ווי N - 1 דורך.

מיר וועלן אַריבער די מענגע און טשעק פֿאַר יעדער ווערט פון 'איך' אויב עס איז גלייך אָדער מאָדנע אויב עס איז גלייך און אויך מענגע [איך] איז גרעסער ווי דער ווייַטער עלעמענט. עס מיטל די ווייַטער עלעמענט שטעלע ווי איך איז באשטימט מאָדנע, און אַז מאָדנע פּאַזישאַנד עלעמענט איז ווייניקער ווי די גלייך פּאַזישאַנד עלעמענט. אַזוי מיר וועלן ויסבייַטן די עלעמענטן ווי אַרר [i] איז די קראַנט אפילו עלעמענט און אַרר [i + 1] איז דער ווייַטער מאָדנע פּאַזישאַנד עלעמענט.

איצט קאָנטראָלירן סיימאַלטייניאַסלי אויב די ווערט פון 'איך' איז מאָדנע, און אויך אויב דער עלעמענט אין דעם אינדעקס איז קלענערער ווי די פריערדיקע עלעמענט, מיר וועלן אויך ויסבייַטן די וואַלועס אין די מענגע. נאָך סוואַפּינג אַלע מעגלעך וואַלועס, די געשאפן מענגע איז די לעצט און געוואלט רעזולטאַט.

ריעריינדזש מענגע אַזאַ אַז אפילו אינדעקס עלעמענטן זענען קלענערער און מאָדנע אינדעקס עלעמענטן זענען גרעסערשפּילקע

קאָדעקס  

C ++ קאָד צו ריעריינדזש מענגע אַזאַ אַז אפילו ינדעקסט עלעמענטן זענען קלענערער ווי מאָדנע ינדעקסט

#include <iostream>
using namespace std;

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

        if (i % 2 != 0 && arr[i] < arr[i + 1])
            swap(arr[i], arr[i + 1]);
    }
}

void printArray(int arr[], int size)
{
    for (int i = 0; i < size; i++)
        cout << arr[i] << " ";

    cout << endl;
}

int main()
{
    int arr[] = {  2,5,7,1,3,4  };
    int n = sizeof(arr) / sizeof(arr[0]);

    evenOddComparison (arr, n);

    printArray(arr, n);

    return 0;
}
2 7 1 5 3 4

דזשאַוואַ קאָד צו ריעריינדזש עריינדזשאַז אַז אפילו ינדעקסט עלעמענטן זענען קלענערער ווי מאָדנע ינדעקסט

class rearrangeArray
{
    public static void evenOddComparison(int arr[], int n)
    {

        int temp;
        for (int i = 0; i < n - 1; i++)
        {
            if (i % 2 == 0 && arr[i] > arr[i + 1])
            {
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
            if (i % 2 != 0 && arr[i] < arr[i + 1])
            {
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
    }
    public static void printArray(int arr[], int size)
    {
        for (int i = 0; i < size; i++)
            System.out.print(arr[i] + " ");

        System.out.println();
    }
    public static void main(String[] args)
    {
        int arr[] = { 2,5,7,1,3,4 };
        int n = arr.length;

        evenOddComparison (arr, n);

        printArray(arr, n);
    }
}
2 7 1 5 3 4

קאַמפּלעקסיטי אַנאַליסיס  

צייט קאַמפּלעקסיטי

אָ (N) ווו “N” איז די נומער פון עלעמענטן אין די מענגע. מיר האָבן פּונקט דורכגעגאנגען די מענגע און האָבן סוואַפּט די עלעמענטן, אַזוי די קאַמפּלעקסיטי פון צייט איז לינעאַר.

זע אויך
ק ליידיק סלאָץ

ספעיס קאַמפּלעקסיטי

אָ (1) ווייַל מיר האָבן געוויינט קעסיידערדיק פּלאַץ, אָבער די פּראָגראַם ווי אַ גאַנץ נעמט אָ (n) פּלאַץ.