Java实现二叉树

二叉树的链式存储结构包含节点元素及分别指向左右子树的引用。具体代码如下：

package binarytree;

import java.util.Scanner;

/**
 * 二叉树的节点
 * @author liyong
 *
 */
class BinaryTreeNode{
    String data;
    BinaryTreeNode left;
    BinaryTreeNode right;
}

public class BinaryTreeOperation {
    static final int MAXLEN = 20;
    static Scanner input = new Scanner(System.in);

    /**
     * 初始化二叉树的根
     * @return
     */
    public BinaryTreeNode initTree(){
        BinaryTreeNode node;
        if((node = new BinaryTreeNode())!= null){
            System.out.printf("请先输入一个根节点数据：");
            node.data = input.next();
            node.left = null;
            node.right = null;
            if(node!=null){
                return node;
            }
        }
        return null;
    }

    /**
     * 根据节点的值查找节点
     * @param node
     * @param data
     * @return
     */
    public BinaryTreeNode findNodeByData(BinaryTreeNode node,String data){

        BinaryTreeNode ptr;

        if(node == null){
            return null;
        }else{
            if(node.data.equals(data)){
                return node;
            }else{
                if((ptr = findNodeByData(node.left, data))!=null){
                    return ptr;
                }else if((ptr = findNodeByData(node.right, data))!= null){
                    return ptr;
                }else{
                    return null;
                }
            }
        }
    }

    /**
     * 向二叉树中添加节点，添加节点时需要知道该节点的父节点的值，根据
     * 父节点的值查找到该父节点，然后判断该父节点的左右子树是否为空
     * @param treeNode
     */
    public void addTreeNode(BinaryTreeNode treeNode){
        BinaryTreeNode pnode,parent;
        String data;
        int menusel;
        if((pnode = new BinaryTreeNode())!=null){
            System.out.printf("输入二叉树节点数据：\n");
            pnode.data = input.next();
            pnode.left = null;
            pnode.right = null;
            System.out.printf("输入父节点的数据：");
            data = input.next();
            parent = findNodeByData(treeNode, data);
            if(parent == null){
                System.out.println("未找到该父节点");
                pnode = null;
                return;
            }
            System.out.printf("1、添加该节点到左子树，2、添加该节点到右子树\n");
            do{
                menusel = input.nextInt();
                if(menusel == 1 || menusel == 2){
                    switch(menusel){
                        case 1:
                            if(parent.left!=null){
                                System.out.println("父亲节点的左子树不为空");
                            }else{
                                parent.left = pnode;
                            }
                            break;
                        case 2:
                            if(parent.right!=null){
                                System.out.println("父亲节点的右子树不为空");
                            }else{
                                parent.right = pnode;
                            }
                            break;
                        default:
                            System.out.println("无效参数");
                    }
                }
            }while(menusel==1&&menusel==2);
        }
    }

    /**
     * 返货某个节点的左子树
     * @param treeNode
     * @return
     */
    public BinaryTreeNode getLeftNode(BinaryTreeNode treeNode){
        if(treeNode != null){
            return treeNode.left;
        }else{
            return null;
        }
    }

    /**
     * 返回某个节点的右子树
     * @param treeNode
     * @return
     */
    public BinaryTreeNode getRightNode(BinaryTreeNode treeNode){
        if(treeNode != null){
            return treeNode.right;
        }else{
            return null;
        }
    }

    /**
     * 传入根节点判断该树是否为空
     * @param treeNode
     * @return
     */
    public boolean treeIsEmpty(BinaryTreeNode treeNode){
        if(treeNode == null){
            return true;
        }else{
            return false;
        }
    }

    /**
     * 传入二叉树的根节点，得到该二叉树的深度
     * @param treeNode
     * @return
     */
    public int treeDepth(BinaryTreeNode treeNode){
        int depleft,depright;
        if(treeNode == null){
            return 0;  //空树
        }else{
            depleft = treeDepth(treeNode.left);
            depright = treeDepth(treeNode.right);
            if(depleft>depright){
                return depleft+1;
            }else{
                return depright+1;
            }
        }
    }

    /**
     * 显示节点的数据
     * @param treeNode
     */
    public void treeNodeData(BinaryTreeNode treeNode){
        System.out.println(treeNode.data);
    }

    /**
     * 二叉树的先序遍历
     * @param treeNode
     */
    public void preOrder(BinaryTreeNode treeNode){
        if(treeNode != null){
            treeNodeData(treeNode);
            preOrder(treeNode.left);
            preOrder(treeNode.right);
        }
    }

    /**
     * 二叉树的中序遍历
     * @param treeNode
     */
    public void inOrder(BinaryTreeNode treeNode){
        if(treeNode != null){
            inOrder(treeNode.left);
            treeNodeData(treeNode);
            inOrder(treeNode.right);
        }
    }

    /**
     * 二叉树的后序遍历
     * @param treeNode
     */
    public void postOrder(BinaryTreeNode treeNode){
        if(treeNode != null){
            postOrder(treeNode.left);
            postOrder(treeNode.right);
            treeNodeData(treeNode);
        }
    }

    /**
     * 二叉树按层遍历
     * @param treeNode
     */
    public void levelTree(BinaryTreeNode treeNode){
        BinaryTreeNode p;
        BinaryTreeNode[] q = new BinaryTreeNode[MAXLEN];

        int head=0;
        int tail = 0;
        if(treeNode!=null){
            tail = (tail+1)%MAXLEN;
            q[tail] = treeNode;
        }

        while(head!=tail){
            head = (head+1)%MAXLEN;
            p = q[head];
            treeNodeData(p);
            if(p.left!=null){
                tail = (tail+1)%MAXLEN;
                q[tail] = p.left;
            }
            if(p.right!=null){
                tail = (tail+1)%MAXLEN;
                q[tail] = p.right;
            }
        }
    }

}