JAVA中递归传递引用的问题

[顽皮猫喵]

我的main函数是这样的:

 public static void main(String[] args) {
        Search_BTree tree2=null,pre=new Search_BTree();
        tree2 = Search_BTree.autoCreate(3);
        tree2.createSearchBTreeEn(tree2,pre);
    }

Search_BTree类是这样的:

public class Search_BTree {
    public Search_BTree Left;
    public Search_BTree Right;
    public String str;
    public int ltag;//1表示指向前驱或后继 0 表示指向孩子
    public int rtag;

    //变为线索二叉
    public void createSearchBTreeEn(Search_BTree tree,Search_BTree pre){
        if(null == tree)
            return ;
        createSearchBTreeEn(tree.Left,pre);
        if(null == tree.Left){
            tree.ltag=1;
            tree.Left=pre;
        }
        if(null == pre.Right){
            pre.rtag=1;
            pre.Right=tree;
        }
        pre = tree;

        createSearchBTreeEn(tree.Right,pre);
    }

    //前序遍历创建二叉树
    public static Search_BTree createSearchBTree(Search_BTree tree){
        String str = new Scanner(System.in).next();
        if(!str.equals("#")){
            tree=new Search_BTree(str);
            tree.Left=createSearchBTree(tree.Left);
            tree.Right=createSearchBTree(tree.Right);
            return tree;
        }
        return null;
    }

    //自动创建满二叉树
    public static Search_BTree autoCreate(int k){
        int sum = (int)Math.pow(2,k)-1;
        int hasChildren = (int)Math.pow(2,k-1)-1;
        Search_BTree list[] = new Search_BTree[sum+1];
        for(int i=1;i<=sum;i++){
            list[i]=new Search_BTree(String.valueOf(i));//全部赋值1,2,3,4.....
        }
        for(int i=1;i<=hasChildren;i++){
            list[i].Left=list[2*i];
            list[i].Right=list[2*i+1];
        }
        return list[1];
    }

    //层次遍历
    public void Hierarchy(Search_BTree tree){
        int current=-1,position=0;
        List<Search_BTree> list = new ArrayList();
        if(tree!=null){
            list.add(tree);
            while(current!=position){
                current++;
                if(list.get(current).Left!=null){
                    list.add(list.get(current).Left);
                    position++;
                }
                if(list.get(current).Right!=null){
                    list.add(list.get(current).Right);
                    position++;
                }
            }
            for (Search_BTree node : list){
                System.out.println(node.str);
            }
        }
    }

    //层次遍历递归
    public void HierarchyDG(Search_BTree tree,int k,List list){
        if(tree!=null){
            if(k==1){
                list.add(tree);
            }
            if(tree.Left!=null){
                list.add(tree.Left);
            }
            if(tree.Right!=null){
                list.add(tree.Right);
            }
            if(tree.Left!=null){
                HierarchyDG(tree.Left,k+1,list);
            }
            if(tree.Right!=null){
                HierarchyDG(tree.Right,k+1,list);
            }
        }
    }


    public Search_BTree() {
    }

    public Search_BTree(String str) {
        this.str = str;
    }
}

问题在于Search_BTree里面， createSearchBTreeEn方法里面有一句 pre = tree; 可以 我在自动创建的满二叉树里面，单步调试后，发现这句话并没有传递引用啊，跳出来后，pre又变回原来的值了，之前pre = tree这里改变了指针的指向没用了。！！？这是为啥，求大神帮忙啊！！

[顽皮猫喵]

上面的问题我用static变量已经解决了，把pre设成一个全局的static静态变量。 换个问题，我下面两个层次遍历的，非递归的方法是对的，可以递归的层次遍历有问题，我也知道也有问题，可是我想不出来如何递归写出层次遍历了。

[夫为欲往_皆如是也]

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Search_BTree {
    public Search_BTree Left;
    public Search_BTree Right;
    public String str;
    public int ltag;//1表示指向前驱或后继 0 表示指向孩子
    public int rtag;

    //变为线索二叉
    public void createSearchBTreeEn(Search_BTree tree,Search_BTree pre){
        if(null == tree)
            return ;
        createSearchBTreeEn(tree.Left,pre);
        if(null == tree.Left){
            tree.ltag=1;
            tree.Left=pre;
        }
        if(null == pre.Right){
            pre.rtag=1;
            pre.Right=tree;
        }
        pre = tree;

        createSearchBTreeEn(tree.Right,pre);
    }

    //前序遍历创建二叉树
    public static Search_BTree createSearchBTree(Search_BTree tree){
        String str = new Scanner(System.in).next();
        if(!str.equals("#")){
            tree=new Search_BTree(str);
            tree.Left=createSearchBTree(tree.Left);
            tree.Right=createSearchBTree(tree.Right);
            return tree;
        }
        return null;
    }

    //自动创建满二叉树
    public static Search_BTree autoCreate(int k){
        int sum = (int)Math.pow(2,k)-1;
        int hasChildren = (int)Math.pow(2,k-1)-1;
        Search_BTree list[] = new Search_BTree[sum+1];
        for(int i=1;i<=sum;i++){
            list[i]=new Search_BTree(String.valueOf(i));//全部赋值1,2,3,4.....
        }
        for(int i=1;i<=hasChildren;i++){
            list[i].Left=list[2*i];
            list[i].Right=list[2*i+1];
        }
        return list[1];
    }

    //层次遍历
    public void Hierarchy(Search_BTree tree){
        int current=-1,position=0;
        List<Search_BTree> list = new ArrayList();
        if(tree!=null){
            list.add(tree);
            while(current!=position){
                current++;
                if(list.get(current).Left!=null){
                    list.add(list.get(current).Left);
                    position++;
                }
                if(list.get(current).Right!=null){
                    list.add(list.get(current).Right);
                    position++;
                }
            }
            for (Search_BTree node : list){
                System.out.println(node.str);
            }
        }
    }

    //层次遍历递归
    public void HierarchyDG(int k,List list,List<Search_BTree> children){
    	if(children.size() == 0)
    		return;
    	if(k==1){
    		for (Search_BTree search_BTree : children) {
    			list.add(search_BTree);
    		}
		}
    	List<Search_BTree> newChildren = new ArrayList<Search_BTree>();
    	for (int j = 0; j < children.size(); j++) {
    		Search_BTree tree = children.get(j);
    		if(tree!=null){
    			
    			if(tree.Left!=null){
    				list.add(tree.Left);
    				newChildren.add(tree.Left);
    			}
    			if(tree.Right!=null){
    				list.add(tree.Right);
    				newChildren.add(tree.Right);
    			}
    			
//            if(tree.Left!=null){
//                HierarchyDG(tree.Left,k+1,list);
//            }
//            if(tree.Right!=null){
//                HierarchyDG(tree.Right,k+1,list);
//            }
    		}
		}
    	HierarchyDG(k+1, list, newChildren);
    }


    public Search_BTree() {
    }

    public Search_BTree(String str) {
        this.str = str;
    }
    
    public static void main(String[] args) {
        Search_BTree tree2=null;
        tree2 = Search_BTree.autoCreate(3);
        Search_BTree search_BTree = new Search_BTree();
        List<Search_BTree> list = new ArrayList<Search_BTree>();
        List<Search_BTree> children = new ArrayList<Search_BTree>();
        children.add(tree2);
        search_BTree.HierarchyDG(1, list, children);
        for (Search_BTree item : list) {
			System.out.println(item.str);
		}
    }
}

就改了递归的地方，你试试

[llihua]

算法有点意思啊，代码问题不大。createSearchBTreeEn()的参数pre，传的是对象引用变量啊，退出方法后，pre就变回调用之前的变量值，引用之前的对象了。Java就是这样，不像C/C++，可以传指针，然后把更新返回到外层。 如果要返回更新的pre，确实没有特别好的办法，要么把pre做成static或全局变量，要么通过方法的返回值返回，要么封装一个类作参数，然后通过类中的成员来返回多个值。 另外，那个层次遍历递归HierarchyDG()方法也有点怪，实际遍历的顺序既不是前序后序或中序，也不是深度优先或广度优先遍历。Hierarchy()方法倒是广度优先遍历的。

[KeepSayingNo]

可以在main方法里面定义一个变量，然后将这个变量传到递归方法中，递归方法重复用这个变量

[薛之谦福州分谦]

如果只有两层递归用lambda会比较简单简洁

[薛之谦福州分谦]

这是我上次项目里面用到的两层菜单不知道能不能帮助你