Làm cách nào để đảo ngược một mảng int trong Java?

Tôi đang cố gắng đảo ngược một mảng int trong Java.

Phương pháp này không đảo ngược mảng.

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

Điều gì là sai với nó?

Để đảo ngược một mảng int, bạn trao đổi các mục lên cho đến khi bạn đạt đến điểm giữa, như thế này:

for(int i = 0; i < validData.length / 2; i++)
{
    int temp = validData[i];
    validData[i] = validData[validData.length - i - 1];
    validData[validData.length - i - 1] = temp;
}

Cách bạn đang thực hiện, bạn trao đổi từng phần tử hai lần, do đó, kết quả giống như danh sách ban đầu.

Với Commons.Lang , bạn chỉ cần sử dụng

ArrayUtils.reverse(int[] array)

Hầu hết thời gian, sẽ nhanh hơn và an toàn hơn khi sử dụng các thư viện có sẵn dễ dàng đã được kiểm tra đơn vị và kiểm tra người dùng khi họ xử lý vấn đề của bạn.

public class ArrayHandle {
    public static Object[] reverse(Object[] arr) {
        List<Object> list = Arrays.asList(arr);
        Collections.reverse(list);
        return list.toArray();
    }
}

Collections.reverse(Arrays.asList(yourArray));

java.util.Collections.reverse()có thể đảo ngược java.util.Lists và java.util.Arrays.asList()trả về một danh sách bao bọc mảng cụ thể mà bạn truyền cho nó, do đó yourArraybị đảo ngược sau khi gọi Collections.reverse().

Chi phí chỉ là việc tạo ra một đối tượng List và không cần thêm thư viện.

Một giải pháp tương tự đã được trình bày trong câu trả lời của Tarik và các nhà bình luận của họ, nhưng tôi nghĩ câu trả lời này sẽ ngắn gọn hơn và dễ phân tích hơn.

Tôi nghĩ rằng việc theo logic của thuật toán sẽ dễ dàng hơn một chút nếu bạn khai báo các biến rõ ràng để theo dõi các chỉ số mà bạn đang hoán đổi ở mỗi lần lặp của vòng lặp.

public static void reverse(int[] data) {
    for (int left = 0, right = data.length - 1; left < right; left++, right--) {
        // swap the values at the left and right indices
        int temp = data[left];
        data[left]  = data[right];
        data[right] = temp;
    }
}

Tôi cũng nghĩ rằng nó dễ đọc hơn để làm điều này trong một vòng lặp.

public static void reverse(int[] data) {
    int left = 0;
    int right = data.length - 1;

    while( left < right ) {
        // swap the values at the left and right indices
        int temp = data[left];
        data[left] = data[right];
        data[right] = temp;

        // move the left and right index pointers in toward the center
        left++;
        right--;
    }
}

Đã có rất nhiều câu trả lời ở đây, chủ yếu tập trung vào việc sửa đổi mảng tại chỗ. Nhưng để hoàn thiện, đây là một cách tiếp cận khác sử dụng các luồng Java để bảo toàn mảng ban đầu và tạo một mảng đảo ngược mới:

    int[] a = {8, 6, 7, 5, 3, 0, 9};
    int[] b = IntStream.rangeClosed(1, a.length).map(i -> a[a.length-i]).toArray();

Với ổi:

Collections.reverse(Ints.asList(array));

Trong trường hợp của Java 8, chúng ta cũng có thể sử dụng IntStreamđể đảo ngược mảng số nguyên như:

int[] sample = new int[]{1,2,3,4,5};
int size = sample.length;
int[] reverseSample = IntStream.range(0,size).map(i -> sample[size-i-1])
                      .toArray(); //Output: [5, 4, 3, 2, 1]

Đơn giản cho vòng lặp!

for (int start = 0, end = array.length - 1; start <= end; start++, end--) {
    int aux = array[start];
    array[start]=array[end];
    array[end]=aux;
}

Điều này sẽ giúp bạn

int a[] = {1,2,3,4,5};
for (int k = 0; k < a.length/2; k++) {
    int temp = a[k];
    a[k] = a[a.length-(1+k)];
    a[a.length-(1+k)] = temp;
}

for(int i=validData.length-1; i>=0; i--){
  System.out.println(validData[i]);
 }

Đây là cách cá nhân tôi sẽ giải quyết nó. Lý do đằng sau việc tạo phương thức tham số hóa là để cho phép bất kỳ mảng nào được sắp xếp ... không chỉ các số nguyên của bạn.

Tôi hy vọng bạn lượm lặt một cái gì đó từ nó.

@Test
public void reverseTest(){
   Integer[] ints = { 1, 2, 3, 4 };
   Integer[] reversedInts = reverse(ints);

   assert ints[0].equals(reversedInts[3]);
   assert ints[1].equals(reversedInts[2]);
   assert ints[2].equals(reversedInts[1]);
   assert ints[3].equals(reversedInts[0]);

   reverseInPlace(reversedInts);
   assert ints[0].equals(reversedInts[0]);
}

@SuppressWarnings("unchecked")
private static <T> T[] reverse(T[] array) {
    if (array == null) {
        return (T[]) new ArrayList<T>().toArray();
    }
    List<T> copyOfArray = Arrays.asList(Arrays.copyOf(array, array.length));
    Collections.reverse(copyOfArray);
    return copyOfArray.toArray(array);
}

private static <T> T[] reverseInPlace(T[] array) {
    if(array == null) {
        // didn't want two unchecked suppressions
        return reverse(array);
    }

    Collections.reverse(Arrays.asList(array));
    return array;
}

Chương trình của bạn sẽ chỉ làm việc length = 0, 1. Bạn co thể thử :

int i = 0, j = validData.length-1 ; 
while(i < j)
{
     swap(validData, i++, j--);  // code for swap not shown, but easy enough
}

Nếu làm việc với dữ liệu nguyên thủy hơn (ví dụ char, byte, int, v.v.) thì bạn có thể thực hiện một số thao tác XOR thú vị.

public static void reverseArray4(int[] array) {
    int len = array.length;
    for (int i = 0; i < len/2; i++) {
        array[i] = array[i] ^ array[len - i  - 1];
        array[len - i  - 1] = array[i] ^ array[len - i  - 1];
        array[i] = array[i] ^ array[len - i  - 1];
    }
}

Nó là hiệu quả nhất để đơn giản lặp lại các mảng ngược.

Tôi không chắc liệu giải pháp của Aaron có thực hiện cuộc gọi này Collections.reverse(list);không? Có ai biết không?

public void getDSCSort(int[] data){
        for (int left = 0, right = data.length - 1; left < right; left++, right--){
            // swap the values at the left and right indices
            int temp = data[left];
            data[left]  = data[right];
            data[right] = temp;
        }
    }

public void display(){
  String x[]=new String [5];
  for(int i = 4 ; i > = 0 ; i-- ){//runs backwards

    //i is the nums running backwards therefore its printing from       
    //highest element to the lowest(ie the back of the array to the front) as i decrements

    System.out.println(x[i]);
  }
}

Sẽ không làm theo cách này sẽ khó xảy ra hơn nhiều cho những sai lầm?

    int[] intArray = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int[] temp = new int[intArray.length];
    for(int i = intArray.length - 1; i > -1; i --){
            temp[intArray.length - i -1] = intArray[i];
    }
    intArray = temp;

Giải pháp với độ phức tạp thời gian o (n) và độ phức tạp không gian o (1).

void reverse(int[] array) {
    int start = 0;
    int end = array.length - 1;
    while (start < end) {
        int temp = array[start];
        array[start] = array[end];
        array[end] = temp;
        start++;
        end--;
    }
}

2 cách để đảo ngược một mảng.

1. Sử dụng vòng lặp For và hoán đổi các phần tử cho đến điểm giữa với độ phức tạp thời gian của O (n / 2).

   private static void reverseArray() {
   int[] array = new int[] { 1, 2, 3, 4, 5, 6 };
   
   for (int i = 0; i < array.length / 2; i++) {
       int temp = array[i];
       int index = array.length - i - 1;
       array[i] = array[index];
       array[index] = temp;
   }
   System.out.println(Arrays.toString(array));

   }

2. Sử dụng hàm dựng sẵn (Collections.reverse ())

   private static void reverseArrayUsingBuiltInFun() {
   int[] array = new int[] { 1, 2, 3, 4, 5, 6 };
   
   Collections.reverse(Ints.asList(array));
   System.out.println(Arrays.toString(array));

   }

   Đầu ra: [6, 5, 4, 3, 2, 1]

Dưới đây là chương trình hoàn chỉnh để chạy trong máy của bạn.

public class ReverseArray {
    public static void main(String[] args) {
        int arr[] = new int[] { 10,20,30,50,70 };
        System.out.println("reversing an array:");
        for(int i = 0; i < arr.length / 2; i++){
            int temp = arr[i];
            arr[i] = arr[arr.length - i - 1];
            arr[arr.length - i - 1] = temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }   
    }
}

Đối với các chương trình trên ma trận sử dụng mảng, đây sẽ là nguồn tốt . Đi qua liên kết.

Sử dụng giải pháp XOR để tránh biến tạm thời, mã của bạn sẽ giống như

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

Xem liên kết này để được giải thích tốt hơn:

http://betterexplained.com/articles/swap-two-variables-USE-xor/

private static int[] reverse(int[] array){
    int[] reversedArray = new int[array.length];
    for(int i = 0; i < array.length; i++){
        reversedArray[i] = array[array.length - i - 1];
    }
    return reversedArray;
} 

Đây là một cách thực hiện đơn giản, để đảo ngược mảng của bất kỳ loại nào , cộng với hỗ trợ đầy đủ / một phần .

import java.util.logging.Logger;

public final class ArrayReverser {
 private static final Logger LOGGER = Logger.getLogger(ArrayReverser.class.getName());

 private ArrayReverser () {

 }

 public static <T> void reverse(T[] seed) {
    reverse(seed, 0, seed.length);
 }

 public static <T> void reverse(T[] seed, int startIndexInclusive, int endIndexExclusive) {
    if (seed == null || seed.length == 0) {
        LOGGER.warning("Nothing to rotate");
    }
    int start = startIndexInclusive < 0 ? 0 : startIndexInclusive;
    int end = Math.min(seed.length, endIndexExclusive) - 1;
    while (start < end) {
        swap(seed, start, end);
        start++;
        end--;
    }
}

 private static <T> void swap(T[] seed, int start, int end) {
    T temp =  seed[start];
    seed[start] = seed[end];
    seed[end] = temp;
 }  

}

Dưới đây là bài kiểm tra đơn vị tương ứng

import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;

import org.junit.Before;
import org.junit.Test;

public class ArrayReverserTest {
private Integer[] seed;

@Before
public void doBeforeEachTestCase() {
    this.seed = new Integer[]{1,2,3,4,5,6,7,8};
}

@Test
public void wholeArrayReverse() {
    ArrayReverser.<Integer>reverse(seed);
    assertThat(seed[0], is(8));
}

 @Test
 public void partialArrayReverse() {
    ArrayReverser.<Integer>reverse(seed, 1, 5);
    assertThat(seed[1], is(5));
 }
}

Đây là những gì tôi nghĩ ra:

// solution 1 - boiler plated 
Integer[] original = {100, 200, 300, 400};
Integer[] reverse = new Integer[original.length];

int lastIdx = original.length -1;
int startIdx = 0;

for (int endIdx = lastIdx; endIdx >= 0; endIdx--, startIdx++)
   reverse[startIdx] = original[endIdx];

System.out.printf("reverse form: %s", Arrays.toString(reverse));

// solution 2 - abstracted 
// convert to list then use Collections static reverse()
List<Integer> l = Arrays.asList(original);
Collections.reverse(l);
System.out.printf("reverse form: %s", l);

Có hai cách để có giải pháp cho vấn đề:

1. Đảo ngược một mảng trong không gian.

Bước 1. Hoán đổi các yếu tố ở đầu và chỉ mục kết thúc.

Bước 2. Tăng chỉ số bắt đầu giảm chỉ số kết thúc.

Bước 3. Lặp lại Bước 1 và Bước 2 cho đến khi bắt đầu chỉ mục <chỉ mục kết thúc

Đối với điều này, độ phức tạp thời gian sẽ là O (n) và độ phức tạp không gian sẽ là O (1)

Mã mẫu để đảo ngược một mảng trong không gian giống như:

public static int[] reverseAnArrayInSpace(int[] array) {
    int startIndex = 0;
    int endIndex = array.length - 1;
    while(startIndex < endIndex) {
        int temp = array[endIndex];
        array[endIndex] = array[startIndex];
        array[startIndex] = temp;
        startIndex++;
        endIndex--;
    }
    return array;
}

2. Đảo ngược một mảng bằng cách sử dụng một mảng phụ trợ.

Bước 1. Tạo một mảng mới có kích thước bằng với mảng đã cho.

Bước 2. Chèn các phần tử vào mảng mới bắt đầu từ chỉ mục bắt đầu, từ mảng đã cho bắt đầu từ chỉ mục kết thúc.

Đối với điều này, độ phức tạp thời gian sẽ là O (n) và độ phức tạp không gian sẽ là O (n)

Mã mẫu để đảo ngược một mảng với mảng phụ trợ giống như:

public static int[] reverseAnArrayWithAuxiliaryArray(int[] array) {
    int[] reversedArray = new int[array.length];
    for(int index = 0; index < array.length; index++) {
        reversedArray[index] = array[array.length - index -1]; 
    }
    return reversedArray;
}

Ngoài ra, chúng ta có thể sử dụng API Bộ sưu tập từ Java để thực hiện việc này.

API Bộ sưu tập trong nội bộ sử dụng cùng một cách tiếp cận ngược lại trong cách tiếp cận không gian.

Mã mẫu để sử dụng API Bộ sưu tập giống như:

public static Integer[] reverseAnArrayWithCollections(Integer[] array) {
    List<Integer> arrayList = Arrays.asList(array);
    Collections.reverse(arrayList);
    return arrayList.toArray(array);
}

static int[] reverseArray(int[] a) {
     int ret[] = new int[a.length];
     for(int i=0, j=a.length-1; i<a.length && j>=0; i++, j--)
         ret[i] = a[j];
     return ret;
}

 public static int[] reverse(int[] array) {

    int j = array.length-1;
    // swap the values at the left and right indices //////
        for(int i=0; i<=j; i++)
        {
             int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
           j--;
        }

         return array;
    }

      public static void main(String []args){
        int[] data = {1,2,3,4,5,6,7,8,9};
        reverse(data);

    }

    public static void main(String args[])    {
        int [] arr = {10, 20, 30, 40, 50}; 
        reverse(arr, arr.length);
    }

    private static void reverse(int[] arr,    int length)    {

        for(int i=length;i>0;i--)    { 
            System.out.println(arr[i-1]); 
        }
    }

Có một số câu trả lời tuyệt vời ở trên, nhưng đây là cách tôi đã làm:

public static int[] test(int[] arr) {

    int[] output = arr.clone();
    for (int i = arr.length - 1; i > -1; i--) {
        output[i] = arr[arr.length - i - 1];
    }
    return output;
}