Java中递归的如果想要达到C++的传参效果的一种写法

常识：

我们都知道 Java方法的参数传递是值传递，就是说如果参数是基本数据类型，那么直接拷贝一份副本给形参，如果参数是对象，不是基本数据类型，那么拷贝对象的引用的副本，也就是相等于是拷贝了一份指向这个对象指针，这样在方法中通过形参修改对象的属性或者字段，是会对原来的对象产生影响的，因为本质上这两个是同一个对象。

问题：

C++里面的值传递是在形参中拷贝一份对象的副本，而Java中没有这种传递方式，Java中的值传递类似于C++里面的引用传递。所以C++的递归在不同深度的递归中形参中的对象是不会相互影响的，所以C++天生就帮我们做了递归层次之间的参数隔离，但是Java 会有这个问题，Java方法中的参数传递不会重新创建对象，而是引用的同一个对象，所以后面更深层次的递归就会对回溯后的形参对象产生影响。
我考虑的是怎么消除这种影响，达到和C++一样的效果。

 比如图中代码中的这个函数形参中的两个对象，一个栈，和一个列表，我怎么样可以让更深次的修改不会对回溯后的本层次造成影响呢，

我的方式是：既然这两个对象在每个层次的递归都是一样的，都是这两个对象，那么这两个对象定义成局部变量就没有什么用了，所以干脆定义成全局变量，但是在每次在本层次递归进行后，都必须进行回溯，消除递归的影响，改动后的代码如下：

我们以往的递归往往是不会在最后一个选择后进行消除回溯的，因为这没什么用，但是这里需要回溯。

这个代码完整的问题如下：

栈是一种重要的数据结构，其主要的操作包括入栈和出栈。请编写程序，对任意给定的n，输出 1，2，…，n 的所有出栈顺序。
输入：正整数 n（1≤n≤9）
输出：输出 1，2，…，n 的所有出栈顺序

例如：

 用递归的思路进行解题：每次进入递归都判断这次是入栈还是出栈

C++式写法：

// 栈是一种重要的数据结构，其主要的操作包括入栈和出栈。请编写程序，对任意给定的n，输出 1，2，…，n 的所有出栈顺序。
#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stack>
#include <vector>
using namespace std;

int n;
vector<vector<int>> v;

void dfs(int i, stack<int> S, vector<int>& temp)
{
    // 每次进入dfs， 判断是否大于等于n, 如果大于n，存储数据，返回
    if (i > n && S.empty()){
        v.push_back(temp);
        return;
    }

    // 选择入栈当前元素还是出栈栈顶元素
    // 选择入栈当前元素
    if (i <= n)
    {
        S.push(i);
        dfs(i + 1, S, temp);
        S.pop();            // 消除入栈的影响
    }

    // 选择出栈当前元素
    if (!S.empty())
    {
        temp.push_back(S.top());
        S.pop();
        dfs(i, S, temp);
        temp.pop_back();
    }
}

int main()
{
    // 读取数据
    scanf("%d", &n);
    // 对这个数据进行dfs递归，求出所有出栈顺序
    stack<int> S;
    vector<int> temp;            // 存储一个弹出序列
    dfs(1, S, temp);

    for (int i = 0; i < v.size(); i++){
        for (int j = 0; j < v[i].size(); j++)
            printf("%d ", v[i][j]);
        printf("
");
    }

    return 0;
}

我把这个C++代码初步改成Java代码

package report2;

import java.util.ArrayList;
import java.util.Scanner;
import java.util.Stack;

// 利用递归打印所有出栈序列
public class Solution1_1 {
    // 存储全排列的数组
    public static ArrayList<ArrayList<Integer>> ps =
            new ArrayList<>();
    public static int n;


    public static void main(String[] args) {
        // 读取输入
        Scanner in = new Scanner(System.in);
        n = in.nextInt();

        // 对这个数据进行dfs递归，求出所有出栈顺序
        Stack<Integer> s = new Stack<>();
        ArrayList<Integer> tmp = new ArrayList<Integer>();
        stackPopPermutation(1, s, tmp);

        // 打印所有的出栈序列
        for(int i = 0; i < ps.size(); i++){
            for(int j = 0; j < ps.get(i).size(); j++){
                System.out.print(ps.get(i).get(j) + " ");
            }
            System.out.println();
        }
    }
    
    // tmp参数中存储的是临时的出栈序列
    private static void stackPopPermutation(int i, Stack<Integer> s, ArrayList<Integer> tmp) {
        // 每次进入递归，判断 i 是否大于等于n, 如果大于n,存储序列，返回
        if(i > n && s.empty()){
            ps.add(tmp);
            return;
        }
        // 选择入栈当前元素还是出栈栈顶元素
        // 选择入栈当前元素
        if (i <= n)
        {
            s.push(i);
            stackPopPermutation(i + 1, s, tmp);
            s.pop();            // 消除入栈的影响
        }

        // 选择出栈当前元素
        if (!s.empty())
        {
            tmp.add(s.peek());
            s.pop();
            stackPopPermutation(i, s, tmp);
            // tmp.remove(new Integer(i));
        }
    }
}

我同学的代码给我了思路，既然第一次选择后回溯可以使得全局变量回退到刚进入这个函数时的状态，那我第二次选择后再进行一次回溯是不是也可以回退到刚进入这个函数时的状态呢，这样是不是就达到了一种类似于在形参中传递了一个对象的拷贝，而非引用的拷贝呢，因为我们通过手动回溯的方式使得一个全局变量在进入递归到出递归状态没有发生变化，

S、S1、S2均表示一个全局变量的状态

S --> S1 --> 进入递归 --> 出递归 -->回溯 -- > S -- S2 -->进入递归 -- > 出递归 -- > 回溯 -- > S

最终的Java代码：

package report2;

import java.util.*;

// 利用递归打印所有出栈序列
public class Solution1 {

    public static Stack<Integer> s = new Stack<>();       // 一个工作栈
    public static LinkedList<Integer> tmp = new LinkedList<>();       // 存储一个临时的序列
    public static int n;


    public static void main(String[] args) {
        // 读取输入
        Scanner in = new Scanner(System.in);
        n = in.nextInt();

        // 对这个数据进行dfs递归，求出并打印所有的出栈序列
        stackPopPermutation(1);
    }

    // tmp参数中存储的是临时的出栈序列
    private static void stackPopPermutation(int i) {
        // 每次进入递归，判断 i 是否大于等于n, 如果大于n,存储序列，返回
        if(i > n && s.empty()){
            for(int j = 0; j < tmp.size(); j++){
                System.out.print(tmp.get(j) + " ");
            }
            System.out.println();
            return;
        }

        // 选择入栈当前元素还是出栈栈顶元素
        // 选择入栈当前元素
        if (i <= n)
        {
            s.push(i);
            stackPopPermutation(i + 1);
            s.pop();            // 消除入栈的影响
        }

        // 选择出栈当前元素
        if (!s.empty())
        {
            Integer top = s.peek();
            tmp.add(top);
            s.pop();
            stackPopPermutation(i);
            s.push(top);            // 消除回溯，消除出栈的影响
            tmp.removeLast();
        }
    }
}