【二叉树】【Java】递归与非递归，各种遍历二叉树

先序、中序、后序、层次及递归与非递归遍历二叉树的Java实现【代码】

一、递归实现

（1）先序遍历 – “根左右”

//将二叉树先序遍历，用于测试结果 “根左右”
public static void preTraverseBinTree(TreeNode node){
    if (node==null) {
        return;
    }
    System.out.print(node.val+" ");
    if (node.left!=null) {
        preTraverseBinTree(node.left);
    }
    if(node.right!=null){
        preTraverseBinTree(node.right);
    }
}

（二）中序遍历 – “左根右”

//将二叉树中序遍历，用于测试结果 “左根右”
    public static void inTraverseBinTree(TreeNode node){
        if (node==null) {
            return;
        }
        if (node.left!=null) {
            inTraverseBinTree(node.left);
        }
        System.out.print(node.val+",");
        if(node.right!=null){
            inTraverseBinTree(node.right);
        }
    }

（三）后序遍历 – “左右根”

//将二叉树后序遍历，用于测试结果 “左右根”
public static void postTraverseBinTree(TreeNode node){
    if (node==null) {
        return;
    }
    if (node.left!=null) {
        postTraverseBinTree(node.left);
    }
    if(node.right!=null){
        postTraverseBinTree(node.right);
    }
    System.out.print(node.val+" ");
}

（四）层次遍历

//将二叉树层次遍历
public static void levelTraverseBinTree(TreeNode node){
    if (node==null) {
        return;
    }
    int depth = depthTree(node);
    System.out.print(depth+" ");
    for (int i=0;i<=depth;i++)
        levelTraverseBinTree(node,i);
}
private static void levelTraverseBinTree(TreeNode node,int level){
    if(node == null || level < 1)
        return;
    if (level == 1){
        System.out.print(node.val + " ");
        return;
    }
    //左子树
    levelTraverseBinTree(node.left,level-1);
    //右子树
    levelTraverseBinTree(node.right,level-1);
}

//计算二叉树的深度
private static int depthTree(TreeNode node){ 
    if (node == null)
        return 0;
    int l = depthTree(node.left);
    int r = depthTree(node.right);
    if (l>r)
        return l+1;
    else
        return r+1;
}

二、非递归方法

前、中、后借助栈实现；层次遍历利用队列实现
（一）先序遍历

public static void preOrder(TreeNode node){
    Stack<TreeNode> stack = new Stack<>();
    while (node != null || !stack.empty()){
        while (node !=null){
            System.out.print(node.val+" "); //简单方式在入栈的同时访问节点
            stack.push(node);
            node = node.left;
        }
        if (!stack.empty()){
            node = stack.pop();
            node = node.right;
        }
    }
}

（二）中序遍历

public static void inOrder(TreeNode node){
    Stack<TreeNode> stack = new Stack<>();
    while (node != null || !stack.empty()){
        while (node !=null){
            stack.push(node);
            node = node.left;
        }
        if (!stack.empty()){
            node = stack.pop();
            System.out.print(node.val+" ");
            node = node.right; //当node是叶子结点时，node==null（所有该结点没有右节点时会为空，然后继续等待弹出下一个结点再又判断其右节点）
        }
    }
}

（三）后序遍历
前序+后序：后序遍历的输出顺序是左、右、根，当我们采用先序遍历的方法，但是先遍历右子树，实现的效果是根、右、左，刚好和后序遍历的结果相反，所以我们通过将顺序反序，即可达到我们想要的效果

public static void postOrder(TreeNode node){
    Stack<TreeNode> stack = new Stack<>();
    while (node != null || !stack.empty()){
        while (node !=null){
            stack.push(node);
            System.out.print(node.val+" ");//根
            node = node.right;//右
        }
        if (!stack.empty()){
            node = stack.pop();
            node = node.left;//左
        }
    }
}

（四）层次遍历

public static void levelOrder(TreeNode node){
    if (node==null) {
        return;
    }
    Queue<TreeNode> queue = new LinkedList<TreeNode>();//java中队列（Queue）的用法：LinkedList类实现了Queue接口，因此我们可以把LinkedList当成Queue来用
    queue.offer(node);
    while (!queue.isEmpty()){
        TreeNode temp = queue.poll();//不推荐用add()和remove()
        System.out.print(temp.val+" ");
        if(temp.left != null)
            queue.offer(temp.left);
        if (temp.right != null)
            queue.offer(temp.right);
    }
}

PS.【代码】