非递归的二叉树的深度遍历

这个问题看似很简单，但是在一个多月前就开始纠结一直没想到更好的解决方案，最开始一想到树就是递归去解决，的确之前的问题都可以用递归的方案，但是深度遍历的问题始终没找到思路，尝试着用非递归的方式去解决了问题。

随便画了个图去分析这个问题。例如要深度遍历这个树，每一层封装一个节点列表，然后去遍历这个列表，然后去封装新一层的列表，同时还要替换掉原来路径列表成分支的列表。以这个树为例。
第一层为节点值为10的节点列表，这个列表的长度为1。
然后遍历这个列表，发现有左分支5，然后remove 10并替换成列表[10,5]，然后发现有右分支12，然后在[10,5]后面添加列表[10,12].这样一层一层去遍历，最后得到的结果是[10,5,4],[10,5,7],[10,12]，这个过程当中应该注意控制add进去的先后顺序。

 public ArrayList<ArrayList<Integer>> FindPath(TreeNode root, int target) {
        if(target == 0)
            return new ArrayList<ArrayList<Integer>>();
        List<ArrayList<TreeNode>> allTreeNodeList = getAllList(root);
        ArrayList<ArrayList<Integer>> resultList = new ArrayList<ArrayList<Integer>>();
        for(ArrayList<TreeNode> list : allTreeNodeList){
            int sum = 0;
            ArrayList<Integer> tempList = new ArrayList<Integer>();
            for(TreeNode treeNode : list){
                sum += treeNode.val;
                tempList.add(treeNode.val);
            }
            if(sum == target)
                resultList.add(tempList);
        }
        return resultList;
    }
    //
    private List<ArrayList<TreeNode>> getAllList(TreeNode root){
        List<ArrayList<TreeNode>> allPathList = new ArrayList<ArrayList<TreeNode>>();
        ArrayList<TreeNode> layerTreeNodeList = new ArrayList<TreeNode>();
        layerTreeNodeList.add(root);
        allPathList.add(layerTreeNodeList);
        while(layerTreeNodeList.size() != 0){
            ArrayList<TreeNode> tempLayerTreeNodeList = new ArrayList<TreeNode>();
            for(TreeNode treeNode : layerTreeNodeList){
                //取出该treeNode的list
                ArrayList<TreeNode> tempTreeNodeList = getTreeNodeList(allPathList, treeNode);
                if(treeNode.left != null){
                    tempLayerTreeNodeList.add(treeNode.left);
                    ArrayList<TreeNode> tempLeftTreeNodeList = getNewTreeNodeList(tempTreeNodeList,treeNode.left);
                    updatePath(allPathList,tempTreeNodeList,tempLeftTreeNodeList);
                } 
                if(treeNode.right != null){
                    tempLayerTreeNodeList.add(treeNode.right);
                    ArrayList<TreeNode> tempRightTreeNodeList = getNewTreeNodeList(tempTreeNodeList, treeNode.right);
                    updatePath(allPathList,tempTreeNodeList,tempRightTreeNodeList);
                } 
            }
            layerTreeNodeList = tempLayerTreeNodeList;
        }
        return allPathList;
    }


    private void updatePath(List<ArrayList<TreeNode>> allPathList, ArrayList<TreeNode> tempTreeNodeList,
            ArrayList<TreeNode> tempForwardTreeNodeList) {
        //处理list的顺序问题,左分支
        int index = allPathList.indexOf(tempTreeNodeList);
        if(index != -1){
            allPathList.remove(tempTreeNodeList);
            allPathList.add(tempForwardTreeNodeList);
            for(int i = index;i < allPathList.size() - 1;i ++){
                allPathList.set(i + 1, allPathList.get(i));
            }
            allPathList.set(index, tempForwardTreeNodeList);
        } else {
            addRightForwardList(allPathList,tempForwardTreeNodeList);
        }
    }

    private void addRightForwardList(List<ArrayList<TreeNode>> allPathList,
        ArrayList<TreeNode> tempForwardTreeNodeList) {
        ArrayList<TreeNode> tempList = new ArrayList<TreeNode>();
        for(int i = 0;i < tempForwardTreeNodeList.size() - 1;i ++){
            tempList.add(tempForwardTreeNodeList.get(i));
        }
        int index = -1;
        for(ArrayList<TreeNode> list : allPathList){
            ArrayList<TreeNode> temp = new ArrayList<TreeNode>();
            for(int i = 0;i < list.size() - 1;i ++){
                temp.add(list.get(i));
            }
            if(temp.equals(tempList)){
                index = allPathList.indexOf(list);
                allPathList.add(tempForwardTreeNodeList);
                for(int i = index + 1;i < allPathList.size() - 1;i ++){
                    allPathList.set(i + 1, allPathList.get(i));
                }
                allPathList.set(index + 1, tempForwardTreeNodeList);
                break;
            }
        }
}
    private ArrayList<TreeNode> getNewTreeNodeList(ArrayList<TreeNode> list, TreeNode TreeNode){
        ArrayList<TreeNode> tempTreeNodeList = new ArrayList<TreeNode>();
        for(TreeNode n : list){
            tempTreeNodeList.add(n);
        }
        tempTreeNodeList.add(TreeNode);
        return tempTreeNodeList;
    }
    private ArrayList<TreeNode> getTreeNodeList(List<ArrayList<TreeNode>> list, TreeNode TreeNode){
        for(ArrayList<TreeNode> inList : list){
            if(inList.get(inList.size() - 1) == TreeNode)
                return inList;
        }
        return null;
    }