Java 交换算法中如何实现返回

我正在编写代码来实现一个交换，该交换将偶数索引中的所有元素设置为小于或等于它们的邻居，将奇数索引中的所有元素设置为大于或等于它们的邻居。我需要在重排方法的末尾有一个return语句，但是由于没有if-else语句，我有点不知所措。任何帮助都将不胜感激

public class Problem3 {

public static boolean rearrange(int[] A)
{
    /*
Input: an array, A, of n sorted integers (positive, negative, or 0) that 
A[0] <= A[1] <= A[2] <=…A[n-2] <= A[n-1]

Output: re-arrange elements in A such that: 
Element at even position (i.e., A[0], A[2]) are less than or equal to both of its neighbors
Element at odd position (i.e., A[1], A[3]) are greater than or equal to both of its neighbors

A[0] <= A[1] >= A[2] <= A[3] >= A[4] <= A[5]…

Design an algorithm that solves this problem in O(n) time.

     */
    for (int i=1; i<A.length-1;){
        swap(A,A[i],A[i+1]);
    }

}

public static void swap(int[] A, int i, int j){
    int temp = A[i];
    A[i] = A[i+1];
    A[i+1] = temp;
}

public static void main(String[] args) {

    int[] A = {13, 20, 45, 69, 78, 100, 127, 155};

    System.out.println("Before:");

    for(int i=0; i < A.length; i++){

        System.out.print(A[i]+" ");
    }

    rearrange(A);

    System.out.println("After:");

    for(int i=0; i < A.length; i++){

        System.out.print(A[i]+" ");
    }



}

}

公共类问题3{
公共静态布尔重新排列（int[]A）
{
/*
输入：由n个排序整数（正、负或0）组成的数组A
A[0]在我看来，如果方法无法重新排列数组，您可以返回
false
。例如，如果违反了某些约定，则可能会返回。在您的任务中，我看到两个约定：


输入不应为
null
应该对输入数组进行排序

在这种情况下，您的方法可以如下所示：

public static boolean rearrange(int[] A) {
    if (A == null || !isSorted(A)) {
        return false;
     }

     .... rearranging algorithm here
     return true;
}

我认为使用loop交换数组和额外的指针变量J是相当昂贵的，因为如果使用loop，那么复杂性将增加到2N

循环将像（（N+1）+N）一样执行，这意味着2N。

我相信将钱投入递归将是一个有利的选择，下面我将分享一个我尝试递归的东西。但是返回应该独立于基本调用，在调用实际的工作函数逻辑之前可以自己进行验证

public class Problem3 {

    /*
     * Input: an array, A, of n sorted integers (positive, negative, or 0) that
     * A[0] <= A[1] <= A[2] <=…A[n-2] <= A[n-1]
     * 
     * Output: re-arrange elements in A such that: Element at even position
     * (i.e., A[0], A[2]) are less than or equal to both of its neighbors
     * Element at odd position (i.e., A[1], A[3]) are greater than or equal to
     * both of its neighbors
     * 
     * A[0] <= A[1] >= A[2] <= A[3] >= A[4] <= A[5]…
     * 
     * Design an algorithm that solves this problem in O(n) time.
     * 
     */
    public static int[] swap(int[] A, int i) {
        if (i < A.length - 1) {
            int temp = A[i];
            A[i] = A[i + 1];
            A[i + 1] = temp;
            i = i + 1;
            swap(A, i);
        }
        return A;
    }

    public static void main(String[] args) {

        int[] A = { 13, 20, 45, 69, 78, 100, 127, 155 };

        System.out.println("Before:");

        for (int i : A) {

            System.out.print(i + " ");
        }

        System.out.println("\nAfter:");

        for (int i : swap(A, 0)) {

            System.out.print(i + " ");
        }

    }

}

公共类问题3{
/*
*输入：由n个排序整数（正、负或0）组成的数组A
*[0]布尔值的返回取决于什么？您需要自己弄清楚该方法应该返回什么（或者询问谁给了您赋值），我们不能告诉您。我不确定，我需要以某种方式返回布尔值，但我认为我的代码不一定需要它。也许我应该添加一个if-else语句，根据元素是否到达数组的末尾返回true或false？即使这在for循环头中已经得到了处理。您尝试过吗运行你的代码？@VladBochenin是的，但是它显然不会在没有返回值的情况下运行，但是如果不需要返回值，它就会工作。如果你有小数组，递归是可以的。在另一种情况下，你可以得到StackOverflowException。你的代码不能解决问题：对于输入
13、20、45、69、78、100、127、155，它返回
2045 69 78 100 127 155 13
请您具体说明，在大数组的其他情况下，您会收到StackOverFlowException。因为如果您的递归处理不正确，就会发生StackOverFlowException。在上面的代码中，只有索引在限制内，我们才会将其放入递归，因此我不会导致StackOverFlowException。这方面的经验是什么这里，如果您交换完整的数组，这将是您的输出。如果这不对，请共享预期的输出。来自Javadoc:StackOverflower由于应用程序递归太深而发生堆栈溢出时引发的错误。堆栈大小取决于
-Xss
属性，在我的机器上，我可以使用数组中的12000个元素来访问它
swap（新整数[12000]，0）