סידרו מחדש את המערך כך שאפילו רכיבי אינדקס קטנים יותר ואלמנטים אינדקסיים מוזרים גדולים יותר


רמת קושי קַל
נשאל לעתים קרובות אבלארה מערכות אפיות פורקיטים רובלוקס טסלה
מערך

הצהרת בעיה

נתת מערך 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 עד פחות מ -1 כאשר n הוא אורך המערך. קח אחד פחות מ -1 עד לחצייה כי אנחנו הולכים להשוות אותו עם האלמנט הבא אם קיים במערך. אז אנחנו חייבים לעזוב את המקום לשם השוואה אחרת זה יהיה באמצעות שגיאה. אם נלך לולאה עד פחות מ- n, אז זה יפגע באינדקס שלא קיים במערך. לכן לקחנו 0 עד פחות מ -1 - מעבר.

נחצה את המערך ונבדוק אם כל ערך של 'אני' הוא שווה או מוזר אם הוא שווה וגם המערך [i] גדול מהאלמנט הבא. המשמעות היא מיקום האלמנט הבא כ- i הוא בהחלט מוזר, ואלמנט זה הממוקם מוזר הוא פחות מהאלמנט הממוקם אפילו. לכן אנו הולכים להחליף את האלמנטים מכיוון ש- arr [i] הוא האלמנט האחיד הנוכחי ו- arr [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

קוד Java כדי לסדר מחדש את המערך כך שאפילו אלמנטים באינדקס קטנים יותר מאשר באינדקס מוזר

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

ניתוח מורכבות

מורכבות זמן

O (n) איפה "N" הוא מספר האלמנטים במערך. בדיוק עברנו את המערך והחלפנו את האלמנטים ולכן מורכבות הזמן היא ליניארית.

מורכבות בחלל

O (1) כי השתמשנו במרחב קבוע אך התוכנית בכללותה תופסת מקום O (n).