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;
}
무엇이 잘못 되었나요?
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;
}
무엇이 잘못 되었나요?
답변:
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 / 2
for-loop의 외부에 부분 을 넣고 싶습니다 .
validData.length >> 1
. 그것은 동등하고 빠르지 만 많은 프로그래머를 혼동하고 좋은 컴파일러는 자동으로 그렇게합니다.
로 Commons.Lang , 당신은 간단하게 사용할 수 있습니다
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();
}
}
int
이 경우 s)는 각각의 랩퍼 ( Integer
이 경우 s )로 랩핑되어 목록에 놓입니다. 보시다시피 Integer
s는 객체입니다. @ 톰
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-인플레 이스 알고리즘은 적은 메모리를 사용하고 더 빠르게 실행됩니다.
Arrays.asList()
은 원래 배열을 참조하지도 않고 배열을 반환하지도 않습니다. 이것이이 방법의 문제점 중 하나입니다. 메모리를 3 배로 사용하고 작업을 알고리즘으로 3 배로 수행합니다.
int[]
이 메소드에 대한 인수로 단순히 인수를 전달할 수 없습니다 ( "호환되지 않는 유형 : int []는 Object []로 변환 할 수 없음" ).
Collections.reverse(Arrays.asList(yourArray));
java.util.Collections.reverse()
되돌릴 수 java.util.List
들과 java.util.Arrays.asList()
, 당신이 그것에 전달하는 특정 배열을 감싸는 목록을 반환 그러므로 yourArray
의 호출 후 역전된다 Collections.reverse()
.
비용은 하나의 List 객체를 만드는 것이므로 추가 라이브러리가 필요하지 않습니다.
Tarik과 그 해설자들의 답변에서 비슷한 해결책이 제시되었지만이 답변이 더 간결하고 쉽게 파싱 될 수 있다고 생각합니다.
int[]
to asList(...)
를 전달하면 하나의 요소를 포함하는 a List<Integer>
가 아니라 a를 반환합니다 List<int[]>
. 내장 방식을 변환 AFAICS 간단한있다 int[]
에가 Integer[]
.
Arrays.stream(arr).boxed().collect(Collectors.toList())
또는Arrays.stream(arr).boxed().toArray(Integer[]::new)
루프의 각 반복에서 스왑하는 인덱스를 추적하기 위해 명시 적 변수를 선언하면 알고리즘의 논리를 따르는 것이 조금 더 쉽다고 생각합니다.
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--;
}
}
구아바와 함께 :
Collections.reverse(Ints.asList(array));
asList
방법 과 마찬가지로 백업 (기본) 배열에 직접 쓰는 뷰 를 만듭니다 . 나는 여기에 투표권자가 실수로 이것이 박스 목록이나 무언가를 반환했다고 생각했다고 생각합니다.
Collections.reverse
는 void 메소드입니다. 이것은 Guava 내부 클래스에서 int[]
적절하게 작동합니다 Integer
. 그러나 예 Integer
, 객체를 전달하는 인터페이스를 통해 작동 하므로 언급 한 것처럼 많은 임시 객체 이탈 및 권투가 발생합니다. IntStream
성능이 중요한 곳에 프리미티브 콜렉션 라이브러리를 사용해보십시오 . (Trove, Koloboke, Eclipse Collections, ...)
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 루프!
for (int start = 0, end = array.length - 1; start <= end; start++, end--) {
int aux = array[start];
array[start]=array[end];
array[end]=aux;
}
start <= end
에start < end
이것은 당신을 도울 것입니다
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]);
}
이것이 내가 개인적으로 해결하는 방법입니다. 매개 변수화 된 메소드를 작성하는 이유는 정수뿐만 아니라 모든 배열을 정렬 할 수 있기 때문입니다.
나는 당신이 그것으로부터 무언가를 수집하기를 바랍니다.
@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;
}
Collections.reverse(asList(arraytoReverse)); return arrayToReverse;
. asList
는 배열 주위의 래퍼 일 뿐이므로 원래 배열은 반대로됩니다.
귀하의 프로그램은 오직 작동합니다 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];
}
}
for (int m = x.length, i = --m / 2; ++i <= m;) { x[i] ^= x[m - i]; x[i] ^= x[m - i] ^= x[i]; }
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]);
}
}
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 (int start = 0, end = array.length - 1; start < end; start++, end--) { ... }
.
배열을 바꾸는 두 가지 방법.
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));
}
내장 함수 사용 (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]
Ints
?
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 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]);
}
}
}
배열을 사용하는 행렬에 대한 프로그램의 경우 좋은 소스가 될 것 입니다. 링크를 통해 이동하십시오.
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/
다음은 모든 유형의 배열 과 전체 / 부분 지원 을 반대로하는 간단한 구현 입니다.
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;
}
또한 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);
}
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);
}