简单二叉树的理解和实现

首先，什么是数据结构？数据结构是数据的逻辑结构，而不是物理结构（数据的真是存储结构），逻辑结构可以帮助我们更好的去处理大批量的数据。接触过数据结构的人都知道树这种结构。最常见的就是二叉树，主要是用来进行数据的查找，且时间的平均复杂度为log(n)，原理有点类似二分查找。二叉树的提出和对象比较Comparable是分不开的。二叉树包含两个子结点的引用，左子树left和右子树right，当要存入数据对象的时候，比当前结点对象值小的或相等的放入left，否则放入right。数据对象需继承Comparable接口。

interface IBinaryTree<T extends Comparable<T>> {
    void add(T data);

    int getCount();

    Object[] getList();

    Object[] getList2();

    void add2(T data);

}

class BinaryTreeImp<T extends Comparable<T>> implements IBinaryTree<T> {
    private Node root;
    private int count;
    private Object[] list;
    private int foot;
    private Node cacheNode;

    @Override
    public void add(T data) {
        if (data == null) {
            return;
        }
        Node newNode = new Node(data);
        if (this.root == null) {
            this.root = newNode;
        } else {
            this.root.addNode(newNode);
        }
        this.count++;
    }

    @Override
    public int getCount() {
        return this.count;
    }

    //中序遍历
    @Override
    public Object[] getList() {
        if (this.root == null) {
            return null;
        }
        list = new Object[this.count];
        this.foot = 0;
        this.root.toList();
        return list;
    }

    //中序遍历方法二
    @Override
    public Object[] getList2() {
        if (this.root == null) {
            return null;
        }
        list = new Object[this.count];
        this.foot = 0;
        getAll(this.root);
        return list;
    }

    //递归核心
    public void getAll(Node node) {
        if (node == null)
            return;
        getAll(node.left);
        list[foot++] = node.data;
        //System.out.println(node.data);
        getAll(node.right);
    }

    //增加数据的方法二
    @Override
    public void add2(T data) {
        if (data == null) {
            return;
        }
        Node newNode = new Node(data);
        this.cacheNode = this.root;
        if (this.root == null) {
            this.root = newNode;
        } else {
            addNode2(newNode);
        }
        this.count++;
    }



    private void addNode2(Node newNode) {
        if (cacheNode.data.compareTo(newNode.data) <= 0) {
            if (cacheNode.left == null) {
                cacheNode.left = newNode;
            } else {
                cacheNode = cacheNode.left;
                addNode2(newNode);
            }
        } else {
            if (cacheNode.right == null) {
                cacheNode.right = newNode;
            } else {
                cacheNode = cacheNode.right;
                addNode2(newNode);
            }
        }
    }


    private class Node {
        private Node left;
        private Node right;
        private Node parent;
        private T data;

        public Node(T data) {
            this.data = data;
        }

        public void addNode(Node newNode) {
            if (this.data.compareTo(newNode.data) <= 0) {
                if (this.left == null) {
                    this.left = newNode;
                } else {
                    this.left.addNode(newNode);
                }
            } else {
                if (this.right == null) {
                    this.right = newNode;
                } else {
                    this.right.addNode(newNode);
                }
            }
        }

        public void toList() {
            if (this.left != null) {
                this.left.toList();
            }
            list[foot++] = this.data;
            //System.out.println(this.data);
            if (this.right != null) {
                this.right.toList();
            }
        }

    }


}


class Persion implements Comparable<Persion> {
    private String name;
    private int age;

    public Persion(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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


    @Override
    public int compareTo(Persion o) {

        return o.age - this.age;
    }

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