二叉树的前序、中序、后序遍历，通过递归和非递归的方式实现【Java】

概述

　　二叉树的遍历，一个老生常谈的问题，大学的时候就天天学习，但是那时候大多是了解每中遍历的方式，但是并没有用代码实现，工作之后，使用代码实现一下。

三种遍历方式的区别

　　具体的介绍我这里就不说了，只总结性的说一下，所谓的前序，中序，后序，的前中后，其实就是根节点被访问的前中后，前序遍历就是根节点在最开始，中序遍历就是根节点在中间，后序遍历就是根节点在最后，当然这个根节点并不一定是二叉树的唯一根节点，而是每个节点只要有子节点，那这个节点其实都可以看作子节点的根节点。

下面就上代码

通过java自己实现二叉树

先定义节点

package com.example.demo.tree;

/**
 * @author steve
 * @date 2020/4/18 3:16 下午
 */
public class Node<E> {
    public Node<E> left;
    public Node<E> right;
    public Node<E> parent;
    public E element;
    public Node(E element){
        this.element = element;
    }
}

定义二叉树

package com.example.demo.tree;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;
import org.omg.PortableInterceptor.INACTIVE;

import java.util.Comparator;

/**
 * @author steve
 * @date 2020/4/16 10:03 上午
 */
public class BinaryTree<E> {

    private int size;
    public Node<E> root;
    private Comparator<E> comparator;

    public BinaryTree(Comparator<E> comparator){
        this.comparator = comparator;
    }

    public BinaryTree(){
        this(null);
    }

    public void add(E element){
        if (root == null){
            Node node = new Node(element);
            root = node;
        }else {
            Node<E> parent = root;
            Node<E> node = root;
            int com = 0;
            while (node != null){
                parent = node;
                if (comparator == null){
                    com = ((Comparable)node.element).compareTo(element);
                }else {
                    System.out.println("-------------");
                    com = comparator.compare(node.element,element);
                }
                if (com > 0){
                    node = node.left;
                }else if (com < 0){
                    node = node.right;
                }else {
                    node.element = element;
                    return;
                }
            }
            Node<E> newNode = new Node(element);
            if (com > 0){
                parent.left = newNode;
                newNode.parent = parent.left;
            }else{
                parent.right = newNode;
                newNode.parent = parent.right;
            }
        }
        size ++;
    }
    public boolean isEmpty(){
        return size == 0;
    }
    public int size(){
        return size;
    }

    public String toString() {
        String d = root == null ? null : root.element + "";
        if (root == null){
            return "root:"+d;
        }else {
            String b = root.left == null ? null : root.left.element + "";
            String c = root.right == null ? null : root.right.element + "";
            return "root:"+d + ", left:" + b + ", right:"+ c;
        }

    }


    public static void main(String[] args) {
        //这种方式就是匿名内部类，通过给一个类传一个接口作为参数，然后这个通过一个匿名内部类是实现这个接口来传入实现。
        BinaryTree<Integer> binaryTree = new BinaryTree<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });

        BinaryTree<Integer> binaryTree1 = new BinaryTree<>();
        binaryTree1.add(1);
        binaryTree1.add(2);
        binaryTree1.add(0);
        System.out.println(binaryTree1.size());
        System.out.println(binaryTree.toString());
    }
}

遍历二叉树

package com.example.demo.tree;

import sun.tools.native2ascii.resources.MsgNative2ascii;

import java.util.*;

/**
 * @author steve
 * @date 2020/4/18 2:58 下午
 * 遍历二叉树，分别使用递归和迭代进行前序中序后序遍历一颗二叉树
 */
public class TraversBinaryTree {

    /**
     * 前序遍历
     * 从根节点开始，先遍历左子树，后遍历右子树
     */
    public static void preOrderTraveral(Node<Integer> node){
        if (node == null) return;
        System.out.println(node.element);
        preOrderTraveral(node.left);
        preOrderTraveral(node.right);
    }

    /**
     * 前序遍历，不使用递归实现
     * 解释：前序遍历是最简单的，因为这个是从头开始的，不用像中序遍历和后序遍历一样，都是从最低级的左孩子开始，所以这个，只需要一直入栈右孩子，
     * 左孩子，就可以了，其实这个过程一遍下来之后，所有的左孩子都出栈了，剩下的就是右孩子，那再慢慢出栈就可以了。
     * @param node
     */
    public static void preOrderTraveralUseStack(Node<Integer> node){
        Stack<Node<Integer>> stack = new Stack<>();
        stack.push(node);
        while (!stack.isEmpty()){
            Node<Integer> node1 = stack.pop();
            System.out.println(node1.element);
            if (node1.right != null){
                stack.push(node1.right);
            }
            if (node1.left != null){
                stack.push(node1.left);
            }
        }
    }

    /**
     * 中序遍历二叉树
     * 根节点在中间，从最左边的节点开始，先左后中，后右，遍历
     */
    public static void inOrderTraveral(Node<Integer> node){
        if (node == null) return;
        inOrderTraveral(node.left);
        System.out.println(node.element);
        inOrderTraveral(node.right);

    }

    /**
     * 中序遍历，不使用递归实现
     * 解释：这个其实比后序遍历简单，因为，这个先压入中，之后压入左，在出栈的时候，可以直接按照这个顺序反着出栈，然后在这个过程中
     * 只需要判断有没有右孩子，而不用担心右孩子重复入栈的问题，但是后序遍历就需要考虑这个问题
     * @param node
     */
    public static void inOrderTraveralUseStack(Node<Integer> node){
        if (node == null) return;
        Stack<Node<Integer>> stack = new Stack<>();
        stack.push(node);
        while (!stack.isEmpty()){
            if (node != null && node.left != null){
                stack.push(node.left);
                node = node.left;
            }else {
                //已经弹出来的节点，其左孩子不能再入栈
                node = stack.pop();
                System.out.println(node.element);
                if (node.right != null){
                    stack.push(node.right);
                    node = node.right;
                }else {
                    node = null;
                }
            }
        }

    }

    /**
     * 后序遍历
     * 根节点最后遍历，先左后右，之后中间的
     */
    public static void postOrderTraveral(Node<Integer> node){
        if (node == null) return;;

        postOrderTraveral(node.left);
        postOrderTraveral(node.right);
        System.out.println(node.element);
    }

    /**
     * 后序遍历，不使用递归，使用栈的方式实现
     * 1.先把左孩子压入栈，如果没有左孩子了，弹出左孩子
     * 2.然后把右孩子压入栈，如果没有了，就弹出
     * 注意：
     * 1.这里要注意两个点，第一个点就是如果一个节点的左孩子和右孩子都已经判断完了，那么就把这个节点置为null
     * 2.如果一个节点的右孩子已经处理过了，就不要重复入栈
     * 总结：
     * 1.不能重复入栈，无论是左孩子还是右孩子
     * @param node
     */
    public static void postOrderTraveralUseStack(Node<Integer> node){
        if (node == null) return;
        Stack<Node<Integer>> stack = new Stack<>();
        stack.add(node);
        Node<Integer> node2 = null;
        while (!stack.isEmpty()){
            if (node != null && node.left != null){
                stack.push(node.left);
                node = node.left;
            }else {
                node = stack.peek();
                if (node.right != null && node.right != node2){
                    stack.push(node.right);
                    //这里为了防止右孩子重复入栈
                    node2 = node.right;
                    node = node.right;
                }else {
                    stack.pop();
                    System.out.println(node.element);
                    //这里为了防止右孩子重复入栈
                    node2 = node;
                    //这里为了防止左孩子重复入栈
                    node = null;
                }
            }
        }
    }

    /**
     * 层序遍历二叉树
     * 使用队列实现，而不是栈
     */
    public static void levelOrderTraveral(Node<Integer> node){
        Queue<Node<Integer>> queue = new LinkedList<>();
        queue.add(node);
        while(!queue.isEmpty()){
            Node<Integer> node1 = queue.peek();
            queue.poll();
            System.out.println(node1.element);
            if (node1.left != null){
                queue.add(node1.left);
            }
            if (node1.right != null){
                queue.add(node1.right);
            }
        }
    }

    public static void main(String[] args) {
        BinaryTree<Integer> binaryTree = new BinaryTree<>();
        binaryTree.add(7);
        binaryTree.add(4);
        binaryTree.add(10);
        binaryTree.add(9);
        binaryTree.add(11);
        binaryTree.add(5);
        binaryTree.add(3);
        System.out.println("------------preorder traveral use recursion---------");
        TraversBinaryTree.preOrderTraveral(binaryTree.root);
        System.out.println("------------preorder traveral use stack");
        TraversBinaryTree.preOrderTraveralUseStack(binaryTree.root);
        System.out.println("-------------inorder traveral use recursion-------------------");
        TraversBinaryTree.inOrderTraveral(binaryTree.root);
        System.out.println("-------------inorder traveral use stack----------------");
        TraversBinaryTree.inOrderTraveralUseStack(binaryTree.root);
        System.out.println("--------------postorder traveral use recursion------------------");
        TraversBinaryTree.postOrderTraveral(binaryTree.root);
        System.out.println("--------------postorder traveral use stack-----------");
        TraversBinaryTree.postOrderTraveralUseStack(binaryTree.root);
        System.out.println("--------------------------------");
        TraversBinaryTree.levelOrderTraveral(binaryTree.root);
    }

}

总结

　　不知道是年龄大了，还是智商本身太低，通过非递归的方式实现二叉树的遍历，想了好久都没有思路，只有前序遍历是自己独立实现的，后面的中序和后序都是参考网上的代码，不过也许这个也是一个熟能生巧的事。