二叉树（数据结构）

public class BinaryTree <T>{
    private final int maxNodes = 100;

    class Node<T>{
        public Node<T> lChild;
        private T data;
        public Node<T> rChild;
        public Node(){
            data = null;
            lChild = null;
            rChild = null;
        }
        public Node(T x){
            data = x;
            lChild = null;
            rChild = null;
        }
    }

    private Node<T> root;
    public BinaryTree(){//建立一棵空二叉树
        this.root = new Node<T>();
    }
    public BinaryTree(T x){//创建一个以数据元素x为根节点的二叉树
        this.root = new Node<T>(x);
    }
    public boolean insertLeft(T x, Node<T> parent){//在当前的二叉树的parent节点中插入一个新的左孩子节点，若存在左子树，则将该左子树变成新的左孩子节点的左子树
        if(parent==null){
            return false;
        }
        Node<T> p = new Node<T>(x);//创建一个新节点
        if(parent.lChild==null){
            parent.lChild = p;//将新节点直接设置为父节点的左孩子节点
        }else {
            //将父节点原来的左子树设置为新节点的左子树
            p.lChild = parent.lChild;
            //再将新节点设置为父节点的左孩子节点
            parent.lChild = p;
        }
        return true;
    }
    public boolean insertRight(Node<T> parent){
        if(parent==null){
            return false;
        }
        Node<T> p = new Node<T>();
        if(parent.rChild==null){
            parent.rChild = p;
        }else {
            p.rChild = parent.rChild;
            parent.rChild = p;
        }
        return true;
    }
    public boolean deleteLeft(Node<T> parent){//删除当前二叉树的parent节点中的左子树
        if (parent == null){
            return false;
        }else {
            parent.lChild = null;
            return true;
        }
    }
    public boolean deleteRight(Node<T> parent){
        if (parent==null){
            return false;
        }else {
            parent.rChild = null;
            return true;
        }
    }
    public boolean search(T x){//查找数据x

    }
    public void preorder(Node<T> node){//前序遍历
        if(node==null) return;
        else {
            System.out.println(node.getDate);
            preorder(node.lChild);
            preorder(node.rChild);
        }
    }
    public void inorder(Node<T> node){//中序遍历
        if (node==null) return;
        else {
            inorder(node.lChild);
            System.out.println(node.getData);
            inorder(node.rChild);
        }
    }
    public void postorder(Node<T> node){
        if (node==null) return;
        else {
            postorder(node.lChild);
            postorder(node.rChild);
            System.out.println(node.getData);
        }
    }
    public void levelorder(){//逐层遍历二叉树
        
        Node<T>[] queue = new Node[this.maxNodes];//构造一个队列
        int front,rear;//队首队尾指针
        if (this.root==null) return;
        front = -1;//队列暂时为空，队首指针不指向任何一个元素
        rear = 0;//队尾指针指向第一个数组元素
        queue[rear] = this.root;//二叉树根节点入队
        while (front!=rear){
            front++;
            System.out.println(queue[front].getData());//访问队首节点的数据域
            //将队首节点的左孩子节点入队
            if (queue[front].lChild!=null){
                rear++;
                queue[rear] = queue[front].lChild;
            }
            //将队首节点的右孩子节点入队
            if (queue[front].rChild!=null){
                rear++;
                queue[front] = queue[front].rChild;
            }
        }
    }
    public void traversal(int i){//遍历二叉树所有节点
        switch (i){
            case 0:preorder(this.root);break;
            case 1:inorder(this.root);break;
            case 2:postorder(this.root);break;
            default:levelorder();
        }
    }
    public int getHeight(Node<T> parent){//求二叉树的深度
        int lh,rh,max;
        if (parent!=null){
            lh = getHeight(parent.lChild);
            rh = getHeight(parent.rChild);
            max = lh>rh?lh:rh;
            return max+1;
        }else return 0;
    }
}