二叉树的遍历——Java

中序遍历

非递归

public List<Integer> inorderTraversal(TreeNode root) {
    
    
        if(root == null)
            return new ArrayList<>();
        List<Integer> list= new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode current = root;
        while(!stack.isEmpty()||current!=null){
    
    
            while(current!=null){
    
    
                stack.push(current);
                current = current.left;
            }
            if(!stack.isEmpty()){
    
    
                current = stack.pop();
                list.add(current.val);
                current = current.right;
            }
        }
        return list;
}

递归

public List<Integer> inorderTraversal(TreeNode root) {
    
    
        if(root == null)
            return new ArrayList<>();
        List<Integer> list= new ArrayList<>();
        list.addAll(inorderTraversal(root.left));
        list.add(root.val);
        list.addAll(inorderTraversal(root.right));
        return list;
}

先序遍历

非递归

public List<Integer> preorderTraversal(TreeNode root) {
    
    
        if(root == null)
            return new ArrayList<>();
        List<Integer> list= new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode current = root;
        while(!stack.isEmpty()||current!=null){
    
    
            while(current!=null){
    
    
                list.add(current.val);
                stack.push(current);
                current = current.left;
            }
            if(!stack.isEmpty()){
    
    
                current = stack.pop();

                current = current.right;
            }
        }
        return list;
}

递归

public List<Integer> preorderTraversal(TreeNode root) {
    
    
        if(root == null)
            return new ArrayList<>();
        List<Integer> list= new ArrayList<>();
        list.add(root.val);
        list.addAll(preorderTraversal(root.left));
        list.addAll(preorderTraversal(root.right));
        return list;
}

后序遍历

递归

public List<Integer> postorderTraversal(TreeNode root) {
    
    
        if(root == null)
            return new ArrayList<>();
        List<Integer> list= new ArrayList<>();

        list.addAll(postorderTraversal(root.left));
        list.addAll(postorderTraversal(root.right));
        list.add(root.val);
        return list;
}

非递归

public List<Integer> postorderTraversal(TreeNode root) {
    
    
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        boolean flag;
        TreeNode pre;
        TreeNode current = root;
        do{
    
    
            while(current!=null){
    
    
                stack.push(current);
                current = current.left;
            }
            pre = null;
            flag = true;
            while(!stack.isEmpty()&&flag){
    
    
                current = stack.peek();
                if(current.right==pre){
    
    
                    list.add(current.val);
                    current = stack.pop();
                    pre = current;
                }else{
    
    
                    current = current.right;
                    flag = false;
                }
            }
        }while(!stack.isEmpty());
        return list;
}

层序遍历

public List<List<Integer>> levelOrder(TreeNode root) {
    
    
        if(root==null){
    
    
            return new ArrayList<>();
        }
        List<List<Integer>> lists = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        queue.add(null);//分层标记
        List<Integer> list = new ArrayList<>();
        while(!queue.isEmpty()){
    
    
            TreeNode element = queue.remove();
            if(element==null){
    
    
                lists.add(list);
                list = new ArrayList<>();
                if(!queue.isEmpty()){
    
    //当队列为空时就不需要再标记了
                    queue.add(null);
                }
            }else{
    
    
                if(element.left!=null)
                    queue.add(element.left);
                if(element.right!=null)
                    queue.add(element.right);
                list.add(element.val);
            }
        }
        return lists;
}