הפוך מערך ב-Java

מערכים משמשים לעתים קרובות בקידוד והם דרך לאחסן מספר ערכים מאותו סוג במשתנה אחד. עשויות להיות סיבות רבות לכך שקודן עשוי לרצות להפוך מערך. ייתכן שיהיה צורך להפוך מערך, למשל, כאשר ההיגיון של בעיה צריך להתחיל עם האלמנט האחרון. במקרה זה, השיטה הטובה ביותר היא לבצע את ההיפוך ולאחר מכן להשתמש במערך ההפוך במידת הצורך בקוד. אפילו יותר, היפוך מערך הוא משימה פופולרית מאוד בראיונות של Java Juniors.

כיצד להפוך מערך

ישנן דרכים רבות להיפוך מערך, וכאן אנו רואים את 5. עבור אפשרות 1, מערך מתהפך באמצעות מערך נוסף שמולא בסדר עולה מסוף המערך המקורי (יורד), באפשרות 2 היפוך במקום מתבצע כאשר רכיבי מערך בהתחלה ובסוף מוחלפים, באופציה 3, נעשה שימוש בשיטת reverse() ממסגרת Collections לביצוע ההיפוך, באופציה 4, List.add() ו- List.remove() משמשים, ולבסוף, באופציה 5, נעשה שימוש ברקורסיה.

אפשרות 1: היפוך מערך באמצעות מערך נוסף

הבה נכתוב שיטה פשוטה להיפוך מערך באמצעות מערך נוסף . אפשרות זו משתמשת במערך נוסף שמתמלא החל מהאלמנט האחרון של המערך המקורי בסדר יורד, כלומר האלמנט הראשון זהה לאלמנט האחרון במערך המקורי, השני זהה לשני מהאחרון וכן פועל עד למילוי המערך הנוסף.

import java.util.Arrays;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       int[] array = {7, 8, 9, 10, 11};
       System.out.println("Array : " + Arrays.toString(array)); // print array

       // Call function to get reversed array
       int[] reversedArray = reverse(array);
       System.out.println("Reversed array : " + Arrays.toString(reversedArray)); // print reversed array
   }

   // Method returns a new reversed array, based on the array which was passed to it.
   static int[] reverse(int[] array) {
       int[] newArray = new int[array.length];

       for (int i = 0; i < array.length; i++) {
           newArray[array.length - 1 - i] = array[i];
       }

       return newArray;
   }
}

בדוגמה זו, כתבנו שיטה שהופכת מערך ומחזירה מערך הפוך חדש, על סמך המערך שהועבר אליו. מערך מוכרז ב- main ואז נקראת שיטה, reverse . הטיעון לשיטה הוא המערך. בשיטה הפוך , נוצר מערך חדש, newArray , והוא בגודל זהה למערך , רק ריק לחלוטין. לולאת for משמשת למילוי ה- newArray ופועלת על פני כל אורך המערך. זה נעשה על ידי התחלת האלמנט הראשון של מערך והקצאתו לאלמנט האחרון של newArray , לאחר מכן לקחת את האלמנט השני של המערך שלנו ולהקצות אותו לאלמנט השני האחרון של newArray , וכן הלאה; newArray ממולא לאחור. כאשר לולאת for הושלמה, newArray מלא לחלוטין והוא היפוך מדויק של המערך .

אפשרות 2: הדפס את הרכיבים של מערך בסדר הפוך

כדי שהאפשרות הזו תהפוך מערך, אין צורך להשתמש במערך נוסף, והוא אינו מומר לרשימת מערך. במקום זאת, רכיבי המערך מוכנסים לסדר הפוך במקום . זה אומר שהם, למעשה, מוחלפים. האלמנט הראשון מוחלף עם האלמנט האחרון, האלמנט השני מוחלף עם השני מהאחרון, וכן הלאה. נעשה שימוש בלולאת for וכאשר זה הושלם, המערך יתהפך. הקוד נראה כך:

import java.util.Arrays;
/*
reversing an array in-place
*/
public class ReverseArrayDemo {

   public static void main(String[] args) {
       int[] array = {1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       arrayReverse(array);
       System.out.println("Array after reverse : " + Arrays.toString(array));
   }
//arrayReverse is a method that reverses array in-place
   static void arrayReverse(int[] array) {
       for (int i = 0; i < array.length / 2; i++) {
           int temp = array[i];
           array[i] = array[array.length - i - 1];
           array[array.length - i - 1] = temp;
       }
   }
}

המערך המקורי מודפס כמחרוזת באמצעות Arrays.toString (array) , ואז המערך שלנו מועבר כארגומנט לאחור . בשיטה ההפוכה בלולאת for , נוצר משתנה, temp, ומשתמשים בו. בלולאת for הסדר ההפוך מושג בשלושה שלבים:

1. הקצאת האלמנט הראשון לטמפ'
2. הקצאת האלמנט האחרון לאלמנט הראשון
3. הקצאת טמפ' לאלמנט האחרון

לאחר מכן זה מתבצע שוב הפעם עבור האלמנט השני והשני מהאלמנט האחרון, וכן הלאה. זה נעשה עבור אלמנטים עוקבים של המערך, אך הלולאה חוזרת רק עד מחצית מגודל המערך. בעצם, האלמנטים בקצוות מנוגדים של המערך מוחלפים. שיטה זו תפעל במהירות כפולה משיטה המשתמשת בלולאת for העוברת מ-0 לגודל. כתוצאה מכך מושג הסדר ההפוך של המערך ומראים לנו כיצד להדפיס מערך בסדר הפוך והערכים מודפסים:

אפשרות 3: שימוש ב- Collections.reverse()

ב-Java, ניתן להשתמש בשיטה ההפוכה , שהיא חלק מהמסגרת הקיימת של Collections, כדי להפוך מערך. בואו נשתמש בו כדי לעשות את ההיפוך.

import java.util.Arrays;
import java.util.Collections;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       Integer[] array = {1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       reverse(array);
       System.out.println("Array after reverse : " + Arrays.toString(array));
   }
//method that reverses an array
   static void reverse(Integer[] array) {
       Collections.reverse(Arrays.asList(array));
   }
}

ב- main , המערך נוצר ומתמלא כמערך שלמים עם 5 מספרים. לאחר מכן היא מודפסת כרשימה באמצעות Arrays.asList(array) ואז נקראת הפונקציה, reverse , ומערך מועבר כארגומנט לפונקציה זו. בהיפוך , נעשה שימוש ב- Collections.reverse , וזה משמש ברשימת המערך, Arrays.asList(array) , ולא במערך עצמו. לאחר מכן בשלב הבא נראה כיצד להדפיס מערך בסדר הפוך באמצעות System.out.println , והפעם כל אלמנט מודפס באותה שורה:

אפשרות 4: הפוך מערך באמצעות List.add() ו-List.remove()

באפשרות החדשה הזו, List.add() ו- List.remove() משמשים לביצוע ההיפוך. הדרך שבה זה עובד היא שהמערך מומר לרשימה והאלמנט האחרון של הרשימה מוסר ומציב אותו בתחילת הרשימה. לאחר שחזרה על כל הרשימה, הרשימה החדשה היא היפוך של הרשימה המקורית. בשיטת main() נוצר מערך המורכב מ-5 מספרים. ואז המצב המקורי של המערך מופק לקונסולה. מערך זה מוכנס כארגומנט למתודה, reverse() . שיטה זו פועלת בעצם על ידי הסרת האלמנט האחרון והכנסתו בקדמת המערך. לבסוף, המצב החדש (ההפוך) של המערך מוקלט לקונסולה. בשיטת reverse() המערך נכתב ל- List דרך Arrays.asList(array) , על מנת לאפשר לשיטות add() ו- remove() לבצע את ההיפוך. שיטה זו פועלת בעצם על ידי הסרת האלמנט האחרון והכנסתו בקדמת המערך. הצעדים שהשימושים reverse() הם כדלקמן. הוא משתמש בלולאת for כדי לבצע את ההיפוך של רכיבי הרשימה. הוא עושה זאת על ידי אתחול משתנה i . בתחילה ה- i מוגדר ל-0. כאשר i = 0 , האלמנט ב- list.size() - 1 ב- list מוסר, וזה תמיד יהיה האלמנט האחרון מאז i < list.size() - 1 . מכיוון שהמתודה remove() מחזירה את האלמנט שהיא הסירה, אלמנט זה מתווסף כעת לרשימה באינדקס i = 0 , כלומר, הוכנס בהתחלה. שאר הרשימה מוזז ימינה, אך הרשימה החדשה עדיין מכילה את אותו מספר אלמנטים, כלומר, גודל . בהמשך לביצוע לולאת for עם הערך הבא של i , i = 1 , אותה קבוצת שלבים מתבצעת כך שהאלמנט האחרון מוסר ומכניסים למספרים ב- i = 1 והרשימה הוסטה ימינה. זה נמשך עד שהערך המצטבר האחרון של i וכל הרכיבים ברשימה השתנו. באלמנט לולאה השני של הרשימה עם index i מוגדר לרכיב המערך עם index i שבו i הוא מ-0 עד list.size() - 1 . לסיכום, השלבים בהם נעשה שימוש הם: שלבים:

1. i = 0
2. הסר אלמנט ב- list.size() - 1
3. insert element, שהיה ב- list.size() - 1 , ב-i = 0
4. הגדלה i
5. חזור על שלבים 2 עד 4 (עם ערכים חדשים עבור i בשלב 3) עד שייעשה שימוש בערך המצטבר האחרון של i

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       Integer[] array = new Integer[]{1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       reverse(array);
       System.out.println("Array after reverse : " + Arrays.toString(array));
   }

   static void reverse(Integer[] array) {
       List list = new ArrayList<>(Arrays.asList(array));

       for (int i = 0; i < list.size() - 1; i++) {
           list.add(i, list.remove(list.size() - 1));
       }

       for (int i = 0; i < list.size(); i++) {
           array[i] = list.get(i);
       }
   }
}

קוד זה נותן את הפלט:

אפשרות 5: הפוך מערך על ידי רקורסיה

שיטת הרקורסיה נמצאת בשימוש נרחב בקידוד וניתן להשתמש בה כדי ליצור שיטה יעילה כיצד להפוך מערך. באפשרות זו, המערך מומר לרשימה ואז הקוד נכנס ל- method reverse() בכל פעם בהסרת האלמנט האחרון בסוף הרשימה ולרשימה מתווספים את הערכים שהוסרו בסדר הפוך. כמו בשיטות הקודמות, נוצר מערך המורכב מ-5 מספרים. לאחר מכן הוא מועבר כארגומנט לפונקציה, reverse() . ב- reverse() הדבר הראשון שנעשה הוא להפוך את המערך לרשימה ולבדוק את גודל הרשימה. אם יש לו רק אלמנט אחד או שהוא null אז השיטה מסיימת וחוזרת. אם לא, הרכיב הראשון יוסר, אך מועתק לערך שלם , . לאחר מכן נקראת שוב השיטה reverse() והרקורסיה מתחילה שוב. כאשר הפונקציה נכנסת, מתבצעים אותם שלבים, בדיקת גודל כאשר, אם הרשימה גדולה מ-1, השלב הבא יהיה להסיר את האלמנט הראשון ולאחר מכן לבצע את הרקורסיה שוב. כאשר גודל הרשימה הוא 1, reverse() חוזר למקום שממנו היא נקראת ואז לרשימה מתווסף כל ערך כדי לבנות אותו להיפוך מדויק של הרשימה המקורית.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       Integer[] array = new Integer[]{1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       List list = new ArrayList<>(Arrays.asList(array));
       reverse(list);
       System.out.println("Array after reverse : " + Arrays.toString(list.toArray()));
   }

   public static void reverse(List list) {
       if (list== null || list.size() <= 1) {
           return;
       }

       Integer value = list.remove(0);

       reverse(list);

       list.add(value);
   }
}

הפלט הוא:

סיכום

אז כאן בדקנו 5 דרכים שונות להפוך מערך. אפשרות 3, המשתמשת במסגרת Collections, היא ככל הנראה השיטה הטובה ביותר לשימוש שכן Collections.reverse היא פונקציית Java שכבר קיימת, מנוסה ובדוקה. כמובן שניתן להשתמש באפשרויות האחרות, במיוחד תוך כדי למידה, אבל בדרך כלל שיטות סטנדרטיות, אם הן קיימות, הן הטובות ביותר מכיוון שהן בדרך כלל מותאמות ונבדקות. עם זאת, אתה יכול ליצור שיטות כאלה בעצמך מכיוון שזהו תרגיל קידוד טוב ויעזור לך להצליח בראיון שלך עבור Java Junior.