Java에서 int 배열을 어떻게 되돌 립니까?


238

Java에서 int 배열을 되돌리려 고합니다.

이 방법은 배열을 바꾸지 않습니다.

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

무엇이 잘못 되었나요?


31
내가 뭘 잘못했는지 봅니다. validData.length / 2 여야합니다. 그렇지 않으면 스스로 반전되고 반전되지 않습니다.
MichaelScott

4
이 알고리즘의 올바른 버전에 대한 설명이 포함 된 en.wikipedia.org/wiki/In-place_algorithm 을 참조하십시오 .
Dean Povey

답변:


284

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

당신이 그것을하는 방식으로, 당신은 각 요소를 두 번 교환하므로 결과는 초기 목록과 동일합니다.


그리고 validData.length / 2for-loop의 외부에 부분 을 넣고 싶습니다 .
Jin Kwon

7
@Jin 나는하지 않을 것이다. 그것은 의미를 난독 화하고, 최적화 컴파일러가 당신을 위해 그것을 할 것이라고 확신합니다. 어쨌든, 프로파일 링이 필요 / 유용하다는 명백한 증거를 얻을 때까지 마이크로 최적화는 중요하지 않습니다.
Nicu Stiurca

9
@JinKwon 그것은 일종의 일과 같습니다 validData.length >> 1. 그것은 동등하고 빠르지 만 많은 프로그래머를 혼동하고 좋은 컴파일러는 자동으로 그렇게합니다.
저스틴

2
이 계산은 한 번만 수행 validData.length - i - 1하여 변수에 저장해야합니다.

온도 변수가없는 반전을 제안 할 수 있습니까!
sg28

303

Commons.Lang , 당신은 간단하게 사용할 수 있습니다

ArrayUtils.reverse(int[] array)

대부분의 경우 문제를 처리 할 때 이미 단위 테스트 및 사용자 테스트를 거친 쉽게 사용할 수있는 라이브러리를 사용하는 것이 더 빠르고 안전합니다.


3
함수형 스타일의 경우 역순 (통과) 배열을 반환하는 것을 선호했습니다.
Laurent G

2
@ laurent-g는 공정합니다 :이 방법으로 배열을 뒤집는 것이 더 메모리 효율적이므로 아마도 그들이 이런 식으로 한 것입니다.
Sirmyself

4
내 요점은 사본이 아니거나 사본이 아니었다. 내 메시지는 "(통과 됨)"이 (역전 된 후) 반환되도록 명시되어 있으므로 별도의 명령문이 필요하지 않은 표현식으로 전달 될 수 있습니다.
Laurent G

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

11
물론 그렇습니다. 리스트는 프리미티브가 아닌 오브젝트 만 보유 할 수 있으므로 모든 프리미티브 ( int이 경우 s)는 각각의 랩퍼 ( Integer이 경우 s )로 랩핑되어 목록에 놓입니다. 보시다시피 Integers는 객체입니다. @ 톰
11,684

6
조심하십시오 : 내가 틀리지 않으면 원래 배열이 수정됩니다. 명확하게하기 위해 아무것도 반환하지 않을 수 있습니다.
Andrea Zilio

3
@ 11684 예, 일반 목록은 객체 만 보유 할 수 있습니다. 그러나 배열을 제외한 방법. 배열은 기본 요소를 보유 할 수 있습니다. 따라서 int[]와 다릅니다 Integer[]. 사용해보십시오 : Integer[] array = new int[5]. 컴파일 오류가 발생합니다. 그렇기 때문에 Java Arrays클래스는 기본 배열 작업을위한 여러 가지 메소드를 정의합니다. int[]위의 메소드에 를 전달하려고하면 다음과 같은 결과가 발생 The method reverse(Object[]) in the type MakeSimple is not applicable for the arguments (int[])합니다. @Filip-인플레 이스 알고리즘은 적은 메모리를 사용하고 더 빠르게 실행됩니다.
Brian McCutchon

3
@Andrea 사실, 그렇지 않습니다. 에서 반환 한 목록 Arrays.asList()은 원래 배열을 참조하지도 않고 배열을 반환하지도 않습니다. 이것이이 방법의 문제점 중 하나입니다. 메모리를 3 배로 사용하고 작업을 알고리즘으로 3 배로 수행합니다.
Brian McCutchon

4
이 메소드 자체는 작동 할 수 있지만 int[]이 메소드에 대한 인수로 단순히 인수를 전달할 수 없습니다 ( "호환되지 않는 유형 : int []는 Object []로 변환 할 수 없음" ).
MC 황제

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

java.util.Collections.reverse()되돌릴 수 java.util.List들과 java.util.Arrays.asList(), 당신이 그것에 전달하는 특정 배열을 감싸는 목록을 반환 그러므로 yourArray의 호출 후 역전된다 Collections.reverse().

비용은 하나의 List 객체를 만드는 것이므로 추가 라이브러리가 필요하지 않습니다.

Tarik과 그 해설자들의 답변에서 비슷한 해결책이 제시되었지만이 답변이 더 간결하고 쉽게 파싱 될 수 있다고 생각합니다.


15
객체 배열의 경우 이것이 좋은 솔루션입니다. 그러나 기본 배열에는 작동하지 않습니다. 예 : int[]to asList(...)를 전달하면 하나의 요소를 포함하는 a List<Integer>가 아니라 a를 반환합니다 List<int[]>. 내장 방식을 변환 AFAICS 간단한있다 int[]에가 Integer[].
Martin Rust

4
이것은 프리미티브 배열과는 작동하지 않습니다 ... collections dosnt는 값을 반환하므로 이제는 메모리에 목록으로 쓸모없는 배열이 있습니다
NightSkyCode

@MartinRust Java 8 이상 : Arrays.stream(arr).boxed().collect(Collectors.toList())또는Arrays.stream(arr).boxed().toArray(Integer[]::new)
Simon Forsberg

39

루프의 각 반복에서 스왑하는 인덱스를 추적하기 위해 명시 적 변수를 선언하면 알고리즘의 논리를 따르는 것이 조금 더 쉽다고 생각합니다.

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

또한 while 루프 에서이 작업을 수행하는 것이 더 읽기 쉽다고 생각합니다.

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

구식 스왑이 더 쉬워 보이지만 배열 인덱스 값을 왼쪽, 오른쪽으로 포함 할 때 예, 디버깅하는 데 도움이 될 것입니다.
Srinath Ganesh

'public static void swap (int [] data, int index1, int index2) {...}'를 추가하고 다음과 같이 'reverse'에서 사용할 수 있습니다 : swap (data, left, right).
pm_

13

여기에 이미 많은 답변이 있습니다. 주로 배열을 수정하는 데 중점을 둡니다. 그러나 완전성을 기하기 위해 Java 스트림을 사용하여 원래 배열을 보존하고 새로운 역 배열을 만드는 또 다른 방법이 있습니다.

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

10

구아바와 함께 :

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

4
훌륭합니다! 짧고 효과적입니다. 모든 asList방법 과 마찬가지로 백업 (기본) 배열에 직접 쓰는 를 만듭니다 . 나는 여기에 투표권자가 실수로 이것이 박스 목록이나 무언가를 반환했다고 생각했다고 생각합니다.
Luke Usherwood

@LukeUsherwood는 아마도 각 요소에 대해 get 및 set을 호출 할 때 boxing 및 unboxing에서 약간의 오버 헤드가있을 것입니다. 그러나 나는 이것이 훌륭한 해결책이라는 것에 동의합니다.
Patrick Parker

실제로, 그것은 가치가 있습니다. 나는 개인적으로 작업하는 대부분의 코드에서 큰 문제가 될 것이라고 생각하지 않습니다. '핫'영역이 잘 정의되어 있고 나머지는 '글루 코드'입니다. 동시에 메모리 이탈 또한 프로파일 러가 실제 기능에 속하지 않는 추가 "숨겨진"비용을 발생 시킨다는 점이 마음에 듭니다.
Luke Usherwood

여전히 꼼꼼한 배열 대신 박스 목록을 반환하지 @LukeUsherwood
AnthonyJClink

2
@AnthonyJClink "it"이 무엇을 의미하는지 모르지만 JDK 유틸리티 Collections.reverse는 void 메소드입니다. 이것은 Guava 내부 클래스에서 int[]적절하게 작동합니다 Integer. 그러나 예 Integer, 객체를 전달하는 인터페이스를 통해 작동 하므로 언급 한 것처럼 많은 임시 객체 이탈 및 권투가 발생합니다. IntStream성능이 중요한 곳에 프리미티브 콜렉션 라이브러리를 사용해보십시오 . (Trove, Koloboke, Eclipse Collections, ...)
Luke Usherwood

10

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]



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

불행히도 모든 개발자가 그 방법을 알고 확장 패키지 설치가 필요하지 않기 때문에 여기에서 가장 확실한 답변을 얻을 수 있습니다.
HoldOffHunger 2016 년

5

이것이 내가 개인적으로 해결하는 방법입니다. 매개 변수화 된 메소드를 작성하는 이유는 정수뿐만 아니라 모든 배열을 정렬 할 수 있기 때문입니다.

나는 당신이 그것으로부터 무언가를 수집하기를 바랍니다.

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

2
기본을 사용하여 원래 문제를 해결하지 않습니다.
Melinda Green

Prims을 객체로 변환하는 방법에는 여러 가지가 있습니다. Java에서 가능한 한 항상 prims을 피하는 것이 좋습니다. 또한 권장해야한다고 생각합니다.
AnthonyJClink

길이를 알 수없는 프리미티브 배열을 배열로 변환하는 것은 특히 실현하지 않고 수행하는 경우 매우 나쁜 생각 일 수 있습니다. 자바는 스몰 토크가 아니다. 프리미티브는 언어의 일부이며 그 자리를 차지합니다. 우리가 마음에 들지 않더라도 문제가되지 않으며 받아 들여서 적절한 곳에 사용해야합니다.
Melinda Green

1
실제로 배열을 복사 할 필요는 없습니다 Collections.reverse(asList(arraytoReverse)); return arrayToReverse;. asList는 배열 주위의 래퍼 일 뿐이므로 원래 배열은 반대로됩니다.
Radiodef

3

귀하의 프로그램은 오직 작동합니다 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
}

3
아마도 메소드 호출이 아닌 인라인 스왑의 의사 코드로 스왑을 의미했지만 그렇지 않은 경우 작동하지 않습니다. Java는 참조로 전달되므로 변수에 대한 스왑 메소드를 작성할 수 없습니다.
Dean Povey

나는 당신이 v [i] & v [j]를 바꾸는 방법을 의미했습니다. Java에서 메소드 호출이 작동하는 방식을 알고 있습니다. 메소드의 경우 swap (v, i ++, j--);
fastcodejava

1
Dean, 배열 validData는 참조로 전달 된 객체이므로 swap () 메서드가 완벽하게 작동합니다.
Gaël Oberson

3

더 원시적 인 데이터 (예 : 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];
    }
}

1
실제로 프로덕션 코드에서 사용하기에는 너무 귀엽지 만 그럼에도 재미 있습니다. [- I - 1 렌] 등 [I] = % 어레이 배열 : 최대 귀여움,이 같은 % = 작업을 사용
멜린 그린

비슷하지만 조금 더 짧습니다 :for (int m = x.length, i = --m / 2; ++i <= m;) { x[i] ^= x[m - i]; x[i] ^= x[m - i] ^= x[i]; }
Thomas Mueller

2

배열을 거꾸로 반복하는 것이 가장 효율적입니다.

Aaron의 솔루션 이이 전화를 통해이 작업을 수행하는지 확실하지 Collections.reverse(list);않습니다.


배열을 거꾸로 반복하려면 새로운 배열이 필요합니다. 새 배열을 만들지 않고 인라인 반전을 수행하는 위에 게시 된 솔루션이 마음에 듭니다.
mmcdole

1
@Simucal 왜 새로운 배열을 만드는가? 그냥 거꾸로 반복하십시오.
Trejkaz

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

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

1
예, 출력과 함께 동일하고 명확한 코드를 시도했습니다 int [] a = {1,3,5,2,6,7}; 대 (INT a.length I = 1, I> = 0; 난 ...) {System.out.print (a [I] + "");}`먼저 인덱스 마지막 인덱스의 배열을 반대로한다
Rocket_03

1

이 방법으로 실수를 할 가능성이 훨씬 더 적지 않습니까?

    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;

1

o (n) 시간 복잡성 및 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--;
    }
}

참고로, 이것은 복잡한 for 루프로 단순화 될 수 있습니다 : for (int start = 0, end = array.length - 1; start < end; start++, end--) { ... }.
Tim Cooke

1

배열을 바꾸는 두 가지 방법.

  1. For 루프를 사용하여 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]


3
무엇입니까 Ints?
CodingNow

@CodingNow 구아바 유틸리티 헬퍼 클래스의 그것의 하나 - 참조 여기
mrec

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

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

0

아래는 컴퓨터에서 실행되는 완전한 프로그램입니다.

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

배열을 사용하는 행렬에 대한 프로그램의 경우 좋은 소스가 될 것 입니다. 링크를 통해 이동하십시오.


0

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/


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

4
답변에 설명을 추가하십시오. 코드 전용 답변은 아무것도 설명하지 않습니다.
rgettman

0

다음은 모든 유형의 배열 과 전체 / 부분 지원 을 반대로하는 간단한 구현 입니다.

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

0

다음은 내가 생각해 낸 것입니다.

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

0

이 문제에 대한 해결책을 갖는 두 가지 방법이 있습니다.

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

또한 Java의 Collections API를 사용하여이를 수행 할 수 있습니다.

Collections API는 내부적으로 동일한 역 공간 접근 방식을 사용합니다.

Collections API 사용을위한 샘플 코드는 다음과 같습니다.

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

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

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

    }
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.