队和栈的题（2021-7-11）

1.二叉搜索树的后序遍历序列

import java.util.Arrays;
public class Solution{
  public boolean VerifySquenceOfBST(int [] sequence){
    if(sequence==null||sequence.length==0) return false;
    return helpVerify(sequence,0,sequence.length-1);//(数组名称，起始位置为0，终止位置为sequence.length-1);
  }
  public boolean helpVerify(int [] sequence,int start,int root){
  if(start>=root) return true;//当左子树的值>根，遍历到最后 都是true
  int key=sequence[root];//定义key为数组的根节点
  int i;
  //找到左右子树的临界点
  for(i=start;i<root;i++){//遍历左子树
     if(sequence[i]>key) break;//如果左子树的值都大于根的值，就结束
  }
  for(int j=i;j<root;j++){//遍历右子树
     if(sequence[j]<key) return false;//如果右子树的值小于根的值，就结束
  }
  return helpVerify(sequence,start,i-1)&&helpVerify(sequence,i,root-1);
  }
}

思路：解决树的问题一般就是递归
1.二叉搜索树：左<根<右
2.后序遍历：左右根
3.定义一个根节点，作为临界值，用左右子树和根节点比较
4.左子树如果大于根节点就结束，右子树如果小于根节点就结束。

2.按之字形顺序打印二叉树

import java.util.*;
public class Solution{
  public ArrayList<ArrayList<Integer>> Print(TreeNode pRoot){
  ArrayList<ArrayList<Integer>> result=new ArrayList<>();
  if(pRoot==null){
  return result;
  }
  Queue<TreeNode> queue=new LinkedList<>();
  queue.add(pRoot);
  boolean reverse=true;
  while(!queue.isEmpty()){
    int size=queue.size();//获取每一层的节点个数
    ArrayList<Integer> list=new ArrayList<>();//创建一个list集合
    for(int i=0;i<size;i++){
    TreeNode node=queue.poll();
    if(node==null){
    continue;
    }
    if(reverse){
    list.add(node.val);
    }else{
    list.add(0,node.val);
    }
    queue.offer(node.left);
    queue.offer(node.right);
    }
    if(list.size()>0){
    result.add(list);
    }
    reverse=!reverse;
  }
  return result;
  }
}

思路：按层打印二叉树（奇数层从左到右打印，偶数层从右到左打印）
1.先得到队列的长度size,size就是这一层的节点个数，然后通过for循环poll出size这个节点
之字形取值的核心思路两个方法：
1.list.add(T):按照索引顺序从小到大依次添加
2.list.add(index,T):将元素插入index位置，index索引后的元素依次后移，这就是完成了每一行元素的倒序。或者使用Collection.reverse()方法倒序。

3.序列化二叉树

public class Solution{
   String Serialize(TreeNode root){
   StringBuffer sb=new StringBuffer();//新建一个字符串
   if(root==null){
      sd.append("#,");
      return sb.toString();//转化成string类型的字符串
   }
   sb.append(root.val+",");
   sb.append(Serialize(root.left));
   sb.append(Serialize(root.right));
   return sb.toString();//转化成string类型的字符串
   }
   //使用index来设置树节点的val值，递归遍历左节点和右节点
   //如果值是#则表示空节点，直接返回
   int index=-1;
   TreeNode Deserialize(String str){
     index++;
     int len=str.length();
     String[] strr=str.split(",");//将序列化之后的序列用，分隔符转化为数组
     TreeNode node=null;
     if(index>=len) return null;
     if(!strr[index].equals("#")){//不是叶子节点继续走，是叶子节点除递归
     node=new TreeNode(Integer.valueOf(strr[index]));
     node.left=Deserialize(str);
     node.right=Deserialize(str);
     }
     return node;
   }
}

思路：序列化：前序遍历二叉树存入字符串中
     1.就是先将根节点放入，然后在将左子树加入，在将右子树加入。
     反序列化：根据前序遍历重建二叉树
     1.先定义字符串的长度为len
     2.先将字符串转化成数组
     3.先确定将好根节点的索引
     4.然后在分别反序列化左子树和右子树。