每日LeeteCode-二叉树的前序遍遍历、中序遍历、后序遍历和层级遍历

节点申明:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */

在给定节点的情况下,对二叉树进行前、中、后序及层级进行遍历,每种遍历又分为递归和迭代两种形式
那这个主要考察的其实是对栈、队列数据结构的使用

前序遍历

递归

class Solution {
	// 存放结果集
    private List<Integer> list = new ArrayList<>();

    public List<Integer> preorderTraversal(TreeNode root) {
        add(root);
        return list;
    }
	// 递归方法
    private void add(TreeNode root) {
        if (root == null) {
            return;
        }
        // 中
        list.add(root.val);
        // 左
        add(root.left);
        // 右
        add(root.right);
    }
}

迭代 - 栈

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
    	// 创建栈对象和返回结果
        LinkedList<TreeNode> stack = new LinkedList<>();
        LinkedList<Integer> res = new LinkedList<>();
		// 空值判断
         if (root == null) {
            return res;
        }
		// 将根节点入栈
        stack.add(root);
		// 结束条件: 栈里没有节点了
        while (stack.size() > 0) {
			// 将当前节点出栈
            TreeNode node = stack.pollLast();
            res.add(node.val);
			// 先压右节点
            if (node.right != null) {
                stack.add(node.right);
            }
			// 后压左节点
            if (node.left != null) {
                stack.add(node.left);
            }
        }
        return res;
    }
}

中序遍历

递归

class Solution {
	// 存放结果集
    private List<Integer> list = new ArrayList<>();

    public List<Integer> inorderTraversal(TreeNode root) {
        add(root);
        return list;
    }
	// 递归方法
    private void add(TreeNode root) {
        if (root == null) {
            return;
        }
        // 左
        add(root.left);
        // 中
        list.add(root.val);
        // 右
        add(root.right);
    }
}

迭代 - 栈

class Solution {

    public List<Integer> inorderTraversal(TreeNode root) {
		// 创建栈
        Stack<TreeNode> stack = new Stack<>();
        List<Integer> list = new ArrayList<>();
		// 空值判断
        if (root == null) {
            return list;
        }

        TreeNode node = root;
		// 当左边遍历结束时,栈为空
        while(node != null || !stack.empty()) {
        	// 将左节点依次入栈(包括自己),直到最左边
            while (node != null) {
                stack.push(node);
                node = node.left;
            } 
            node = stack.pop();
            list.add(node.val);
      		// 左节点+根节点结束,开始右jiedian
            node = node.right;
        }
        return list;
    }
}

后序遍历

递归

class Solution {
	//存放结果集
    private List<Integer> list = new ArrayList<>();
    public List<Integer> postorderTraversal(TreeNode root) {
        add(root);
        return list;
    }
	// 递归方法
    private void add(TreeNode root) {
        if (root == null) {
            return;
        }
        // 左
        add(root.left);
        // 右
        add(root.right);
        // 根
        list.add(root.val);
    }
}

迭代 - 栈和队列

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
    	// 创建栈
        LinkedList<TreeNode> stack = new LinkedList<>();
        // 结果集
        LinkedList<Integer> list = new LinkedList<>();

        if (root == null) {
            return list;
        }

        stack.add(root);
        while (stack.size() > 0) {
            TreeNode node = stack.pollLast();
            // 结果集倒序
            list.addFirst(node.val);
            if (node.left != null) {
                stack.add(node.left);
            }
            if (node.right != null) {
                stack.add(node.right);
            }
        }
        return list;
    }
}

层级遍历

迭代 - 队列

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {

        LinkedList<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> list = new ArrayList<>();

        if (root == null) {
            return list;
        }

        queue.add(root);

        while (queue.size() > 0) {
            int len = queue.size();
            List<Integer> currList = new ArrayList<>();
            for (int i = 0; i < len; i ++) {
                TreeNode node = queue.pollFirst();
                currList.add(node.val);
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
            list.add(currList);
        }
        return list;
    }
}