树的遍历总结
整理了最近遇到的关于二叉树的遍历问题，记录如下：
递归：
递归方法比较简单，所以不再赘述。代码如下：
前序:
public class Solution {
/**
* @param root: The root of binary tree.
* @return: Preorder in ArrayList which contains node values.
*/
public ArrayList<Integer> result;
public ArrayList<Integer> preorderTraversal(TreeNode root) {
// write your code here
if (result == null)
result = new ArrayList<Integer>();
if (root == null){
return result;
}
result.add(root.val);
preorderTraversal(root.left);
preorderTraversal(root.right);
return result;
}
}
中序：
public class Solution {
/**
* @param root: The root of binary tree.
* @return: Inorder in ArrayList which contains node values.
*/
public ArrayList<Integer> result;
public ArrayList<Integer> inorderTraversal(TreeNode root) {
// write your code here
if (result == null)
result= new ArrayList<Integer>();
if (root == null){
return result;
}
inorderTraversal(root.left);
result.add(root.val);
inorderTraversal(root.right);
return result;
}
}
后序：
public class Solution {
/**
* @param root: The root of binary tree.
* @return: Postorder in ArrayList which contains node values.
*/
public ArrayList<Integer> result;
public ArrayList<Integer> postorderTraversal(TreeNode root) {
// write your code here
if (result == null)
result = new ArrayList<Integer>();
if (root == null){
return result;
}
postorderTraversal(root.left);
postorderTraversal(root.right);
result.add(root.val);
return result;
}
}
对于非递归
前序
非递归需要用栈来保存遍历的节点，对于前序遍历来说，是在第一次遇到这个节点的时候就访问它，但是需要把它放进栈里，以便于访问完成之后进一步处理它的左右子树。向左走到底，然后再从栈顶取元素，处理其右子树，如果它没有右子树，则再弹出栈顶~~
public class Solution {
/**
* @param root: The root of binary tree.
* @return: Preorder in ArrayList which contains node values.
*/
public ArrayList<Integer> preorderTraversal(TreeNode root) {
// write your code here
ArrayList<Integer> result = new ArrayList<Integer>();
if (root == null){
return result;
}
Stack<TreeNode> s = new Stack<TreeNode>();
while (!s.empty()|| root != null){
while (root != null){
result.add(root.val);
s.push(root);
root = root.left;
}
if (!s.empty()){
root = s.pop();
root = root.right;
}
}
return result;
}
}
中序:
对于中序遍历则同样用栈来保存，但是不是在入栈时就访问，而是在出栈时进行访问。（因为中序遍历要求先访问左子树，由入栈顺序可知，左子树必在根节点之后入栈，所以必先出栈，先访问到。满足要求）
public class Solution {
/**
* @param root: The root of binary tree.
* @return: Inorder in ArrayList which contains node values.
*/
public ArrayList<Integer> result;
public ArrayList<Integer> inorderTraversal(TreeNode root) {
// write your code here
ArrayList<Integer> result= new ArrayList<Integer>();
if (root == null){
return result;
}
Stack<TreeNode> s = new Stack<TreeNode>();
while ( !s.empty() || root != null){
while (root != null){
s.push(root);
root = root.left;
}
if (!s.empty()){
root = s.pop();
result.add(root.val);
root = root.right;
}
}
return result;
}
}
后序：
后序遍历比较复杂，在一个节点出栈前，用pre保存上次访问过的节点，如果其右孩子被访问过了或者右孩子为空，则应该出栈，并访问该节点，并将pre置为该节点，root=null是为了出栈下一个元素（因为根都访问完了，该再有新元素出栈了），如果没有，则应该先访问右子树，而非当前元素出栈。
public class Solution {
/**
* @param root: The root of binary tree.
* @return: Postorder in ArrayList which contains node values.
*/
public ArrayList<Integer> postorderTraversal(TreeNode root) {
// write your code here
ArrayList<Integer> result = new ArrayList<Integer>();
if (root == null){
return result;
}
Stack<TreeNode> s = new Stack<TreeNode>();
TreeNode pre = null;
while ( !s.empty() || root != null){
while (root != null){
s.push(root);
root = root.left;
}
if ( !s.empty()){
root = s.peek();
if ( pre == root.right || root.right == null){
root = s.pop();
result.add(root.val);
pre = root;
root = null ;
}
else{
root = root.right;
}
}
}
return result;
}
}
