Question

我试图制作一个递归方法，在打印时会给我以下结果（例如n = 5）：1 2 3 4 5 4 3 2 1.我可以轻松地以相反的方式实现它这段代码：

    public static void DownUp(int n) {
    if (n == 1) {
        System.out.print(n +" ");
    } else {
        System.out.print(n +" ");
        DownUp(n - 1);
        System.out.print(n +" ");
    }
}

这将给我结果：5 4 3 2 1 2 3 4 5，但由于递归的工作方式，我似乎无法按照我需要的方式进行。我可以使用2个参数来完成它，但是根据我的需要，我只想使用1个参数。我已经搜索过，在这里/其他地方使用ArrayList等找到了一些相似的帖子。这很不错，但不能给我带来我需要的结果。如果有人可以指导我如何做到这一点，那就太棒了，不，这不是功课。感谢。

Answer 1

您可以使用方法设置起始值：

public static void downUp(int limit) {

    downUp(1, limit);
}

private static void downUp(int value, int limit) {

    if (((2 * limit) - value) ==0 ) { return;}
    if (value > limit) {
        System.out.print((2 * limit) - value);
    } else {
        System.out.print(value);
    }

    downUp(++value, limit);
}

使用downUp(5);

进行测试

如果您不喜欢这个概念，可以将该方法封装在一个类中，并使用一个字段作为递增值：

class UpDown {

    static int value = 1;

    public static void downUp(int limit) {

        if (((2 * limit) - value) ==0 ) { return;}
        if (value > limit) {
            System.out.print((2 * limit) - value);
        } else {
            System.out.print(value);
        }
        value++;
        downUp(limit);
    }
}

使用UpDown.downUp(5);

进行测试

Answer 2

有一个占位符（此处为＆＃34; x＆＃34;），用于标记要插入递归调用结果的字符串中的位置。然后有一个包装器方法，它消除了最终返回的占位符。

/**
 * Removes the " x " + i from the helper's string.
 * E.g. "1 2 3 4 5 x 5 4 3 2 1" -> "1 2 3 4 5 4 3 2 1".
 */
public static String upDown(int i)
{
    return upDownHelper(i).replace(" x " + i, "");
}

/**
 * Returns a string e.g. "1 2 3 4 5 x 5 4 3 2 1" if i = 5.
 * The "x" marks the spot where, after a recursive call,
 * the method replaces its current "i" value.
 */
private static String upDownHelper(int i) {
    if (i == 1) {
        return "1 x 1";
    } else {
        return upDownHelper(i - 1).replace("x", i + " x " + i);
    }
}

这只需要1个参数。测试：

for (int i = 1; i <= 5; i++) {
    System.out.println(upDown(i));
}

输出：

1
1 2 1
1 2 3 2 1
1 2 3 4 3 2 1
1 2 3 4 5 4 3 2 1

Answer 3

没有额外的args，没有全局静态变量，并且具有与原始问题相同的print - 结构：

public class UpDown {
  public static void upDown(int i) {
    class Helper {
      void rec(int j) {
        if (i == j) {
          System.out.print(i);
        } else {
          System.out.print(j + " ");
          rec(j + 1);
          System.out.print(" " + j);
        }
      }
    };
    new Helper().rec(1);
  }
  public static void main(String[] args) {
    upDown(5);
  }
}

输出：

1 2 3 4 5 4 3 2 1

但并不完全是recursive，因为upDown从不调用自己。嵌套的rec是递归的。

Answer 4

private static void increasingDecreasing(int i, int n){
    if(i == n + 1) return;
    System.out.print(i + ", ");
    increasingDecreasing(i + 1, n);
    System.out.print(i + ", ");
}

执行5：increasingDecreasing(1, 5); 容易，简单和递归。这会奏效。

使用递归打印增加和减少的数字

4 个答案: