CODE

Question

我想写一个简洁的代码，以不使用任何循环的方式反转一个整数数组。 “反转”的意思是： [1, 4, 3, 7, 2] -> [2, 7, 3, 4, 1]。我认为IntStream在这里可能会有所帮助：应该有可能“捕获”有限的流并像堆栈（LIFO）一样继续进行。不幸的是我不能-您能帮忙吗？

Answer 1

任何循环都可以替换为recursion。

雇用是一个例子。

import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;

class RecursionReverseArray {


    private static <T> void reverseImpl(T[] arr,int lhsIdx, int rhsIdx) {
        if(lhsIdx == rhsIdx)
            return;
        T tmp = arr[lhsIdx];
        arr[lhsIdx] = arr[rhsIdx];
        arr[rhsIdx] = tmp;
        reverceImpl(arr, ++lhsIdx, --rhsIdx);
    }

    public static <T> void reverse(T[] arr) {
        reverseImpl(arr, 0, arr.length-1);
    }

    @Test
    void test() {
        Integer[] actual = {9,8,7,6,5,4,3,2,1};
        Integer[] expected = {1,2,3,4,5,6,7,8,9};
        reverse(actual);
        assertArrayEquals(expected, actual);
    }

}

与Java 8+一样，您可以使用reverse order stream API。

Answer 2

如果您不想使用循环，则可以使用递归。这是使用递归编写的代码。

CODE

导入java.io. *;

ReverseArray类{

static void rvereseArray(int arr[], int start, int end) 
{ 
    int temp; 
    if (start >= end) 
        return; 
    temp = arr[start]; 
    arr[start] = arr[end]; 
    arr[end] = temp; 
    rvereseArray(arr, start+1, end-1); 
} 

static void printArray(int arr[], int size) 
{ 
    for (int i=0; i < size; i++) 
        System.out.print(arr[i] + " "); 
    System.out.println(""); 
} 

public static void main (String[] args) { 
    int arr[] = {1, 2, 3, 4, 5, 6}; 
    printArray(arr, 6); 
    rvereseArray(arr, 0, 5); 
    System.out.println("Reversed array is "); 
    printArray(arr, 6); 
}

}

反转整数数组，没有任何循环

2 个答案:

CODE