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();
        }
    }

}