Đảo ngược một mảng trong Java

Mảng được sử dụng thường xuyên trong mã hóa và là một cách lưu trữ nhiều giá trị cùng loại trong một biến. Có thể có nhiều lý do tại sao một lập trình viên có thể muốn đảo ngược một mảng. Ví dụ, có thể cần phải đảo ngược một mảng khi logic của một vấn đề cần bắt đầu từ phần tử cuối cùng. Trong trường hợp này, cách tốt nhất là thực hiện đảo ngược và sau đó sử dụng mảng đảo ngược khi cần thiết trong mã. Hơn nữa, đảo ngược một mảng là một nhiệm vụ rất phổ biến trong các cuộc phỏng vấn của Java Juniors.

Làm thế nào để đảo ngược một mảng

Có nhiều cách để đảo ngược một mảng và ở đây chúng tôi xem xét 5. Đối với Tùy chọn 1, một mảng được đảo ngược bằng cách sử dụng một mảng bổ sung được điền theo thứ tự tăng dần từ cuối mảng ban đầu (giảm dần), trong Tùy chọn 2 là đảo ngược tại chỗ được thực hiện trong đó các phần tử mảng ở đầu và cuối được hoán đổi cho nhau, trong Tùy chọn 3, phương thức reverse() từ khung Bộ sưu tập được sử dụng để thực hiện đảo ngược, trong Tùy chọn 4, List.add() và List.remove() được sử dụng và cuối cùng, trong Tùy chọn 5, đệ quy được sử dụng.

Tùy chọn 1: Đảo ngược Mảng bằng Mảng bổ sung

Chúng ta hãy viết một phương thức đơn giản để đảo ngược một mảng bằng cách sử dụng một mảng bổ sung . Tùy chọn này sử dụng một mảng bổ sung được điền bắt đầu bằng phần tử cuối cùng của mảng ban đầu theo thứ tự giảm dần, nghĩa là phần tử đầu tiên giống với phần tử cuối cùng trong mảng ban đầu, phần tử thứ hai giống với phần tử thứ hai từ cuối cùng và cứ thế cho đến khi mảng bổ sung được lấp đầy.

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;
   }
}

Trong ví dụ này, chúng ta đã viết một phương thức đảo ngược một mảng và trả về một mảng đã đảo ngược mới, dựa trên mảng được truyền cho nó. mảng được khai báo trong main và sau đó một phương thức, reverse , được gọi. Đối số của phương thức là mảng. Trong phương thức reverse , một mảng mới, newArray , được tạo và có cùng kích thước với array , chỉ khác là hoàn toàn trống. Một vòng lặp for được sử dụng để điền vào newArray và hoạt động trên toàn bộ chiều dài của mảng. Điều này được thực hiện bằng cách bắt đầu với phần tử đầu tiên của một mảng và gán nó cho phần tử cuối cùng của newArray, sau đó lấy phần tử thứ hai của mảng và gán nó cho phần tử cuối cùng thứ hai của newArray , v.v.; newArray được điền ngược. Khi vòng lặp for hoàn tất, newArray hoàn toàn đầy và ngược lại chính xác với mảng .

Tùy chọn 2: In các phần tử của một mảng theo thứ tự đảo ngược

Đối với tùy chọn này để đảo ngược một mảng, không cần sử dụng một mảng bổ sung và nó không được chuyển đổi thành một danh sách mảng. Thay vào đó, các phần tử mảng được đặt theo thứ tự ngược lại tại chỗ . Điều này có nghĩa là trên thực tế, chúng đã bị tráo đổi. Phần tử đầu tiên được hoán đổi với phần tử cuối cùng, phần tử thứ hai được hoán đổi với phần tử thứ hai từ cuối cùng, v.v. Vòng lặp for được sử dụng và khi hoàn thành, mảng sẽ bị đảo ngược. Mã này trông như thế này:

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;
       }
   }
}

Mảng ban đầu được in ra dưới dạng Chuỗi sử dụng Arrays.toString(array) và sau đó mảng của chúng ta được chuyển dưới dạng đối số vào reverse . Trong phương thức đảo ngược trong vòng lặp for , một biến temp được tạo và sử dụng. Trong vòng lặp for , thứ tự ngược lại được thực hiện theo ba bước:

1. gán phần tử đầu tiên cho temp
2. gán phần tử cuối cùng cho phần tử đầu tiên
3. gán tạm thời cho phần tử cuối cùng

Điều này sau đó được thực hiện lại lần này cho phần tử thứ hai và thứ hai từ phần tử cuối cùng, v.v. Điều này được thực hiện cho các phần tử liên tiếp của mảng nhưng vòng lặp chỉ lặp đến một nửa kích thước mảng. Về cơ bản, các phần tử ở hai đầu đối diện của mảng được hoán đổi. Phương thức này sẽ chạy nhanh gấp đôi so với phương thức sử dụng vòng lặp for đi từ 0 đến size. Kết quả là thứ tự đảo ngược của mảng đã đạt được và chúng ta được chỉ dẫn cách in một mảng theo thứ tự ngược lại và các giá trị được in ra:

Cách 3: Sử dụng Collections.reverse()

Trong Java, phương thức đảo ngược , là một phần của khung Bộ sưu tập hiện có, có thể được sử dụng để đảo ngược một mảng. Hãy sử dụng nó để làm đảo ngược.

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));
   }
}

Trong main , mảng được tạo và điền dưới dạng mảng Số nguyên có 5 số. Sau đó, nó được in ra dưới dạng một danh sách bằng cách sử dụng Arrays.asList(array) và sau đó hàm, reverse , được gọi và mảng được truyền dưới dạng đối số vào hàm này. Reverse , Collections.reverse được sử dụng và điều này được sử dụng trong danh sách mảng, Arrays.asList(array) , thay vì chính mảng đó. Sau đó, trong bước tiếp theo, chúng ta sẽ thấy cách in một mảng theo thứ tự đảo ngược bằng cách sử dụng System.out.println và lần này mỗi phần tử được in ra trên cùng một dòng:

Tùy chọn 4: Đảo ngược một mảng bằng List.add() và List.remove()

Trong tùy chọn mới này, List.add() và List.remove() được sử dụng để thực hiện đảo ngược. Cách thức hoạt động của nó là mảng được chuyển đổi thành danh sách và phần tử cuối cùng của danh sách được loại bỏ và đặt ở đầu danh sách. Sau khi toàn bộ danh sách đã được lặp đi lặp lại, danh sách mới sẽ đảo ngược danh sách ban đầu. Trong phương thức main() , một mảng được tạo bao gồm 5 số. Sau đó, trạng thái ban đầu của mảng được xuất ra bàn điều khiển. Mảng này sau đó được đưa vào làm đối số cho phương thức, reverse() . Phương pháp này về cơ bản hoạt động bằng cách loại bỏ phần tử cuối cùng và chèn nó vào đầu mảng. Cuối cùng, trạng thái mới (đảo ngược) của mảng được xuất ra bàn điều khiển. ngược lại ()phương thức, mảng được ghi vào Danh sách thông qua Arrays.asList(array) , để cho phép các phương thức add() và remove() thực hiện đảo ngược. Phương pháp này về cơ bản hoạt động bằng cách loại bỏ phần tử cuối cùng và chèn nó vào đầu mảng. Các bước sử dụng reverse() như sau. Nó sử dụng vòng lặp for để thực hiện việc đảo ngược các phần tử của danh sách. Nó thực hiện điều này bằng cách khởi tạo một biến i . Ban đầu i được đặt thành 0. Khi i = 0 , phần tử tại list.size() - 1 trong danh sách sẽ bị xóa và đây sẽ luôn là phần tử cuối cùng kể từ i < list.size() - 1. Vì phương thức remove() trả về phần tử mà nó đã loại bỏ, phần tử này hiện được thêm vào danh sách tại chỉ mục i = 0 , tức là được chèn vào đầu. Phần còn lại của danh sách sau đó được chuyển sang bên phải nhưng danh sách mới vẫn có cùng số lượng phần tử, tức là kích thước . Tiếp tục thực hiện vòng lặp for với giá trị tiếp theo của i , i = 1 , tập hợp các bước tương tự được thực hiện để phần tử cuối cùng được loại bỏ và đưa vào nums tại i = 1 và danh sách dịch chuyển sang bên phải. Điều này tiếp tục cho đến khi giá trị gia tăng cuối cùng của i và tất cả các phần tử trong danh sách đã được thay đổi. Trong lần thứ hai chophần tử vòng lặp của danh sách có chỉ số i được đặt thành phần tử mảng có chỉ số i với giá trị từ 0 đến list.size() - 1 . Tóm lại, các bước được sử dụng là: Các bước:

1. tôi = 0
2. xóa phần tử tại list.size() - 1
3. chèn phần tử, tại list.size() - 1 , tại i = 0
4. tăng tôi
5. lặp lại các bước từ 2 đến 4 (với các giá trị mới cho i ở bước 3) cho đến khi sử dụng giá trị gia tăng cuối cùng của 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);
       }
   }
}

Mã này cho đầu ra:

Tùy chọn 5: Đảo ngược một mảng bằng đệ quy

Phương pháp đệ quy được sử dụng rộng rãi trong mã hóa và có thể được sử dụng để tạo ra một phương pháp hiệu quả về cách đảo ngược một mảng. Trong tùy chọn này, mảng được chuyển đổi thành một danh sách và sau đó mã sẽ chuyển sang phương thức reverse() mỗi khi xóa phần tử cuối cùng ở cuối danh sách và danh sách có các giá trị đã xóa được thêm vào theo thứ tự đảo ngược. Như trong các phương pháp trước, một mảng được tạo bao gồm 5 số. Sau đó, nó được chuyển dưới dạng đối số vào hàm, reverse() . Trong Reverse(), điều đầu tiên được thực hiện là biến mảng thành danh sách và kiểm tra kích thước danh sách. Nếu nó chỉ có một phần tử hoặc là null thì phương thức kết thúc và trả về. Nếu không, phần tử đầu tiên sẽ bị xóa, nhưng được sao chép sang Số nguyên, giá trị . Phương thức reverse() sau đó được gọi lại và đệ quy bắt đầu lại. Khi hàm được nhập, các bước tương tự được thực hiện, kiểm tra kích thước trong đó, nếu danh sách lớn hơn 1, bước tiếp theo sẽ là xóa phần tử đầu tiên và sau đó thực hiện lại đệ quy. Khi kích thước của danh sách là 1, hàm đảo ngược () trở về vị trí mà nó được gọi và sau đó danh sách có từng giá trị được thêm vào để xây dựng nó thành một đảo ngược chính xác của danh sách ban đầu.

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);
   }
}

Đầu ra là:

Phần kết luận

Vì vậy, ở đây chúng tôi đã xem xét 5 cách khác nhau để đảo ngược một mảng. Tùy chọn 3, sử dụng khung Bộ sưu tập, có lẽ là phương pháp tốt nhất để sử dụng vì Collections.reverse là một hàm Java đã tồn tại, đã được thử và kiểm tra. Tất nhiên, các tùy chọn khác có thể được sử dụng, đặc biệt là trong khi học, nhưng nhìn chung các phương pháp tiêu chuẩn, nếu chúng tồn tại, là tốt nhất vì chúng thường được tối ưu hóa và thử nghiệm cao. Tuy nhiên, bạn có thể tự tạo các phương thức như vậy vì đây là một bài tập mã hóa tốt và sẽ giúp bạn thành công trong cuộc phỏng vấn cho Java Junior.