BST Sequences java 走地牙CTCI 4.9 结果会输出四遍 不知道原因！！！！！

/*
4.9 BST Sequences: A binary search tree was created by traversing through an array from left to
right and inserting each element. Given a binary search tree with distinct elements, print all
possible arrays that could have led to this tree.

要求找到bst的所有arrays，这个顺序有点复杂，意思是root要在所有子节点之前就行，两个子节点没有顺序；所以题目可以简化成一个节点A与两个
序列arr1和arr2的故事，例如A = 4， arr1{1,2,3} arr2{5,6,7};
               我们要做的是先把 {4, 1} {2,3} {5,6,7}
                                     {4,1,2} {3} {5,6,7}
                                           {4,1,2,3} {""} {5,6,7}
                                                :
                                                :
                                                :
                              {4, 5} {1,2,3} {6,7}
                                    {4,5,1} {2,3} {6,7}
                                               :
                                               :
                                               :
想写成这种形式首先需要一个递归把tree传递下去 返回的是ArrayList<LinkedList<Integer>>;
递归过程中回得到两个list<list> 分别是一左一右，然后把list<list> 中的每个list 都两两对应的编织起来
编织的过程也需要一个递归实现，建立一个存放root的list；每次把root的值存入list 然后递归下去，知道两个list又一个为空；

过程很复杂，代码实现。
*/
import java.util.*;

public class Main {

    public static void main(String[] args) {
        System.out.println("Hello World!");
        TreeNode node = new TreeNode(4);
        node.left = new TreeNode(1);
        node.right = new TreeNode(5);
        node.left.left = new TreeNode(2);
        node.left.right = new TreeNode(3);
        node.right.left = new TreeNode(6);
        node.right.right = new TreeNode(7);
        ArrayList<LinkedList<Integer>> allSequence = allSequences(node);
        printSeq(allSequence);
    }

    public static ArrayList<LinkedList<Integer>> allSequences(TreeNode root) {
        ArrayList<LinkedList<Integer>> result = new ArrayList<>();

        if(root == null) {
            result.add(new LinkedList<Integer>());
            return result;
        }

        LinkedList<Integer> prefix = new LinkedList<>();
        prefix.add(root.val);
        ArrayList<LinkedList<Integer>> leftSeq = allSequences(root.left);
        ArrayList<LinkedList<Integer>> rightSeq = allSequences(root.right);

        for(LinkedList<Integer> left : leftSeq) {
            for(LinkedList<Integer> right : rightSeq) {
                ArrayList<LinkedList<Integer>> weavedList = new ArrayList<LinkedList<Integer>>();
                weaved(left, right, weavedList, prefix);
                result.addAll(weavedList);
            }
        }
        return result;
    }

    public static void weaved(LinkedList<Integer> left, LinkedList<Integer> right,
                              ArrayList<LinkedList<Integer>> weavedList, LinkedList<Integer> prefix) {
        if(left.size() == 0 || right.size() == 0) {
            LinkedList<Integer> result = (LinkedList<Integer>)prefix.clone();
            result.addAll(left);
            result.addAll(right);
            weavedList.add(result);
            return;
        }

        int headOfLeft = left.poll();
        prefix.add(headOfLeft);
        weaved(left, right, weavedList, prefix);
        prefix.removeLast();
        left.addFirst(headOfLeft);

        int headOfRight = right.poll();
        prefix.add(headOfRight);
        weaved(left, right, weavedList, prefix);
        prefix.removeLast();
        right.addFirst(headOfRight);
    }

    public static void printSeq(ArrayList<LinkedList<Integer>> list) {
        for(int i = 0; i < list.size(); i++) {
            for(int j = 0; j < list.get(i).size(); j++) {
                System.out.print(list.get(i).get(j));
            }
            System.out.println();
        }
    }

}