数据结构二叉树类

二叉树类

• 二叉树结点类

//二叉树的二叉链表结点类，T指定结点的元素类型
public class BinaryNode<T> {
    public T data;  //数据域，存储数据元素
    public BinaryNode<T> left, right;   //地址域，分别指向左右孩子结点

    //构造结点
    public BinaryNode(T data, BinaryNode<T> left, BinaryNode<T> right){
        this.data=data;
        this.left=left;
        this.right=right;
    }
    //构造元素为data的叶子结点
    public BinaryNode(T data){
        this.data=data;
        this.left=null;
        this.right=null;
    }

    //返回结点数据域的描述字符串
    public String toString(){
        return data.toString();
    }
    //判断是否是叶子结点
    public boolean isLeaf(){
        if (this.left==null && this.right==null){
            return true;
        }
        else
            return false;
    }
}

• 二叉树类

public class BinaryTree<T> {
    public BinaryNode<T> root;      //根结点，二叉链表结点结构

    //构造空二叉树
    public BinaryTree() {
        this.root = null;
    }
    //由先序和中序遍历构造一颗二叉树,preIndex和inIndex分别表示开始遍历的位置，最开始两个值都为0，count值代表将要构造二叉树的节点数
    public BinaryTree(T[] preList, T[] inList, int preIndex, int inIndex, int count){
       //首先说明递归结束条件：count=0
        if (count>0){
            T rootVal=preList[preIndex];    //根据先序序列确定根结点值

            //根据在先序序列中确定的根节点值查找其在中序序列中的位置，进而可以确定该结点的左子树和右子树
            int i=0;
            for (; i<count; i++){
                if (rootVal==inList[i+inIndex]){
                    break;
                }
            }

            this.root=new BinaryNode<>(rootVal);
            this.root.left=new BinaryTree<>(preList, inList, preIndex+1, inIndex, i).root;
            this.root.right=new BinaryTree<>(preList, inList, preIndex+i+1, inIndex+i+1, count-i-1).root;
        }
    }
    //以标明空子树的先根次序遍历序列构造一颗二叉树
    public BinaryTree(T[] preList){
        this.root=create(preList);
    }
    //以从i开始的标明空子树的先根序列，创建一颗以preList[]为根的子树
    private int i=0;
    private BinaryNode<T> create(T[] preList){
        BinaryNode<T> p=null;
        if (i<preList.length){
            T elem=preList[i++];
            if (elem!=null){
                p=new BinaryNode<>(elem);
                p.left=create(preList);
                p.right=create(preList);
            }
        }
        return p;
    }

    //判断是否空二叉树
    public boolean isEmpty() {
        return this.root == null;
    }

    //插入x元素作为根结点, x!=null, 原根节点作为x的左孩子
    public void insert(T x) {
        if (x != null) {
            this.root = new BinaryNode<T>(x, this.root, null);
        }
    }

    //插入x元素作为p结点的左/右孩子，x!=null且p!=null，left指定左/右孩子，取值为true(左)，false(右)
    //p原左/右孩子成为x结点的左/右孩子；返回插入的x元素结点，若x==null或p==null，则不插入，返回null
    public BinaryNode<T> insert(BinaryNode<T> p, boolean left, T x) {
        if (x == null || p == null) {
            return null;
        }
        if (left) {
            return p.left = new BinaryNode<>(x, p.left, null);
        }
        return p.right = new BinaryNode<>(x, null, p.right);
    }

    //删除p结点的左/右子树，left指定左/右子树，取值为true（左），false（右）
    public void remove(BinaryNode<T> p, boolean left) {
        if (p != null) {
            if (left) {
                p.left = null;
            } else {
                p.right = null;
            }
        }
    }

    //删除二叉树的所有结点，删除根节点
    public void clear() {
        this.root = null;
    }

    //先根次序遍历二叉树算法
    public void preOrder() {
        preOrder(this.root);
        System.out.println();
    }
    public void preOrder(BinaryNode<T> p){
        if (p!=null){
            System.out.print(p.data.toString() + " ");    //先访问结点元素
            preOrder(p.left);       //访问左子树
            preOrder(p.right);      //访问右子树
        }
    }

    //中根次序遍历二叉树
    public void inOrder(){
        inOrder(this.root);
        System.out.println();
    }
    public void inOrder(BinaryNode<T> p){
        if (p!=null){
            inOrder(p.left);
            System.out.print(p.data.toString() + " ");
            inOrder(p.right);
        }
    }

    //后跟次序遍历二叉树
    public void postOrder(){
        preOrder(this.root);
        System.out.println();
    }
    public void postOrder(BinaryNode<T> p){
        if (p!=null){
            preOrder(p.left);
            preOrder(p.right);
            System.out.print(p.data.toString() + " ");
        }
    }

    //返回二叉树的广义表表示字符串
    public String toGenListString(){
        return "二叉树的广义表表示: " + toGenListString(this.root);
    }
    //返回以p结点为根的一颗子树的广义表表示字符串，先根次序遍历，递归算法
    public String toGenListString(BinaryNode<T> p){
        if (p==null){
            return "^";     //返回空子树标记
        }
        if (p.left==null && p.right==null){
            return p.data.toString();       //p是叶子结点
        }
        return p.data.toString() + "(" +toGenListString(p.left) + "," + toGenListString(p.right) + ")";
    }

    //先根次序遍历二叉树非递归算法
    public void preOrderTraverse(){
        Stack<BinaryNode<T>> stack=new LinkedStack<>();
        BinaryNode<T> p=this.root;
        while(p!=null || !stack.isEmpty()){
            if (p!=null){
                System.out.print(p.data + " ");
                stack.push(p);
                p=p.left;
            }
            else {
                System.out.print("^ ");
                p=stack.pop();
                p=p.right;
            }
        }
        System.out.println("^");
    }
    //中根次序遍历二叉树的非递归算法
    public void inOrderTraverse(){
        Stack<BinaryNode<T>> stack=new LinkedStack<>();
        BinaryNode<T> p=this.root;
        while(p!=null || !stack.isEmpty()){
            if (p!=null){
                stack.push(p);
                p=p.left;
            }
            else {
                System.out.print("^ ");
                p=stack.pop();
                System.out.print(p.data + " ");
                p=p.right;
            }
        }
        System.out.println("^");
    }
    //后根次序遍历二叉树的非递归算法
    public void postOrderTraverse(){
        Stack<BinaryNode<T>> stack=new LinkedStack<>();
        BinaryNode<T> last=null;        //指向上次访问的结点
        BinaryNode<T> p=this.root;      //将要遍历的树的根结点
        while (p!=null || !stack.isEmpty()){
            while (p!=null){
                stack.push(p);
                p=p.left;
            }
            if (!stack.isEmpty()){
                BinaryNode<T> t=stack.pop();
                if (t.right==null || last==t.right){        //if循环后没有对结点p进行任何处理，因为此时结点p一定为null，会再次弹出t的父节点进行处理
                    System.out.print(t.data + " ");
                    last=t;
                }
                else {
                    stack.push(t);
                    p=t.right;      //改变结点p的值
                }
            }
        }
    }
    //后根次序遍历二叉树的非递归算法
    public void postOrderTraverse2(){
        Stack<BinaryNode<T>> stack=new LinkedStack<>();
        BinaryNode<T> last=null;        //指向上次访问的结点
        BinaryNode<T> p=this.root;      //将要遍历的树的根结点

        while(p!=null || !stack.isEmpty()){
            if (p!=null){
                stack.push(p);
                p=p.left;
            }
            else {
                BinaryNode<T> t=stack.pop();
                if (t.right==null){
                    System.out.print(t.data + " ");
                    last=t;
                }
                else if (last==t.right){
                    System.out.print(t.data + " ");
                    last=t;
                }
                else {
                    stack.push(t);
                    p=t.right;
                }
            }
        }
    }


    //二叉树的层序遍历
    public void levelOrder(){
        if (this.root==null){
            return;
        }
        //创建空队列，其中队列的元素类型是二叉树结点BinaryNode<T>
        Queue<BinaryNode<T>> que=new LinkedQueue<>();       //链式队列
        que.add(this.root);
        while(!que.isEmpty()){
            BinaryNode<T> p=que.poll();
            System.out.print(p.data + " ");
            if (p.left!=null){
                que.add(p.left);
            }
            if (p.right!=null){
                que.add(p.right);
            }
        }
        System.out.println();
    }

    public static void main(String[] args) {
        String[] preList={"A","B","D",null,"G",null,null,null,"C","E",null,null,"F","H"};
        BinaryTree<String> binaryTree=new BinaryTree<>(preList);
        binaryTree.preOrderTraverse();
        binaryTree.postOrderTraverse2();
    }
}

• 广义表表示二叉树类

//二叉树操作类，生命特定对二叉树操作的静态方法
public class BinaryTrees {
    private static int i=0;

    //返回以广义表表示字符串genList构造的二叉树
    public static BinaryTree<String> createByGenList(String genList){
        BinaryTree<String> binaryTree=new BinaryTree<>();
        i=0;
        binaryTree.root=create(genList);
        return binaryTree;
    }

    //以从i开始的广义表表示字符串创建一颗以genList[i]为根的子树，返回子树根节点
    //递归算法先创建根结点，再创建左子树，右子树
    public static BinaryNode<String> create(String genList){
        BinaryNode<String> p=null;
        if (i<genList.length()){
            char ch=genList.charAt(i);
            i++;
            if (ch=='^'){
                return null;
            }
            p=new BinaryNode<>(ch + "");
            if (i<genList.length() && genList.charAt(i)=='('){
                p.left=create(genList);
                i++;
                p.right=create(genList);
                i++;
            }
        }
        return p;
    }
}