描述
主要是层次遍历相关的事情
之字形打印二叉树的基本情况
首先从左走到右,接下来一层从右走到左的基本情况
关于这到题目也可以查看下
102 层次遍历并保存每层的结果构成一个collectons
102. Binary Tree Level Order Traversal
层次遍历 BFS
队列中的元素个数其实就是每层节点中的个数, 在while(循环体操作之前我们是可以)
层次遍历中, 利用每层队列中 队列格式进行的情况, 每一层进行一遍处理
while(队列不为空){
int num = 队列中的大小;
// 处理每一层的节点数目情况
for(int 0;i<num;i++){
}
就是每层节点的数目
}
实际上这种办法是BFS, 只不过这种时间复杂度为O(n), n 个节点的情况
public class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
Queue<TreeNode> queue = new LinkedList<TreeNode>();
List<List<Integer>> wrapList = new LinkedList<List<Integer>>();
if(root == null) return wrapList;
queue.offer(root);
while(!queue.isEmpty()){
int levelNum = queue.size();
List<Integer> subList = new LinkedList<Integer>();
for(int i=0; i<levelNum; i++) {
if(queue.peek().left != null) queue.offer(queue.peek().left);
if(queue.peek().right != null) queue.offer(queue.peek().right);
subList.add(queue.poll().val);
}
wrapList.add(subList);
}
return wrapList;
}
}
DFS
深度优先搜索遍历, 其实这道题目也是跟排列组合那道题目一样的解法情况, 使用一个变量depth标记每个节点的层次关系, 按照层次关系进行添加,
第一层, 第二层,,,。。。。。 最后一层
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> result= new LinkedList<>();
if(root==null){
return result;
}
return helper(root, 1, result);
}
private List<List<Integer>>helper(TreeNode root, int depth, List<List<Integer>> result){
if(root==null){
return null;
}
// 为下一次结果进行, = 等号主要是为了第一层的添加, depth, 就是没有添加往才
if(depth>result.size()){
result.add(new LinkedList<>());
}
result.get(depth-1).add(root.val); //
helper(root.left, depth+1, result);
helper(root.right, depth+1,result );
return result;
}
}
103. Binary Tree Zigzag Level Order Traversal
深度优先搜索
对深度加入一个元素进行判断即可, 是中间, depth中间元素, 判断
class Solution {
public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
//利用层次遍历的基本情况
//该种情况如何处理
// 元素可以从中间左右两边进行一个基本情况的添加
List<List<Integer>>result = new LinkedList<>();
if(root==null)
return result;
helper(root, result, 0);
return result;
}
private void helper(TreeNode root, List<List<Integer>> result, int depth){
if(root==null)
return;
if(depth >= result.size())
result.add(new LinkedList<>());
// 在这里取出一个元素而已, 实质上并没有改变原来的元素情况,
// List<Integer> collection = result.get(depth);
if(depth % 2== 0){
result.get(depth).add(root.val);
}
else{
result.get(depth).add(0,root.val);
}
helper(root.left, result, depth+1);
helper(root.right, result, depth+1);
}
}
层次遍历
利用一个标记位来标记一个东西是层数, 注意的是出队列过程添加一个判断是否为空的队列即可
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
//利用层次遍历的基本情况
//该种情况如何处理
// 元素可以从中间左右两边进行一个基本情况的添加
List<List<Integer>>result = new LinkedList<>();
Deque<TreeNode> queue = new LinkedList<>();
int len =0;
queue.offer(root);
if(root==null)
return result;
while(!queue.isEmpty()){
// 在前面就应该知道队列当中的元素情况的话,
int number= queue.size();
// 一次循环处理一层元素情况, 所以在这里的话
List<Integer> tmp=new LinkedList<>();
result.add(tmp);
for(int i=0;i<number;i++)
{
// 如果是在这个过程当中就把元素
TreeNode deal = queue.peek();
if(deal==null)
return null;
if( len% 2==0 )
tmp.add(deal.val);
else
tmp.add(0,deal.val);
if(deal.left!=null)
queue.offer(deal.left);
if(deal.right!=null)
queue.offer(deal.right);
queue.poll();
}
++len;
}
return result;
}
}