Java中的二叉树插入

Question

I have a list like the following. I would like to know how to create a binary tree with this type of list in Java. Can anyone provide me with some binary tree insertion code in Java for this type of list?

For example:

List 1:  AND AND AND G M S T

The binary tree will be:

       AND
   AND                AND 
 G     M            S     T

And for this list:

List 2: AND AND G M S

The binary tree will be:

              AND
  AND          S
 G   M          

I tried following method for insertion:

public void insert(RDFQuery node,  RDF leafValue) { 
    flag++;
    if ((flag%2)!=0) {
        if (node.left  != null) {
            flag--;
            nodeStore=node.left;
            leftFlag=1;
            insert(node.left, leafValue);
        } 
        else { 
              node.left = new RDFQuery(leafValue);
        }

    }       
    if ((flag%2)==0) {
        if (leftFlag==1) {
            node=nodeStore; 
            leftFlag=0;
        }

        if (node.right  != null) {
              flag--;   
              insert(node.right, leafValue);
        } 
        else { 
              node.right = new RDFQuery(leafValue);
              rightFlag=0;
        }
    }
}

Answer 1

I'm unsure how you want to turn your lists into trees, as I cannot reproduce both of your examples using any of the obvious algorithms I can think of.

Fill by row, breadth first

Usually, I'd fill in a level from left to right, before continuing in the next level. For your example input, this would result in the following tree:

List 2: AND AND G M S

        AND
       /   \
    AND     G
  /    \ 
 M      S

There are various ways you could implement this. One would be maintaining two numbers: the index of the row you're currently inserting into (ie the depth) and the index of the new leaf within that row. The bit pattern of that index within the row would tell you the order of left and right children, starting at the root with the most significant bit. The depth would tell you how many bits you have to consider, ie which bit is the most significant of those you have to handle.

Prefix notation

On the other hand, the names of your elements suggest that some of them have a fixed arity. I imagine AND to be a binary operator in all cases, whereas the simple symbols are probably nullary. However, with this interpretation, your first example would result in a different list:

       AND
     /     \
  AND       AND 
 /   \     /   \         
G     M  S      T

AND ( AND ( G, M ), AND ( S, T ) )
List 1: AND AND G M AND S T

If thsi were your interpretation, then you'd probably best maintain a reference to the current node, and after the last expected child has been added to it, switch from parent to parent until you reach a node which still expects children.