Java二叉树按顺序插入

在java中，如何将项插入到二叉树中，使它们按顺序排列？我想使用随机值，从最小值到最大值排序，然后按以下顺序将它们插入到二叉树中：

          1
     2         3
   4   5     6   7
 8  9

---

当你说“按顺序”时，你需要澄清，你是指按排序顺序还是指插入顺序，等等

或上有大量可用资源，我怀疑这是重复的

你的例子有什么不同？将“1”作为根节点意味着您不能有重新平衡树，因为“2”和“3”都大于根节点的值。您的插入规则似乎不一致，因为如果“1”是插入的第一个节点，那么所有其他值都将级联到树的右分支，除非您对根使用不同的规则，然后在其他级别使用不同的规则，这将是一个编码难题。

类似的内容：

public class BinaryTree {
    private List<Integer> list = new ArrayList<Integer>();


    public class BinaryTreeNode {
        private int p;

        public BinaryTreeNode(int p) {
            this.p = p;
        }

        private BinaryTreeNode getChild(int childP){
            BinaryTreeNode result= null;
            if (childP < list.size()){
                result = new BinaryTreeNode(childP);
            }
            return result;
        }

        public BinaryTreeNode getLeft(){
            return getChild(p*2+1);
        }

        public BinaryTreeNode getRight(){
            return getChild(p*2+2);
        }

        public int getValue(){
            return list.get(p);
        }
    }

    public void add(int item){
        list.add(item);
    }

    public BinaryTreeNode getRoot(){
        BinaryTreeNode result = null;
        if (!list.isEmpty()){
            result = new BinaryTreeNode(0);
        }
        return result;
    }
}

公共类二进制树{
私有列表=新的ArrayList（）；
公共类二元树节点{
私人INTP；
公共二进制树节点（INTP）{
这个，p=p；
}
私有二进制树节点getChild（int childP）{
二进制树节点结果=null；
if（childP

在中，我遇到了这个我最喜欢的实现：

public interface TreeVisitor<E, R> {
    public R visit(E leaf);

    public R visit(E value, Tree<E> left, Tree<E> right);
}

public abstract class Tree<E> {

    public abstract <R> R accept(TreeVisitor<E, R> visitor);

    public static <E> Tree<E> leaf(final E leaf) {
        return new Tree<E>() {
            @Override
            public <R> R accept(TreeVisitor<E, R> visitor) {
                return visitor.visit(leaf);
            }
        };
    }

    public static <E> Tree<E> branch(final E value, final Tree<E> left, final Tree<E> right){
        return new Tree<E>(){
            @Override
            public <R> R accept(TreeVisitor<E, R> visitor) {
                return visitor.visit(value, left, right);
            }
        };
    }
}

public interface TreeVisitor{
公众参观(E leaf);；
公共R访问（E值、左树、右树）；
}
公共抽象类树{
公开摘要R接受（TreeVisitor访问者）；
公共静态树叶（最终E叶）{
返回新树（）{
@凌驾
公共R接受（TreeVisitor访客）{
回访者。参观（叶）；
}
};
}
公共静态树分支（最终E值、左最终树、右最终树）{
返回新树（）{
@凌驾
公共R接受（TreeVisitor访客）{
回访访客。访问（值、左、右）；
}
};
}
}

现在，您可以添加任何需要的操作，并按如下方式创建树：

Tree<Integer> t = Tree.branch(1, 
            Tree.branch(2, 
                Tree.branch(4, Tree.leaf(8), Tree.leaf(9)), Tree.leaf(5)),
                Tree.branch(3, Tree.leaf(6), Tree.leaf(7));

Tree t=Tree.branch（1，
树枝（2，
树.枝（4，树.叶（8），树.叶（9）），树.叶（5）），
树.枝（3，树.叶（6），树.叶（7））；

我找到了我需要的答案

---

我提到的其他一些东西，要么不是我想要的，要么不是超过8个左右的值。

这还不完全清楚。这里的数字是什么意思；它们是值，还是代表你添加东西的顺序？如果是后者，那么这应该相对容易。如果是前者，你会每次插入时我都需要移动一堆东西。@OliverCharlesworth很清楚。他想要一个完整的二叉树。@alifirat它不是一个二叉搜索树，只是一个二叉树（完整）它们正是我想要添加值的顺序。这似乎是一个很好的实现，但我一直在寻找更传统的东西，如其他答案所示。@Relindrani注意，该实现是完全线程安全的，因为您没有可以修改的变量。我自己在我们的项目中使用它。