从BST（二进制搜索树）到链表列表

Question

A binary search tree was created by traversing through an array from left to right and inserting each element. This tree may not be a balanced tree. Given a binary search tree with distinct elements, print all possible arrays that could have led to this tree.

To answer to this question I wrote the following code. Still, it seems that it doesn't print all possible arrays that could have lead to the the tree in all the cases. What do you think should be modified ?

public class Main {

  public static LinkedList<Integer> passed = new LinkedList<>();
    public static LinkedList<BinaryTree> notyet = new LinkedList<>();
    public static ArrayList<LinkedList<Integer>> results = new ArrayList<LinkedList<Integer>>();



public static void main(String args[]) {
    BinaryTree tr = readTree();
    ArrayList<LinkedList<Integer>> result = allSequences(tr);
    for (LinkedList<Integer> l : result){
        for(int elem: l) System.out.print(elem+" ");
        System.out.println("");
    }
}
private static BinaryTree readTree() {
    BinaryTree tr = new BinaryTree(2, null, null);
    tr.left = new  BinaryTree(1, null, null);
    tr.right = new  BinaryTree(3, null, null);
    return tr;
}

public static ArrayList<LinkedList<Integer>> allSequences(BinaryTree tr){
    // implement here
    ArrayList<LinkedList<Integer>> result = new ArrayList<LinkedList<Integer>>();


    findseqs(passed,notyet,tr);
    //result=results.clone();
    for(LinkedList<Integer> sample :results){
        result.add(sample);
    }


    return result;
}


public static void findseqs(LinkedList<Integer> passed, LinkedList<BinaryTree> notyet, BinaryTree tr) {
    passed.add(tr.value);

    if (tr.left != null) notyet.add(tr.left);
  if (tr.right != null) notyet.add(tr.right);

  if (notyet.isEmpty()) {
    results.add(passed);
  }

  for (BinaryTree elem: notyet) {
    LinkedList<Integer> temp = (LinkedList<Integer>) passed.clone();
    LinkedList<BinaryTree> ptemp = (LinkedList<BinaryTree>) notyet.clone();
    ptemp.remove(elem);
    findseqs(temp, ptemp, elem);
  }


  }

Answer 1

What holds about the array is that if A is ancestor of B in the graph then A precedes B in the array. Nothing else can be assumed. So the arrays can be produced by the following recursive function.

function sourceArrays(Tree t)

  // leafe node
  if t == null
    return empty list;

  r = root(t);
  append r to existing arrays;

  la = sourceArrays(t.left);
  ra = sourceArrays(t.right);

  ac = createArrayCombitations(la, ra);
  append ac to existing arrays;

end

function createArrayCombitations(la, ra)


  foreach a in la
    foreach b in ra
      r = combineArrays(a,b);
      add r to result;
    end
  end

end

function combineArrays(a, b)
  generate all combinations of elements from two array such that order of elements in each array is preserved.
  Ie if x precedes y in a or b the x precedes y in result