Question

我一直在尝试编写一个用于创建二叉树的程序。我希望逐级添加节点。当我google主题时，我得到的只是二叉搜索树。这是代码

public class BinaryTree
{
    public static void main(String[] args)
        throws NullPointerException
    {
        Tree myTree = new Tree();
        myTree.add(2,new Node(4));
        myTree.add(4,new Node(5));
        myTree.add(2,new Node(6));
        //myTree.add(2,new Node(7));
    }
}
class Node
{
    int data;
    boolean visited;
    Node left,right;

    Node(int data)
    {
        left=null;
        right=null;
        visited=false;
        this.data=data;
    }
}
class Tree
{
    Node root;
    int level,cLevel;
    Tree()
    {
        root=null;
        level=0;
        cLevel=level-1;
    }

    protected void add(int data,Node node)
    {
        System.out.println("node.data k: "+node.data);
        Node t;
        if(root==null)
        {
            Node n=new Node(data);
            root=n;
            root.visited=true;
            System.out.println("root visited"+root.data+""+root.visited);
            level++;
            cLevel++;
            return;
        }
        while(root!=null)
        {

        }
    }
}

我想逐级添加新节点，不应该创建新级别，直到某个级别没有被创建，所有我通过谷歌搜索获得的是二叉搜索树。我应该怎么做，我试过使用深度优先，呼吸第一的方法，没有推动有用的。

Answer 1

您可以通过维护一个尚未生成两个子节点的节点队列来实现此目的。每次添加新节点时，将其粘贴在此队列的末尾，并使其成为此队列前端节点的子节点。一旦前面的节点有两个子节点，将其从队列中删除。通过这种方式，您可以从左到右一次构建一个级别，并且只有当前级别完成后才会进入下一级别。

Answer 2

您也可以尝试“限制深度优先搜索”
使用部分代码在Java中进行递归实现可能是：

class Tree
{
    Node root;
    int level,cLevel;
    Tree()
    {
        root=null;
        level=0;
        cLevel=level-1;
    }

    protected void add(int data)
    {
        System.out.println("data k: "+ data);
        Node t;
        if(root==null)
        {
            root=new Node(data);
            level++;
        } else {
            cLevel = 0;
            boolean added = add(data, root);
            //Couldn't add to current level, add new level
            if (!added){
                level++;
                cLevel = 0;
                add(data, root);
            }

        }
    }

    private boolean add(int data, Node node)
    {   
        cLevel++;
        boolean added;
        //Depth limited
        if (cLevel<=level){
            added = true;
            //Try to add to current node
            if (node.left == null)
                node.left = new Node(data);
            else if (node.right == null)
                node.right = new Node(data);
            else if (!add(data, node.left)) //Recursively trying to add to children 
                added = add(data, node.right);
        } else {
            added=false;
        }
        cLevel--;
        return added;
    }

}

希望它有所帮助。

Answer 3

完成它。谢谢Animatinator。虽然我已经用硬编码测试了它，因为我现在没有时间，但是我早上有一篇关于编译器构造的论文。

protected void add(int data,Tree mytree)
{
    if(root==null)
    {
        root=new Node(data);
        myList.addLast(root);
        root.count++;
        return;
    }
    Node node=mytree.myList.getFirst();
    if(root!=null)
    {
        if(node.left==null)
        {
            node.count++;
            node.left=new Node(data);
            mytree.myList.add(node.left);
            return;
        }
        else
        {
            node.count++;
            node.right=new Node(data);
            mytree.myList.add(node.right);
        }
        if(node.left!=null & node.right!=null)
        {
            mytree.myList.removeFirst();
        }
    }
}

用于逐级添加节点的二叉树实现

3 个答案: