Java 如何在一个递归函数中先递增后递减？

我想提出一个递归函数，它以一个非负整数n作为输入，生成从0到n再到0的所有自然数的列表

例如，如果函数名为

ArrayList<Integer> f(int x)

ArrayList f（int x）

)；当x=4时，给出一个包含

{0,1,2,3,4,3,2,1,0}

如何实现这一点？在没有辅助函数（如倒计时和倒计时）的情况下，可以在一个函数中实现这一点。
需要逻辑！
谢谢你的帮助

以下是我的解决方案：

public ArrayList<Integer> f(int x) {
    ArrayList<Integer> arr;
    if (x == 1) {
        arr = new ArrayList<Integer>();
        arr.add(0);
        arr.add(1);
        arr.add(0);

    } else {
        arr = f(x-1);
        int pos = (int) (arr.size() / 2)+1;
        arr.add(pos, x);
        arr.add(pos + 1, x-1);

    }
    return arr;
}

公共数组列表f（int x）{
ArrayList-arr；
如果（x==1）{
arr=新的ArrayList（）；
arr.add（0）；
arr.add（1）；
arr.add（0）；
}否则{
arr=f（x-1）；
int pos=（int）（arr.size（）/2）+1；
arr.add（位置x）；
arr.add（位置+1，x-1）；
}
返回arr；
}

在该算法中，我将x的基值设置为1，其中生成的数字应为[0,1,0]

如果x大于1，则递归生成x-1的列表，然后在返回列表的适当位置插入两个值x和x-1，该位置基本上位于中间值旁边的位置

e、 g

如果x等于2； 获取1的值-即[0,1,0]
然后在第三个位置（中间后的位置）插入2和1，得到[0,1,2,1,0]

如果x等于3； 获取2的值-即[0,1,2,1,0]
然后在第四个位置插入3和2，得到[0,1,2,3,2,1,0]

---

etc.

recArray是递归函数，以递归方式作为arraylist返回

 int x=10;
 List<Integer> result=null;
result=recArray(x,result);

intx=10；
列表结果=空；
结果=重新排列（x，结果）；

如果您迭代结果数组列表，它将具有您所说的数字

public List<Integer> recArray(Integer x, List<Integer> result) {
    if (result == null) {
        result = new ArrayList<Integer>();
        for (int i = 0; i < 2 * x + 1; i++) {
            result.add(0);
        }
        result.set(x, x);
    }
    int pos = result.size() / 2;

    result.set(pos - x, pos - x);
    result.set(pos + x, pos - x);
    if (x == 0) {
        return result;
    }

    return recArray(x - 1, result);

}

公共列表重新排列（整数x，列表结果）{
如果（结果==null）{
结果=新的ArrayList（）；
对于（int i=0；i<2*x+1；i++）{
结果：添加（0）；
}
结果集（x，x）；
}
int pos=result.size（）/2；
结果集（pos-x，pos-x）；
结果集（pos+x，pos-x）；
如果（x==0）{
返回结果；
}
返回重新排列（x-1，结果）；
}

谢谢，

---

阿鲁穆加拉尼

你可以这样做：

ArrayList<Integer> f(int x) {
    if (x==0) {
        ArrayList<Integer> res = new ArrayList<>();
        res.add(0);
        return res;
    }
    ArrayList<Integer> t = f(x-1);
    t.add(t.size()/2, x-1);
    t.add(t.size()/2, x);       
    return t;
}

ArrayList f（int x）{
如果（x==0）{
ArrayList res=新的ArrayList（）；
决议添加（0）；
返回res；
}
阵列列表t=f（x-1）；
t、 添加（t.size（）/2，x-1）；
t、 添加（t.size（）/2，x）；
返回t；
}

假设您有一个函数，它生成一个从1到n再到1的自然数列表。在一个生成以0开始和结束的列表的函数中，您将如何使用它？@Becojo不是一个家庭作业，您的递归有三种边缘情况：1）当您开始时，2）当您的数字到达

n

3）当您返回到起始点时。仔细想想，这很容易。@mostruash但是如果没有全局变量被允许在它到达n时检测到该怎么办？将分配推送到边缘案例编辑：pushed allocation arr=new ArrayList（）推送到边缘案例。