【数据结构】树（二叉树）JAVA实现

数据结构—树（二叉树）

一、二叉树的数据结构

/**
 * 二叉树节点数据结构
 * @param <E>
 */
public class TNode<E> {
    private E data;
    private TNode<E> lChild;
    private TNode<E> rChild;

    public TNode() {
    }
    public TNode(E data) {
        this.data = data;
    }

    public TNode(E data, TNode<E> lChild, TNode<E> rChild) {
        this.data = data;
        this.lChild = lChild;
        this.rChild = rChild;
    }

    public E getData() {
        return data;
    }

    public void setData(E data) {
        this.data = data;
    }

    public TNode<E> getlChild() {
        return lChild;
    }

    public void setlChild(TNode<E> lChild) {
        this.lChild = lChild;
    }

    public TNode<E> getrChild() {
        return rChild;
    }

    public void setrChild(TNode<E> rChild) {
        this.rChild = rChild;
    }

    @Override
    public String toString() {
        return "TNode{" +
                "data=" + data +
                ", lChild=" + lChild +
                ", rChild=" + rChild +
                '}';
    }
}

二、二叉树算法实现（链式存储）

/**
 * 二叉树的链式存储
 * @param <E>
 */
public class BinaryTree<E> {

    //根节点
    public TNode<E> head;
    public List<TNode> nodeList = null;
    public BinaryTree(){
        head = null;
    }
    //构造函数,生成一棵以data为根结点数据域信息，以二叉树lp和rp为左子树和右子树的二叉树
    public BinaryTree(E val,TNode<E> lp, TNode<E> rp) {
        TNode<E> tNode  = new TNode<E>(val,lp,rp);
        head  = tNode;
    }
    // 构造函数，生成一棵空的二叉树
    public BinaryTree(E val){
        this(val,null,null);
    }

    //判断是否为空
    public Boolean isEmpty(){
        return head == null;
    }

    //获取根节点
    public TNode<E> Root(){
        return head;
    }

    //获取节点的左孩子节点
    public TNode<E> getLChild(TNode<E> tNode){
        return tNode.getlChild();
    }

    //获取节点的右孩子节点
    public TNode<E> getRChild(TNode<E> tNode){
        return tNode.getrChild();
    }

    //创建二叉树
    public void create(E val,TNode<E> l,TNode<E> r){
        TNode<E> tNode = new TNode<>(val,l,r);
        head = tNode;
    }
    // 将结点p的左子树插入值为val的新结点，
    // 原来的左子树成为新结点的左子树
    public void insertL(E val,TNode<E> l){
        TNode<E> tNode = new TNode<>(val);
        tNode.setlChild(l.getlChild());//TNode是参数
        l.setlChild(tNode);
    }

    // 将结点p的右子树插入值为val的新结点，
    // 原来的右子树成为新结点的右子树
    public void insertR(E val,TNode<E> r){
        TNode<E> tNode = new TNode<>(val);
        tNode.setrChild(r.getrChild());//TNode是参数
        r.setrChild(tNode);
    }

    // 若p非空，删除p的左子树
    public TNode<E> deleteL(TNode<E> p){
        if(p == null || p.getlChild() == null){
            return null;
        }
        TNode<E> tNode = new TNode<>();
        p.setlChild(null);
        return tNode;
    }

    // 若p非空，删除p的右子树
    public TNode<E> deleteR(TNode<E> p){
        if(p == null || p.getrChild() == null){
            return null;
        }
        TNode<E> tNode = new TNode<>();
        p.setrChild(null);
        return tNode;
    }

    // 在二叉树中查找值为value的结点
    public TNode<E> search(TNode<E> root, E val){
        TNode<E> p = root;
        if(p==null){
            return null;
        }
        if(p.getData().equals(val)){
            return p;
        }
        if(p.getlChild()!=null){
            return search(p.getlChild(),val);
        }
        if(p.getrChild()!=null){
            return search(p.getrChild(),val);
        }
        return null;
    }
    // 判断是否是叶子结点
    public Boolean isLeaf(TNode<E> p){
        return p!=null && p.getlChild() == null && p.getrChild() == null;
    }

    /**********************           递归实现       *******************/
    //先序遍历
    public void preorder(TNode<E> p) {
        if(p == null)
            return;
        System.out.print(p.getData()+" ");
        preorder(p.getlChild());
        preorder(p.getrChild());
    }
    //中序遍历
    public void inorder(TNode<E> p) {
        if(p == null)
            return;
        inorder(p.getlChild());
        System.out.print(p.getData()+" ");
        inorder(p.getrChild());
    }
    // 后序遍历
    public void postorder(TNode<E> p) {
        if(p == null)
            return;
        postorder(p.getlChild());
        postorder(p.getrChild());
        System.out.print(p.getData()+" ");
    }

    /**********************           非递归实现       *******************/
    /**
     *  ******  使用栈数据结构  栈的核心的在于先入后出，符合二叉树的遍历需求
     *          而入栈和出栈操作则是我们设计算法的核心。
     *          何时入栈？谁先入栈？这里的设计是左孩子节点先入栈
     *          何时出栈？出栈的条件是什么？
     *          是不是所有节点都需要入栈呢？
     *          想明白了这几点，二叉树的遍历实现就会更容易实现。
     * @param p
     */

    //先序遍历 栈思想，按层次入栈，右孩子节点先入栈
    public void preorder_2(TNode<E> p) {
        if(p == null)
            return;
        Stack<TNode<E>> stack = new Stack<>();
        stack.push(p);//入栈
        while(!stack.empty()){
            p = stack.pop();
            System.out.print(p.getData()+" ");
            if(p.getrChild()!=null) stack.push(p.getrChild());//先入右孩子节点
            if(p.getlChild()!=null) stack.push(p.getlChild());//左孩子节点入栈，栈的特性会使得左孩子节点先出栈
        }
    }

    //先序遍历
    public void preorder_3(TNode<E> p) {
        if(p == null)
            return;
        Stack<TNode<E>> stack = new Stack<>();
        while (!stack.isEmpty() || p!=null){
            //从p节点开始向下找到所有左孩子节点
            while (p!=null){
                System.out.print(p.getData()+" ");
                stack.push(p);
                p = p.getlChild();
            }
            //当左孩子为null时，就向上访问右孩子节点
            p = stack.pop();
            p = p.getrChild();
        }
    }

    //中序遍历 与先序遍历的preorder_3相似，只是输出位置不同
    public void inorder_2(TNode<E> p) {
        if(p == null)
            return;
        Stack<TNode<E>> stack = new Stack<>();
        while (!stack.isEmpty() || p!=null){
            //从p节点开始向下找到所有左孩子节点
            while (p!=null){
                stack.push(p);
                p = p.getlChild();
            }
            //当左孩子为null时，就向上访问右孩子节点
            p = stack.pop();
            System.out.print(p.getData()+" ");
            p = p.getrChild();
        }
    }

    // 后序遍历
    public void postorder_2(TNode<E> p) {
        if(p == null)
            return;
        Stack<TNode<E>> stack = new Stack<>();
        TNode<E> prep = p;
        while (!stack.isEmpty() || p!=null) {
            //从p节点开始向下找到所有左孩子节点
            while (p != null) {
                stack.push(p);
                p = p.getlChild();
            }
            p = stack.peek().getrChild();//获得栈顶节点的右孩子节点
            if( p==null || p == prep){ //说明此时的p，是可以被输出的。不存在右孩子节点或者该右孩子节点已经出栈
                p = stack.pop();//此时p可以出栈
                System.out.print(p.getData()+" ");
                prep = p;//该节点已被访问
                p = null;//不设置p为null，p会一直被push，陷入死循环
            }
        }
    }

    //后序遍历
    public void postorder_3(TNode<E> p) {
        if(p == null)
            return;
        Stack<TNode<E>> stack = new Stack<>();
        TNode<E> prep = p;
        while (!stack.isEmpty() || p!=null) {
            //从p节点开始向下找到所有左孩子节点
            while (p.getlChild()!= null) {
                stack.push(p);
                p = p.getlChild();
            }
            while(p!=null && (p.getrChild()==null||p.getrChild()==prep)){
                System.out.print(p.getData()+" ");
                prep = p;
                if(stack.empty()) return;
                p = stack.pop();
            }
            stack.push(p);
            p  = p.getrChild();
        }
    }

    //后序遍历 双栈法
    public void postorder_4(TNode<E> p) {
        if(p == null) return;
        Stack<TNode<E>> stack = new Stack<>();
        Stack<TNode<E>> result = new Stack<>();
        while (!stack.isEmpty() || p!=null) {
            while (p!= null) {
                stack.push(p);
                result.push(p);
                p = p.getrChild();
            }
            if(!stack.empty())
                p = stack.pop().getlChild();
        }
        while (!result.empty()){
            p = result.pop();
            System.out.print(p.getData()+" ");
        }
    }

    // 层次遍历 使用队列 简单易懂
    public void levelOrder(TNode<E> root) {
        if(root == null)
            return;
        Queue<TNode<E>> queue = new LinkedList<TNode<E>>();
        queue.add(root);
        while(!queue.isEmpty()){
            TNode<E> temp = queue.poll();
            System.out.print(temp.getData()+" ");
            if(temp.getlChild()!=null){
                queue.add(temp.getlChild());
            }
            if(temp.getrChild()!=null){
                queue.add(temp.getrChild());
            }
        }
    }
}

三、测试

public class Test {
    public static void main(String[] args) {
        BinaryTree<String> binaryTree = new BinaryTree<>("A");
        System.out.println("根节点"+binaryTree.head.getData());
        binaryTree.insertL("B",binaryTree.head);
        binaryTree.insertR("C",binaryTree.head);
        binaryTree.insertL("D",binaryTree.head.getlChild());
        binaryTree.insertL("E",binaryTree.head.getrChild());
        binaryTree.insertR("F",binaryTree.head.getrChild());


//        System.out.println("是否为空"+binaryTree.isEmpty());//是否为空false
//        System.out.println("获取根节点"+binaryTree.Root());
//        System.out.println("获取指定节点的左孩子节点"+binaryTree.head.getlChild());
//        System.out.println("获取指定节点的右孩子节点"+binaryTree.head.getlChild().getlChild().getrChild());
        /**
         * 先序遍历测试
         */
        //binaryTree.preorder(binaryTree.head);//A B D C E F
        //binaryTree.preorder_2(binaryTree.head);//A B D C E F
         binaryTree.preorder_3(binaryTree.head);//A B D C E F
        /**
         * 中序遍历测试
         */
        //binaryTree.inorder(binaryTree.head);//D B A E C F
       // binaryTree.inorder_2(binaryTree.head);//D B A E C F
        /**
         * 后序遍历测试
         */
        //binaryTree.postorder(binaryTree.head);//D B E F C A
        //binaryTree.postorder_2(binaryTree.head);//D B E F C A
       // binaryTree.postorder_3(binaryTree.head);//D B E F C A
      //  binaryTree.postorder_4(binaryTree.head);//D B E F C A

        /**
         * 层次遍历测试
         */
        // binaryTree.levelOrder(binaryTree.head);//A B C D E F
    }
}