Java二叉树逆序遍历_二叉树遍历小结

二叉树遍历小结

声明

0 二叉树遍历概述

二叉树遍历：按照既定序，对每个节点仅访问一次；

二叉树非递归遍历思想：参考这篇博文，核心思想是存在重合元素的局部有序保证整体有序，由于二叉树的结构特点，二叉树中的每个节点(除根节点和叶子节点)均属于两个局部的重合元素。对于任一重合元素，保证所在两个局部遍历有序，保证实现整体遍历有序；

重合元素所在局部：

局部全部有序，遍历该元素并出栈；

局部未全部有序，将未有序局部元素全部入栈。由于栈是LIFO，局部元素按照逆序入栈；

二叉树节点TreeNode声明

public class TreeNode {

public int val;

public TreeNode left, right;

public TreeNode(int val) {

this.val = val;

this.left = this.right = null;

}

}

1 前序遍历

1.1 非递归实现

public class Solution {

private class Pair {

public TreeNode node;

public boolean isVisited;

public Pair(TreeNode node, boolean isVisited) {

this.node = node;

this.isVisited = isVisited;

}

}

public ArrayList preorderTraversal(TreeNode root) {

ArrayList list = new ArrayList();

if (root == null) {

return list;

}

ArrayDeque stack = new ArrayDeque();

stack.push(new Pair(root, false));

while (!stack.isEmpty()) {

Pair top = stack.pop();

// 重合节点完成所有局部有序，弹出

if (top.isVisited) {

list.add(top.node.val);

} else {

// reverse: right -> left -> root

if (top.node.right != null) {

stack.push(new Pair(top.node.right, false));

}

if (top.node.left != null) {

stack.push(new Pair(top.node.left, false));

}

stack.push(new Pair(top.node, true));

}

}

return list;

}

}

1.2 递归实现

public class Solution {

public ArrayList preorderTraversal(TreeNode root) {

ArrayList list = new ArrayList();

if (root == null) {

return list;

}

traverse(list, root);

return list;

}

private void traverse(ArrayListlist, TreeNode root) {

if (root == null) {

return;

}

list.add(root.val);

traverse(list, root.left);

traverse(list, root.right);

}

}

2 中序遍历

2.1 非递归实现

public class Solution {

private class Pair {

public TreeNode node;

public boolean isVisited;

public Pair(TreeNode node, boolean isVisited) {

this.node = node;

this.isVisited = isVisited;

}

}

public ArrayList inorderTraversal(TreeNode root) {

ArrayList list = new ArrayList();

if (root == null) {

return list;

}

ArrayDeque stack = new ArrayDeque();

stack.push(new Pair(root, false));

while (!stack.isEmpty()) {

Pair top = stack.pop();

if (top.isVisited) {

list.add(top.node.val);

} else {

// reverse: right -> root -> left

if (top.node.right != null) {

stack.push(new Pair(top.node.right, false));

}

stack.push(new Pair(top.node, true));

if (top.node.left != null) {

stack.push(new Pair(top.node.left, false));

}

}

}

return list;

}

}

2.2 递归实现

public class Solution {

public ArrayList inorderTraversal(TreeNode root) {

ArrayList list = new ArrayList();

if (root == null) {

return list;

}

traverse(list, root);

return list;

}

private void traverse(ArrayListlist, TreeNode root) {

if (root == null) {

return;

}

traverse(list, root.left);

list.add(root.val);

traverse(list, root.right);

}

}

3 后序遍历

3.1 非递归实现

public class Solution {

private class Pair {

public TreeNode node;

public boolean isVisited;

public Pair(TreeNode node, boolean isVisited) {

this.node = node;

this.isVisited = isVisited;

}

}

public ArrayList postorderTraversal(TreeNode root) {

ArrayList list = new ArrayList();

if (root == null) {

return list;

}

ArrayDeque stack = new ArrayDeque();

stack.push(new Pair(root, false));

while (!stack.isEmpty()) {

Pair top = stack.pop();

if (top.isVisited) {

list.add(top.node.val);

} else {

// reverse: root -> right -> left

stack.push(new Pair(top.node, true));

if (top.node.right != null) {

stack.push(new Pair(top.node.right, false));

}

if (top.node.left != null) {

stack.push(new Pair(top.node.left, false));

}

}

}

return list;

}

}

3.2 递归实现

public class Solution {

public ArrayList postorderTraversal(TreeNode root) {

ArrayList list = new ArrayList();

if (root == null) {

return list;

}

traverse(list, root);

return list;

}

private void traverse(ArrayList list, TreeNode root) {

if (root == null) {

return;

}

traverse(list, root.left);

traverse(list, root.right);

list.add(root.val);

}

}

4 层序遍历

public class Solution {

public ArrayList> levelOrder(TreeNode root) {

ArrayDeque queue = new ArrayDeque();

ArrayList> list = new ArrayList>();

if (root == null) {

return list;

}

queue.offer(root);

while (!queue.isEmpty()) {

int level = queue.size();

ArrayList levelList = new ArrayList();

// 按层BFS遍历

for (int i = 0; i < level; i++) {

TreeNode head = queue.poll();

levelList.add(head.val);

if (head.left != null) {

queue.offer(head.left);

}

if (head.right != null) {

queue.offer(head.right);

}

}

list.add(levelList);

}

return list;

}

}