ฉันจะย้อนกลับอาร์เรย์ int ใน Java ได้อย่างไร

ฉันพยายามที่จะย้อนกลับอาร์เรย์ int ใน Java

วิธีนี้จะไม่ย้อนกลับอาร์เรย์

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

มีอะไรผิดปกติกับมัน?

ในการย้อนกลับอาร์เรย์ int คุณสลับรายการจนถึงจุดกึ่งกลางเช่นนี้

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

ในแบบที่คุณทำคุณสลับแต่ละองค์ประกอบสองครั้งดังนั้นผลลัพธ์จะเหมือนกับรายการเริ่มต้น

ด้วยคอมมอนส์แลงคุณสามารถใช้

ArrayUtils.reverse(int[] array)

ส่วนใหญ่แล้วมันเร็วกว่าและปลอดภัยกว่าบั๊กที่ใช้กับห้องสมุดที่มีอยู่แล้วที่ใช้งานง่ายและผ่านการทดสอบจากผู้ใช้เมื่อพวกเขาดูแลปัญหาของคุณ

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()สามารถย้อนกลับjava.util.Listและjava.util.Arrays.asList()ส่งกลับรายการที่ล้อมอาร์เรย์เฉพาะที่คุณส่งไปให้ดังนั้นจึงyourArrayถูกย้อนกลับหลังจากการเรียกCollections.reverse()ใช้

ค่าใช้จ่ายเป็นเพียงการสร้างหนึ่งรายการวัตถุและไม่จำเป็นต้องมีห้องสมุดเพิ่มเติม

มีคำตอบที่คล้ายกันในคำตอบของ Tarik และผู้ให้ความเห็น แต่ฉันคิดว่าคำตอบนี้จะกระชับและแยกวิเคราะห์ได้ง่ายขึ้น

ฉันคิดว่าการทำตามตรรกะของอัลกอริทึมง่ายขึ้นถ้าคุณประกาศตัวแปรที่ชัดเจนเพื่อติดตามดัชนีที่คุณสลับในการวนซ้ำในแต่ละรอบ

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

ฉันยังคิดว่ามันสามารถอ่านได้ง่ายขึ้นในการวนรอบในขณะนี้

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

มีคำตอบมากมายอยู่ที่นี่แล้วส่วนใหญ่เน้นที่การปรับเปลี่ยนอาร์เรย์ในสถานที่ แต่เพื่อความสมบูรณ์นี่คืออีกวิธีหนึ่งในการใช้สตรีม Java เพื่อรักษาอาเรย์ดั้งเดิมและสร้างอาเรย์กลับด้านใหม่:

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

ด้วยฝรั่ง:

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

ในกรณีของJava 8เราสามารถใช้IntStreamเพื่อย้อนกลับอาร์เรย์ของจำนวนเต็มเป็น:

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]

ง่ายสำหรับวง!

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

สิ่งนี้จะช่วยคุณ

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

นี่คือวิธีที่ฉันจะแก้ไขมันเป็นการส่วนตัว เหตุผลที่อยู่เบื้องหลังการสร้างวิธี parametrized คืออนุญาตให้เรียงลำดับอาร์เรย์ใด ๆ ... ไม่ใช่แค่จำนวนเต็มของคุณ

ฉันหวังว่าคุณจะรวบรวมบางอย่างจากมัน

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

length = 0, 1โปรแกรมของคุณจะทำงานเพียง คุณสามารถลอง :

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

หากทำงานกับข้อมูลที่เป็นแบบดั้งเดิม (เช่น char, byte, int, ฯลฯ ) คุณสามารถทำการดำเนินการ XOR ที่สนุกสนานได้

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

มันมีประสิทธิภาพมากที่สุดในการวนซ้ำแถวหลัง

ฉันไม่แน่ใจว่าคำตอบของแอรอนนี้จะทำให้การโทรนี้Collections.reverse(list);ไม่มีใครรู้หรือไม่?

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

การทำเช่นนี้จะไม่เกิดความผิดพลาดมากขึ้นหรือไม่

    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;

โซลูชันที่มีความซับซ้อนของเวลา (o) และความซับซ้อนของพื้นที่ 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 วิธีในการย้อนกลับอาร์เรย์

1. ใช้สำหรับวนรอบและสลับองค์ประกอบจนถึงจุดกึ่งกลางด้วยความซับซ้อนของเวลาของ 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. การใช้ฟังก์ชั่นในตัว (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));

   }

   เอาต์พุต: [6, 5, 4, 3, 2, 1]

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

มีคำตอบที่ดีบางข้อด้านบน แต่นี่คือวิธีที่ฉันทำ:

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

ด้านล่างเป็นโปรแกรมที่สมบูรณ์ในการทำงานในเครื่องของคุณ

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

สำหรับโปรแกรมที่ใช้ matrix จะเป็นแหล่งข้อมูลที่ดีผ่านลิงค์

การใช้โซลูชัน XOR เพื่อหลีกเลี่ยงตัวแปรอุณหภูมิรหัสของคุณควรมีลักษณะ

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

ดูลิงค์นี้สำหรับคำอธิบายที่ดีกว่า:

http://betterexplained.com/articles/swap-two-variables-using-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;
} 

นี่คือการใช้งานที่ง่ายเพื่อย้อนกลับอาร์เรย์ประเภทใด ๆรวมทั้งการสนับสนุนเต็ม / บางส่วน

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

}

นี่คือการทดสอบหน่วยที่สอดคล้องกัน

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

นี่คือสิ่งที่ฉันเกิดขึ้น:

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

มีสองวิธีในการแก้ปัญหา:

1. ย้อนกลับอาร์เรย์ในพื้นที่

ขั้นตอนที่ 1 สลับองค์ประกอบที่จุดเริ่มต้นและดัชนีสิ้นสุด

ขั้นตอนที่ 2 เพิ่มค่าดัชนีเริ่มต้นลดค่าดัชนีสิ้นสุด

ขั้นตอนที่ 3 ทำซ้ำขั้นตอนที่ 1 และขั้นตอนที่ 2 จนถึงเริ่มดัชนี <สิ้นสุดดัชนี

สำหรับสิ่งนี้ความซับซ้อนของเวลาจะเป็น O (n) และความซับซ้อนของพื้นที่จะเป็น O (1)

โค้ดตัวอย่างสำหรับการย้อนกลับอาร์เรย์ในอวกาศเป็นดังนี้:

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. กลับอาร์เรย์โดยใช้อาร์เรย์เสริม

ขั้นตอนที่ 1 สร้างอาร์เรย์ใหม่ที่มีขนาดเท่ากับอาร์เรย์ที่กำหนด

ขั้นตอนที่ 2 ใส่องค์ประกอบในอาร์เรย์ใหม่ที่เริ่มต้นจากดัชนีเริ่มต้นจากอาร์เรย์ที่กำหนดเริ่มต้นจากดัชนีสิ้นสุด

สำหรับสิ่งนี้ความซับซ้อนของเวลาจะเป็น O (n) และความซับซ้อนของพื้นที่จะเป็น O (n)

โค้ดตัวอย่างสำหรับการย้อนกลับอาร์เรย์ด้วยอาร์เรย์เสริมเป็นดังนี้:

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

นอกจากนี้เราสามารถใช้ Collections API จาก Java เพื่อทำสิ่งนี้

Collections API ภายในใช้วิธีการย้อนกลับในพื้นที่เดียวกัน

โค้ดตัวอย่างสำหรับการใช้ Collections API เป็นดังนี้:

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

    }