Java之二叉树结构

结构理解：

将第一个节点作为根节点，通过某一条件，大于的放在右子树，小于的放在左子树。此时进行查询的话时间复杂度就是O(logn)，因为在查询的时候不会进行整个结构的查询。

二叉树中有三种遍历方式：前序遍历、中序遍历、后序遍历。

 

 二叉树的基础实现：

实现二叉树的关键在于数据的保存，并且会涉及到数据的比较，那么就需要比较器的支持，而首选的比较器就是Comparable接口 。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        BinaryTree<Person> tree = new BinaryTree<>();
        tree.add(new Person("张三",90));
        tree.add(new Person("李四",40));
        tree.add(new Person("王五",30));
        tree.add(new Person("牛二",60));
        tree.add(new Person("大黄",100));
        System.out.println(Arrays.toString(tree.toArray()));
    }
}

 

class BinaryTree<T extends Comparable<T>> {
    /**
     * 实现二叉树的操作
     */
    private class Node {
        private Comparable<T> data; // 存放Comparable，可以比较大小
        private Node paerent;   // 父节点
        private Node left;  // 保存左子树
        private Node right; // 保存右子树

        public Node(Comparable<T> data) {    // 构造方法直接进行数据的存储
            this.data = data;
        }

        public void addNode(Node newNode) {  // 实现节点数据的适当位置存储
            if (newNode.data.compareTo((T) this.data) <= 0) { // 比当前节点数据小
                if (this.left == null) { // 左子树为空
                    this.left = newNode;    // 保存左子树
                    newNode.paerent = this; // 保存父节点
                } else { // 左子树不为空，则继续判断
                    this.left.addNode(newNode); // 向下进行递归判断
                }
            } else { // 比当前节点数据大
                if (this.right == null) {    // 右子树为空
                    this.right = newNode;   // 保存右子树
                    newNode.paerent = this; // 保存右子树
                } else { // 右子树不为空，则继续判断
                    this.right.addNode(newNode);    // 向下进行递归判断
                }
            }
        }

        // 实现数据的获取处理，按照中序遍历来进行
        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 Object[] returnData;    // 以数组的形式返回数据
    private int foot;   // 脚标

    // 进行数据的保存
    public void add(Comparable<T> data) {
        if (data == null) {
            throw new NullPointerException("保存数据为空");
        }
        // 所有数据本身不具备节点关系的匹配，那么一定要将其包装在Node类中
        Node newNode = new Node(data);
        if (this.root == null) { // 没有根节点则第一个节点作为根节点
            this.root = newNode;
        } else {  // 根节点存在，需要根据判断得出保存的位置进行保存
            this.root.addNode(newNode); // 交给Node类进行处理
        }
        this.count++; // 个数加一
    }

    // 以对象数组的形式进行数据的返回，如果没有数据则返回空
    public Object[] toArray() {
        if (this.count == 0) {   // 没有数据返回空
            return null;
        }
        this.returnData = new Object[this.count];   // 保存长度为数组长度
        this.foot = 0;  // 脚标清零
        this.root.toArrayNode();    // 直接通过Node类
        return this.returnData; // 返回数据
    }
}

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

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

    @Override
    public int compareTo(Person person) {
        return this.age - person.age;
    }

    @Override
    public String toString() {
        return "name: " + this.name + " age: " + this.age;
    }
}