二叉树的遍历

定义二叉树节点

class TreeNode{
    int val;
    TreeNode left;
    TreeNode right;
    public TreeNode(int val){
        this.val = val;
    }
}

1. 前序遍历

递归

非常简单，代码如下：

public void preTraversal(TreeNode root){
    if(root == null)return;

    System.out.println(root.val);
    if(root.left != null)preTraversal(root.left);
    if(root.right != null)preTraversal(root.right);
}

非递归

借助栈实现

public void preTraversal(TreeNode root){
    if(root == null)return;

    LinkedList<TreeNode> stack = new LinkedList<TreeNode>();
    stack.addFirst(root);
    while(stack.size() > 0){
        TreeNode node = stack.removeFirst();
        System.out.println(node.val);
        if(node.right != null)stack.addFirst(node.right);
        if(node.left != null)stack.addFirst(node.left);
    }
}

或

public void preTraversal(TreeNode root){
    if(root == null)return;

    LinkedList<TreeNode> stack = new LinkedList<TreeNode>();
    TreeNode cur = root;
    while(cur!=null || stack.size() > 0){
        while(cur != null){
            System.out.println(cur.val);
            stack.addFirst(cur);
            cur = cur.left;
        }
        cur = stack.removeFrist();
        cur = cur.right;
    }
}

2. 中序遍历

递归

非常简单，代码如下：

public void inTraversal(TreeNode root){
    if(root == null)return;

    if(root.left != null)preTraversal(root.left);
    System.out.println(root.val);
    if(root.right != null)preTraversal(root.right);
}

非递归

借助栈实现

public void inTraversal(TreeNode root){
    if(root == null)return;

    LinkedList<TreeNode> stack = new LinkedList<TreeNode>();
    TreeNode cur = root;
    while(cur!=null && stack.size()>0){
        while(cur != null){
            stack.addFirst(cur);
            cur = cur.left;
        }
        cur = stack.removeFirst();
        System.out.println(cur.val);
        cur = cur.right;
    }
}

3. 后序遍历

递归

非常简单，代码如下：

public void postTraversal(TreeNode root){
    if(root == null)return;

    if(root.left != null)preTraversal(root.left);
    if(root.right != null)preTraversal(root.right);
    System.out.println(root.val);
}

非递归

借助栈实现，比较麻烦，需要记录上次遍历过的节点

public void postTraversal(TreeNode root){
    if(root == null)return;

    LinkedList<TreeNode> stack = new LinkedList<TreeNode>();
    TreeNode cur = root;
    TreeNode pre = null;
    while(cur!=null && stack.size()>0){
        while(cur != null){
            stack.addFirst(cur);
            cur = cur.left;
        }
        cur = stack.getFirst();
        if(pre==null || pre==cur.right){
            System.out.println(cur.val);
            stack.removeFirst();
            pre = cur;
            cur = null;
        }else{
            cur = cur.right;
        }
    }
}

4. 层次遍历

借助队列实现，非常简单

public void levelTraversal(TreeNode root){
    if(root == null)return;

    Queue<TreeNode> queue = LinkedList<TreeNode>();
    queue.offer(root);
    while(queue.size() > 0){
        TreeNode node = queue.poll();

        System.out.println(node.val);

        if(node.left != null)queue.offer(node.left);
        if(node.right != null)queue.offer(node.right);
    }
}