二叉树的遍历-由中序和后序遍历序列确定一颗二叉树

概述

中序遍历的结果和后序遍历的结果可以确定一颗二叉树

 

方法

后序序列可以知道根结点和子树的子节点；中序序列可以知道根结点（子树的子节点）的左子树有哪些元素，右子树有哪些元素

 

推演

中序遍历序列和后序遍历序列确定树

中序序列：cbedahgijf

后序序列：cedbhjigfa

 

案例

Given the postorder and inorder traversal sequences  给出后序和中序序列

you are supposed to output the level order traversal sequences of the corresponding binary tree 输出层序的序列

 

输入：

7（树的size）

2 3 1 5 7 6 4（后序）

1 2 3 4 5 6 7 （中序）

输出：

4 1 6 3 5 7 2

 

 

 

 

package com.yao;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

//二叉树的基本结点
@Data
@AllArgsConstructor
@NoArgsConstructor
public  class Node {
    Object data;
    Node leftChild;
    Node rightChild;

}

 

package com.yao;

/**
 * @author
 * @date 2020/11/26 14:29
 */
public interface Tree {
    public Node create(int postL, int postR, int inL, int inR);
    public int size();
    public boolean isEmpty();
    public int getHeight();
    public void preTraversal();
    public void middleTraversal();
    public void postTraversal();
    public void orderByQueue(); //借助队列实现层次遍历
    public void preTraByStack(); //借助栈实现非递归遍历二叉树,使用先序进行遍历
    void inOrderByStack();  //借助栈实现非递归遍历二叉树,使用中序进行遍历
    void postTraByStack();  //借助栈实现非递归遍历二叉树,使用后序进行遍历
}

 

package com.yao;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.ArrayList;
import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;

/**
 * 采用双链表法实现二叉树
 */
@Data
@AllArgsConstructor
@NoArgsConstructor

public class LinkedBinaryTree  implements Tree{
    //为此棵数，创建根节点
    private Node root;
    int pre[];
    int in[];
    int post[];


    @Override
    public Node create(int postL, int postR, int inL, int inR) {
        Node root=new Node();
        if (postL >postR){
            return null;
        }
        root.data = post[postR];
        int k;
        for (k = inL; k <=inR; k++) {
            if (in[k] == post[postR]) break;
        }
        int numLeft = k - inL;
        root.leftChild = create(postL, postL + numLeft - 1, inL, k - 1);
        root.rightChild = create(postL + numLeft, postR - 1, k + 1, inR);
        return root;
    }



    @Override
    public int size() {
        return this.size(root);
    }

    private int size(Node node) {
        if(node==null){
            return 0;
        }else{
            int le = size(node.leftChild);
            int ri = size(node.rightChild);
            return ri+le+1;
        }
    }

    @Override
    public boolean isEmpty() {
        return root == null;
    }

    @Override
    public int getHeight() {
        return this.getHeight(root);
    }

    private int getHeight(Node node) {
        if(node == null){
            return 0;
        }else{
            int ai = this.getHeight(node.leftChild);
            int bi = this.getHeight(node.rightChild);
            return ai>bi?ai+1:bi+1;
        }
    }

    @Override
    public void preTraversal() {
        //进一步封装完善方法
        //首先必须考虑代码健壮性
        if(root !=null){
            System.out.println("先序递归遍历：");
            pre(root);
            System.out.println();
        }else{
            System.out.println("此二叉树为空");
        }
    }

    private void pre(Node node) {
        if(node!=null){
            //输出二叉树根节点
            System.out.print(node.data+"  ");
            //继续相应地遍历左子树和右子树
            this.pre(node.leftChild);
            this.pre(node.rightChild);
        }
    }

    @Override
    public void middleTraversal() {
        if(root !=null){
            System.out.println("中序递归遍历：");
            middle(root);
            System.out.println();
        }else{
            System.out.println("此二叉树为空");
        }
    }

    private void middle(Node node) {
        if(node!=null){
            //输出二叉树根节点
            this.middle(node.leftChild);
            System.out.print(node.data+"  ");
            this.middle(node.rightChild);
        }
    }

    @Override
    public void postTraversal() {
        if(root !=null){
            System.out.println("后序递归遍历：");
            pos(root);
            System.out.println();
        }else{
            System.out.println("此二叉树为空");
        }
    }

    private void pos(Node node) {
        if(node!=null){
            //输出二叉树根节点
            this.pos(node.leftChild);
            this.pos(node.rightChild);
            System.out.print(node.data+"  ");
        }
    }

    @Override
    public void orderByQueue() {
        //新建一个队列，存放二叉树结点
        Queue qu = new LinkedList();
        Node node = root;
        qu.add(node);
        //遍历输出每一层，同时将下一层的结点加入到对列中,队列现有的个数，就是每层节点的个数
        while(qu.size()!=0){
            for(int i = 0;i<qu.size();i++)
            {
                Node po = (Node) qu.poll();
                System.out.print(po.data+"  ");
                if(po.leftChild != null)
                    qu.add(po.leftChild);
                if(po.rightChild != null)
                    qu.add(po.rightChild);
            }
        }
        System.out.println();
    }

    @Override
    public void preTraByStack() {
        System.out.println("先序栈遍历：");
        Deque<Node> de = new LinkedList<>();//新建栈

        Node node = root;
        de.push(node);
        while(node != null&&de.size()>0){
            node = de.pop();
            System.out.print(node.data+"  ");
            if(node.leftChild!=null && node.rightChild!=null){
                de.push(node.rightChild);
                de.push(node.leftChild);
            }else if(node.leftChild!=null &&node.rightChild == null){
                de.push(node.leftChild);
            }else if(node.leftChild ==null &&node.rightChild != null){
                de.push(node.rightChild);
            }
        }
        System.out.println();
    }

    public void postTree(){
        System.out.println("借助外部方法实现后序遍历：");
        Deque<Node> stack =new LinkedList<Node>();
        Node node = root;
        Node proot;//标记栈顶元素前一个被访问的元素
        int flag;//root的左孩子未被访问；
        if(node!=null){
            do{
                while(node!=null){//将root所有左孩子全部入栈
                    stack.push(root);
                    node=node.leftChild;
                }

                //执行到此处，栈顶元素没有左孩子或者左子树已经被访问过；
                proot=null;//标记栈顶元素前一个被访问的元素，或者此时为最左下边，该元素前一个被访问的元素肯定为空。
                flag=1;//root的左孩子已经被访问；或者root为null

                while(!stack.isEmpty() && flag==1){
                    node=stack.peek();       //取到栈顶元素，但是不出栈；
                    if(node.rightChild==proot){
                        node=stack.pop();
                        System.out.print(node.data+"  ");
                        proot=node;
                    }else{
                        node=node.rightChild;
                        flag=0;//root左边孩子未被访问；
                    }
                }
            }while(!stack.isEmpty());
        }
    }

    @Override
    public void postTraByStack() {
        System.out.println("后序非递归遍历，借助栈");
        //新建栈，先进后出,将根结点入栈,双端队列
        Deque<Node> stack = new LinkedList<>();
        //新建一个list，记录结点的状态是否已经被访问过
        ArrayList<Node> list = new ArrayList<>();
        Node node = root;
        int flag;
        //首先检查完树的左子树，再右子树，最后将根节点输出
        while(node != null  || stack.size()>0){
            //将最左子树添加完毕
            while(node != null){
                stack.push(node);
                node = node.leftChild;
            }
            //和中序遍历相似，为先输出左结点，但是做结点输出完毕之后，不能直接将根结点弹出，而是必须先将右结点弹出，
            //最后再将根结点弹出来，就会牵扯到一个根结点的访问状态的问题，是否已经被遍历过了
            //利用一个list集合记录已将被遍历过的根结点，防止产生死循环
            if(stack.size()> 0 ){
                Node peek = stack.peek();
                if(peek.rightChild!=null){
                    boolean con = list.contains(peek);
                    if(con ==true){
                        Node pop = stack.pop();
                        System.out.print(pop.data+"  ");
                    }else{
                        list.add(peek);
                        node = peek.rightChild;
                    }
                }else{
                    Node pop = stack.pop();
                    System.out.print(pop.data+"  ");
                }
            }
        }
    }

    @Override
    public void inOrderByStack() {
        System.out.println("中序栈遍历:");
        // 创建栈,和先序遍历类似，直接入栈直到没有最左左子树可以入栈
        Deque<Node> stack = new LinkedList<Node>();
        Node node = root;
        //添加暂时完毕，开始pop元素
        while(node!=null || stack.size()>0 ){
            while(node!=null){
                stack.push(node);
                node = node.leftChild;
            }
            //一边pop并且一边进行判断，右结点不会null的，右子树，继续按照添加方法，将最左结点全部添加进去
            if(stack.size()>0){
                Node pop = stack.pop();
                System.out.print(pop.data+"  ");
                if(pop.rightChild!=null){
                    node = pop.rightChild;
                }
            }
        }
        System.out.println();
    }


}

 

package com.yao;
import java.util.Scanner;

/**
 * @author
 * @date 2020/11/26 14:30
 */

public class TestTreeTraversal {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int n=scanner.nextInt();
        int post[]=new int[n];
        int in[]=new int[n];
        for (int i = 0; i <n ; i++) {
             post[i]=scanner.nextInt();
        }
        for (int i = 0; i <n ; i++) {
            in[i]=scanner.nextInt();
        }

        LinkedBinaryTree lb=new LinkedBinaryTree();
        lb.setPost(post);
        lb.setIn(in);
        Node node=lb.create(0,n-1,0,n-1);
        lb.setRoot(node);
        lb.orderByQueue();
        lb.middleTraversal();

    }
}