ย้อนกลับ Array ใน 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 อาร์กิวเมนต์ของเมธอดคืออาร์เรย์ ในเมธอดreverseอาร์เรย์ใหม่newArrayจะถูกสร้างขึ้นและมีขนาดเท่ากับอาร์เรย์ว่างเปล่าเท่านั้น for loop ใช้เพื่อเติมข้อมูลในnewArray และดำเนินการ ตลอดความยาวของอาร์เรย์ สิ่งนี้ทำได้โดยเริ่มต้นด้วยองค์ประกอบแรกของอาร์เรย์และกำหนดให้กับองค์ประกอบสุดท้ายของnewArrayจากนั้นรับองค์ประกอบที่สองของอาร์เรย์ ของเรา และกำหนดให้กับองค์ประกอบสุดท้ายที่สองของnewArrayและอื่น ๆ newArrayถูกกรอกย้อนหลัง เมื่อลูป for เสร็จสมบูรณ์newArray จะเต็มและเป็นการย้อนกลับของอาร์เรย์

ตัวเลือกที่ 2: พิมพ์องค์ประกอบของอาร์เรย์ในลำดับย้อนกลับ

สำหรับตัวเลือกนี้ในการย้อนกลับอาร์เรย์ ไม่จำเป็นต้องใช้อาร์เรย์เพิ่มเติม และจะไม่แปลงเป็นรายการอาร์เรย์ แทนที่จะใส่องค์ประกอบอาร์เรย์ในลำดับย้อนกลับin -place ซึ่งหมายความว่าพวกเขาถูกสับเปลี่ยน องค์ประกอบแรกจะสลับกับองค์ประกอบสุดท้าย องค์ประกอบที่สองจะถูกสลับกับองค์ประกอบที่สองจากสุดท้าย และอื่น ๆ ใช้ for loopและเมื่อดำเนินการเสร็จสิ้นอาร์เรย์จะถูกย้อนกลับ รหัสมีลักษณะดังนี้:

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)จากนั้นอาร์เรย์ ของเรา จะถูกส่งผ่านเป็นอาร์กิวเมนต์เป็นreverse ใน เมธอด ย้อนกลับในfor loop ตัวแปร temp จะถูกสร้างและใช้งาน ในfor loop ลำดับการย้อนกลับทำได้ในสามขั้นตอน:

1. การกำหนดองค์ประกอบแรกให้กับอุณหภูมิ
2. การกำหนดองค์ประกอบสุดท้ายให้กับองค์ประกอบแรก
3. การกำหนดอุณหภูมิให้กับองค์ประกอบสุดท้าย

ครั้งนี้จะดำเนินการอีกครั้งสำหรับองค์ประกอบที่สองและองค์ประกอบที่สองจากองค์ประกอบสุดท้าย และอื่นๆ สิ่งนี้ทำสำหรับองค์ประกอบที่ต่อเนื่องกันของอาร์เรย์ แต่การวนซ้ำจะทำซ้ำได้ถึงครึ่งหนึ่งของขนาดอาร์เรย์ โดยพื้นฐานแล้วองค์ประกอบที่ปลายด้านตรงข้ามของอาร์เรย์จะถูกสลับ วิธีนี้จะทำงานได้เร็วกว่าวิธีที่ใช้for loop ที่มีขนาดตั้งแต่ 0 ถึง 2 เท่า ผลที่ได้คือการเรียงลำดับย้อนกลับของอาร์เรย์ และเราจะแสดงวิธีการพิมพ์อาร์เรย์ในลำดับย้อนกลับและค่าจะถูกพิมพ์ออกมา:

ตัวเลือกที่ 3: การใช้ Collections.reverse()

ใน Java สามารถใช้เมธอดย้อนกลับ ซึ่งเป็นส่วนหนึ่งของเฟรมเวิร์กคอลเลกชันที่มีอยู่ เพื่อย้อนกลับอาร์เรย์ได้ ลองใช้มันเพื่อทำการกลับรายการ

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( ) วิธีนี้ใช้งานได้โดยการนำองค์ประกอบสุดท้ายออกและใส่ไว้ที่ด้านหน้าของอาร์เรย์ สุดท้าย สถานะใหม่ (ย้อนกลับ) ของอาร์เรย์จะถูกส่งออกไปยังคอนโซล ในทางกลับกัน ()เมธอด อาร์เรย์ถูกเขียนไปยัง List ผ่านArrays.asList(array)เพื่อเปิดใช้ งาน เมธอด add()และremove()เพื่อดำเนินการกลับรายการ วิธีนี้ใช้งานได้โดยการนำองค์ประกอบสุดท้ายออกและใส่ไว้ที่ด้านหน้าของอาร์เรย์ ขั้นตอนย้อนกลับ ()ใช้มีดังนี้ มันใช้สำหรับการวนซ้ำเพื่อดำเนินการกลับองค์ประกอบของรายการ ทำได้โดยการเริ่มต้นตัวแปรi ในขั้นต้นiถูกตั้งค่าเป็น 0 เมื่อi = 0องค์ประกอบที่list.size() - 1ในlistจะถูกลบออก และนี่จะเป็นองค์ประกอบสุดท้ายเสมอเนื่องจากi < list.size() - 1. เนื่องจาก เมธอด remove()ส่งคืนองค์ประกอบที่ลบออกไป ตอนนี้องค์ประกอบนี้จึงถูกเพิ่มเข้าไปในรายการที่ดัชนีi = 0เช่น แทรกที่จุดเริ่มต้น ส่วนที่เหลือของรายการจะถูก เลื่อนไปทางขวา แต่รายการ ใหม่ ยังคงมีองค์ประกอบจำนวนเท่าเดิม เช่นขนาด ดำเนินการต่อสำหรับลูปด้วยค่าถัดไปของi , i = 1ชุดของขั้นตอนเดียวกันจะดำเนินการเพื่อให้องค์ประกอบสุดท้ายถูกลบออกและใส่เป็นตัวเลขที่i = 1และรายการเลื่อนไปทางขวา สิ่งนี้จะดำเนินต่อไปจนกว่าค่าที่เพิ่มขึ้นสุดท้ายของiและองค์ประกอบทั้งหมดในรายการจะมีการเปลี่ยนแปลง ในวินาทีที่องค์ประกอบลูปของรายการที่มีดัชนี i ถูกตั้งค่าเป็นองค์ประกอบอาร์เรย์ที่มีดัชนีiโดยที่iจาก 0 ถึง list.size( ) - 1 สรุปขั้นตอนที่ใช้คือ ขั้นตอน :

1. ฉัน = 0
2. ลบองค์ประกอบที่list.size() - 1
3. แทรกองค์ประกอบซึ่งอยู่ที่list.size() - 1ที่ i = 0
4. เพิ่มขึ้น
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: ย้อนกลับอาร์เรย์ด้วยการเรียกซ้ำ

วิธีการเรียกซ้ำใช้กันอย่างแพร่หลายในการเข้ารหัสและสามารถใช้เพื่อสร้างวิธีการที่มีประสิทธิภาพในการย้อนกลับอาร์เรย์ ในตัวเลือกนี้ อาร์เรย์จะถูกแปลงเป็นรายการ จากนั้นรหัสจะเข้าสู่เมธอดreverse()ทุกครั้งที่ลบองค์ประกอบสุดท้ายที่ส่วนท้ายของรายการ และรายการจะมีค่าที่ถูกลบเพิ่มเข้าไปในลำดับที่กลับกัน เช่นเดียวกับวิธีการก่อนหน้านี้ อาร์เรย์จะถูกสร้างขึ้นด้วยตัวเลข 5 ตัว จากนั้นจะถูกส่งผ่านเป็นอาร์กิวเมนต์ในฟังก์ชันreverse( ) ในการย้อนกลับ ()สิ่งแรกที่ทำคือเปลี่ยนอาร์เรย์ให้เป็นรายการและตรวจสอบขนาดรายการ หากมีเพียงองค์ประกอบเดียวหรือเป็นโมฆะ เมธอดจะเสร็จสิ้นและส่งกลับ ถ้าไม่ใช่ องค์ประกอบแรกจะถูกลบออก แต่จะคัดลอกไปยังจำนวนเต็ม, ค่า . วิธีการย้อนกลับ ()จะถูกเรียกใช้อีกครั้งและการเรียกซ้ำจะเริ่มต้นอีกครั้ง เมื่อป้อนฟังก์ชันแล้ว ขั้นตอนเดียวกันจะดำเนินการ ตรวจสอบขนาด โดยที่หากรายการมีค่ามากกว่า 1 ขั้นตอนต่อไปคือการลบองค์ประกอบแรกออกแล้วทำการเรียกซ้ำอีกครั้ง เมื่อขนาดของรายการเป็น 1 การย้อนกลับ ()จะคืนค่าไปยังตำแหน่งที่เรียกจาก จากนั้นรายการจะมีค่า แต่ละค่า เพิ่มเข้าไปเพื่อสร้างรายการย้อนกลับที่แน่นอนของรายการเดิม

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