二叉树的遍历

二叉树的遍历

这里面主要是针对一些普通二叉树的基本操作进行处理

1： 获取二叉树的深度

获取二叉树的深度本质就是一个DFS问题，我们可以用递归来求解

public int getDeep(TreeNode p){
	if(p==null){
	return 0;
    }
    return Math.max(getDeep(p.left),getDeep(p.right))+1;
}

但是要注意的是，如果递归的深度太深了，将会导致栈的溢出，因为栈保存的是递归的返回结果、程序运行状态、方法返回值等，只有等递归结束，栈里面保存的值才会释放，不然的话一直叠加。对于这样的情况，我们可以用栈来代替递归

2：二叉树的深度遍历

1. 对于如下一颗二叉树

如果我们将其进行深度遍历，输出的结果为1-2-4-5-3-6-7

public List<TreeNode> traversal(TreeNode p){
   List<TreeNode> res =new List<>();
   Stack<TreeNode> stack = new Stack<>();
   if(p==null){
       return res;
   }
   stack.add(p);
   while(!stack.isEmpty()){
       TreeNode temp = stack.peek();
       res.add(temp);
       stack.pop();
       if(temp.right!=null){
           stack.add(temp.right);
       }
        if(temp.left!=null){
           stack.add(temp.left);
       }
   }
   return res;
}

这里面用到了栈来代替递归进行求解

3：二叉树的“Z”字遍历

对于上面的那颗二叉树，对其进行一个“z”字形遍历
输出的结果为：1-2-3-4-5-6-7

import java.util.*;
public ArrayList<Integer> levelOred(TreedNode p){
	ArrayList<Integer> list = new ArrayList<>();
	if(p==null) {
		return list;
	}
	 Queue<TreeNode> q = new LinkedList<TreeNode>();
    q.offer(p);
    while(!q.isEmpty()){
        TreeNode temp = q.poll();
        list.add(temp.val);
        if(temp.left!=null){
            q.offer(temp.left);
        }
        if(temp.right!=null){
            q.offer(temp.right);
        }
    }
    return list;
	}

这里面我们用到了queue队列，它满足FIFO，在这里我们要知道队列中添加元素用offer()，移除第一个元素并且返回其值用poll()

4：二叉树的“之”字形遍历

这里的遍历跟上面的“z”形遍历类似，但是他的遍历规则是第一层从左到右遍历，第二层从右到左遍历，第三层从左到右遍历…。故对于上面的二叉树我们的输出是：1-3-2-4-5-6-7

import java.util.ArrayList;
import java.util.Stack;
import java.util.LinkedList;
public class Solution {
    public ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> list = new ArrayList<>();
        if(pRoot==null){
            return list;
        }
       LinkedList<TreeNode> q = new LinkedList<>();
        q.offer(pRoot);
        Boolean flag = true;
        while(!q.isEmpty()){
            ArrayList<Integer> templist =new ArrayList<>();
            //这里需要获取每一层的节点数，用size保存
            int size = q.size();
            for(int i = 0;i<size;i++){
                TreeNode temp = q.poll();
                if(flag){
                    templist.add(temp.val);
                }
                if(!flag){
                    templist.add(0,temp.val);
                }
                if(temp.left!=null){
                    q.offer(temp.left);
                }
                if(temp.right!=null){
                    q.offer(temp.right);
                }
            }
            flag = !flag;
            if(templist.size()!=0){
                list.add(templist);
            }
            
        }
         return list;
        
    }

}

总结

对于上面的这种层次遍历，我们要学会用到栈或者队列来代替递归，这样可以避免栈的溢出。