如何实现二叉树？

二叉树的实体类

/**
 * @description 二叉树的实现类
 */

public class BinaryTree<T extends Comparable<T>> {

    private class Node {
        private Comparable<T> data;
        private Node parent; // 父节点
        private Node left; // 左子树
        private Node right; // 右子树

        Node(Comparable<T> data) {
            this.data = data;
        }

        /**
        * @description: 添加节点
        * @param node
        * @return void
        */
        public void addNode(Node node) {
            // 要加入当前节点的节点，比当前节点要小
            if (node.data.compareTo((T) this.data) <= 0) {
                if (this.left == null) {
                    // 当前节点的左节点不存在，加入左节点
                    this.left = node;
                    // 保存父节点
                    node.parent = this;
                } else {
                    // 当前节点的左节点已经存在，继续向下做判断
                    this.left.addNode(node);
                }
            } else { // 要加入当前节点的节点，比当前节点大
                if (this.right == null) {
                    // 当前节点的右节点不存在，加入右节点
                    this.right = node;
                    // 保存父节点
                    node.parent = this;
                } else {
                    // 当前节点的右节点已经存在，继续向下做判断
                    this.right.addNode(node);
                }
            }
        }

        public void toArrayNode() {
            if (this.left != null) {
                this.left.toArrayNode();
            }
            BinaryTree.this.returnData[BinaryTree.this.foot++] = this.data;
            if (this.right != null) {
                this.right.toArrayNode();
            }
        }
    }

    // ----------------------- 以下为二叉树的实现 -----------------------
    // 根节点
    private Node root;
    //统计节点个数
    private int count;
    //脚标
    private int foot;
    //返回数据
    private Object[] returnData;

    public void add(Comparable<T> data) {
        if (data == null) {
            throw new NullPointerException("添加的数据为空");
        } else {
            Node newNode = new Node(data);
            if (root == null) {
                root = newNode;
            } else {
                root.addNode(newNode);
            }
        }
        this.count++;
    }

    /**
    * @description: 获取返回值
    * @param
    * @return java.lang.Object[]
    */
    public Object[] returnArrayData() {
        //若当前二叉树长度为0，直接返回null
        if (this.count == 0) {
            return null;
        }
        // 有多少个节点就创建多少个长度的对象
        returnData = new Object[this.count];
        //直接通过Node类负责
        this.root.toArrayNode();
        //脚标清0
        this.foot = 0;
        return this.returnData;
    }

}

实体类

/**
 * @description 实体类
 */

public class Person implements Comparable<Person>{
    @Override
    // 当前对象大于比较对象时为正数，当前对象小于比较对象为负数，相等为0(正序排序)
    public int compareTo(Person o) {
        return this.age - o.age;
    }

    private String name;
    private Integer age;

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

测试类

import java.util.Arrays;

/**
 * @description
 */

public class BinaryTreeTest {
    public static void main(String[] args) {
        BinaryTree<Person> tree = new BinaryTree<>();
        tree.add(new Person("张三",20));
        tree.add(new Person("李四",10));
        tree.add(new Person("王五",50));
        tree.add(new Person("赵六",30));
        System.out.println(Arrays.toString(tree.returnArrayData()));
    }
}

结果：

[Person{name=‘李四’, age=10}, Person{name=‘张三’, age=20}, Person{name=‘赵六’, age=30}, Person{name=‘王五’, age=50}]