二叉树的前中后序遍历

前序遍历

要求二叉树的输出结果为  中 左 右 按照这一个逻辑

递归实现

 

 public static void  pre_Print(Node head){
        
        if(head==null)
            return;
        System.out.println(head);
        pre_Print(head.left);
        pre_Print(head.right);
    }

 

   递归实现有一个特点，就是每一判断个节点函数都走了三次，第一次是正常执行到该节点，第二次是左节点的返回又回到该节点，第三次是右节点的返回回到该节点，即使是子节点，也是如此，因为他也进行了其子节点的判断，只不过判断为空直接返回了。

非递归版本的实现：

 public static void  bef_Out(Node head){
         //基本原理是进行压栈
         //压右压左。 左弹
        Stack<Node>  sta =new Stack<>();
        if(head!=null) {
            sta.add(head);
            while (!sta.empty()) {
                Node temp = sta.pop();
                System.out.println(temp);
                if (temp.right != null)
                    sta.push(temp.right);
                if (temp.left != null)
                    sta.push(temp.left);
            }
        }


    }

利用栈结构，先把右压入，再压入左这样取结果时候就实现了先输出左 再输出右。

 

中序遍历

      中 序遍历， 要求输出的顺序是 左—中---右

   递归实现

public static void mid_Print(TreeNodes head){
        if(head==null) return;
        mid_Print(head.left);
        System.out.println(head);
        mid_Print(head.right);

    }

 逻辑与前序遍历的逻辑基本是一样的 只是将输出的位置换到了中间

非递归的实现

public static void  mid_Out(Node head){
        //只要有左孩子 就一直压
         Stack<Node>  sta =new Stack<>();
         //中序遍历 能左则左
        while(head!=null||!sta.empty()){
            if(head!=null){
                sta.push(head);
                head=head.left;
            }else{
               head =sta.pop();
                System.out.println(head);
                head =head.right;
            }
        }


}

       非递归的实现也与前序类似， 因为他要求是能先左则先左，代码逻辑略有不同。最开始添加了一个head！=Null判断是因为中序没有在循环之前将顶端压入，所以利用此判断将其作为程序的第一次入口。然后判断head是否为空，不为空的话直接将其压入，然后将Head变为他的左节点，直到左节点为空了，从栈取出值判断他的右节点。

 

后序遍历 

 

 

递归实现

    public static void  aft_Print(Node head){
          if(head==null) return ;
          aft_Print(head.left);
          aft_Print(head.right);
            System.out.println(head);
    }

 

非递归版本

    public static void aft_Out(Node head){
        Stack<Node>  sta =new Stack<>();
        Stack<Node>  ss =new Stack<>();
        if(head!=null) {
            sta.add(head);
            while (!sta.empty()) {
                Node temp = sta.pop();
                ss.push(temp);
                if (temp.left != null)
                    sta.push(temp.left);
                if (temp.right != null)
                    sta.push(temp.right);

            }
            Iterator<Node> iter= ss.iterator();
            while(iter.hasNext()){
                System.out.println(iter.next());
            }

        }

    }

 

  后序遍历的输出样式为 左 ----右----中  与  前序遍历的 中 ----左----右很类似，前序是因为先插右再插入左 最后的输出位 中左右，那么进行先插入左 再插入右 输出位 中右左，然后根据栈可以将数据逆序，然后将数据存入栈然后再输出就得到了 左右中。

 

层级遍历

  递归实现

public static void level_Pri(Node head,int level){
          if(head==null){
              return;
          }
          if(level==1){
              System.out.println(head);
              return ;
          }
          level_Pri(head.left,level-1);
          level_Pri(head.right,level-1);

    }
    public static void level_Pri(Node head){
        int level =3;
        for(int i=1;i<=level;i++){
            level_Pri(head,i);
        }
    }

 

       层级遍历的递归实现相对较为复杂，因为使用递归的话，二叉树往往会直接由一个头结点直接深入到根节点，要做到一层一层遍历，且是从头结点为层起点的向下输出，就要设置一个判断条件来保证。其中level表示二叉树的深度，这样可以通过层级进行二叉树的输出，第一次 让level为1 递归直接判断输出头结束，第二次为level为2 递归判断为1不成立，向下找到左右节点判断，这样就输出了第二层的数据，依次类推。这样就需要我们在外部有一个依次将level传入的函数，下边的重载函数就是算出深度然后利用for循环依次进行输出

非递归实现

  public  static void level_Out(Node head){
        Queue<Node> queue =new LinkedList<>();
        queue.add(head);
        while(!queue.isEmpty()){
            head =queue.poll();
            System.out.println(head);
            if(head.left!=null){
                queue.add(head.left);
            }
            if(head.right!=null){
                queue.add(head.right);
            }

        }

    }

利用栈的先进先出原则  插入左右，然后弹出再插入左右依次输出。

相对来说，中序遍历的非递归实现要比递归实现容易分析，容易想到。