剑指Offer算法题JAVA版21-30题（全是个人写的非官方，只供参考和自己复习，测试用例都通过了。）

21.栈的压入、弹出序列、

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4，5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）

(思路：模拟整个过程，如果，弹出序列正确那么栈里最终为空的，否则，栈不为空)

 public boolean IsPopOrder(int [] pushA,int [] popA) {
		      Stack<Integer> stack =new Stack<Integer>();
		      int j=0;
		      for(int i=0;i<pushA.length;i++){
		    	  stack.push(pushA[i]);
		    	  while(j<=i&&popA[j]==stack.peek()){
		    		  stack.pop();
		    		  j++;
		    	  }
		      }
		      return stack.isEmpty()?true:false;
		    
			
		}

22. 从上往下打印二叉树

从上往下打印出二叉树的每个节点，同层节点从左至右打印。

（思路：用一个队列保存节点，每个被读取的节点将自己的左右孩子放入队列，然后出队列，并将出队列的元素值放入list。循环知道队列为空）

public class Solution {
		ArrayList<Integer> list=new ArrayList<Integer>();//存放节点值的list
		  public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
			  if(root==null){
				  return list;
			  }
			  ArrayList<TreeNode> list1=new ArrayList<TreeNode>();//队列
			  list1.add(root);//现将头节点放入队列
			 while(!list1.isEmpty()){
				 if(list1.get(0).left!=null){//放节点的左右孩子
					 list1.add(list1.get(0).left);
				 }
				 if(list1.get(0).right!=null){
					 list1.add(list1.get(0).right);
				 }
				 list.add(list1.get(0).val);//保存当前节点的值到list
				 list1.remove(0);//出队列
			 }
			 return list;
			
		  
		    }
	}

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

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

23.1(思路：BST的后序序列的合法序列是，对于一个序列S，最后一个元素是x （也就是根），如果去掉最后一个元素的序列为T，那么T满足：T可以分成两段，前一段（左子树）小于x，后一段（右子树）大于x，且这两段（子树）都是合法的后序序列。完美的递归定义 : ))

public class Solution {
		 public static boolean VerifySquenceOfBST(int [] sequence) {
			 if(sequence.length==0){
				 return false;
			 }
			 if(sequence.length==1){
				 return true;
			 }
			 int i=0;
			 while(sequence[i]<sequence[sequence.length-1]){
				 i++;
			 }
			 boolean isOk=false;
			 int j=i;
			 while(sequence[j]>sequence[sequence.length-1]){
				j++;
				 }
			 if(j==sequence.length-1){
				 isOk=true;
			 }
			 int [] sequenceSmall=new int[i];
			 for(int k=0;k<i;k++){
				 sequenceSmall[k]=sequence[k];
			 }
			 int [] sequenceBig=new int[sequence.length-1-i];
			 for(int t=0;t<sequenceBig.length;t++){
				 sequenceBig[t]=sequence[i+t];
			 }
			 if(sequenceSmall.length!=0&&sequenceBig.length!=0){
			 return isOk&&VerifySquenceOfBST(sequenceSmall)&&VerifySquenceOfBST(sequenceBig);
			 }else if(sequenceSmall.length==0&&sequenceBig.length==0){
				 return isOk;
			 }else if(sequenceSmall.length==0&&sequenceBig.length!=0){
				 return isOk&&VerifySquenceOfBST(sequenceBig);
			 }else{
				 return isOk&&VerifySquenceOfBST(sequenceSmall);
			 }
		        
		    }
	}

23.2非递归

public class Solution {
  public static boolean VerifySquenceOfBST(int [] sequence) {
			 if(sequence.length==0||sequence==null) return false;
		int n=sequence.length-1;
		while(n>=0){
			int i=0;
			while(sequence[i]<sequence[n])i++;
			while(sequence[i]>sequence[n])i++;
			if(i!=n) return false;
			n--;
		}
			 return true;
	}
}

24.二叉搜索树与双向链表

输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。

	public class Solution {
		static Stack<TreeNode> stack =new Stack<TreeNode>();
			 public static TreeNode Convert(TreeNode pRootOfTree) {
                 if(pRootOfTree==null){
                     return null;
                 }
				 TreeNode nowNode=null;
				 Stack<TreeNode> stack =stack1(pRootOfTree);
				 if(!stack.isEmpty()){
				 nowNode=stack.pop(); 
				 while(!stack.isEmpty()){
					nowNode.left=stack.peek();
					stack.peek().right=nowNode;
					nowNode=stack.pop();
				 }
				 }
				 return nowNode;
				}
			    public static Stack<TreeNode> stack1(TreeNode pRootOfTree){
			    	if(pRootOfTree==null)
			    		return null;
			    	if(pRootOfTree.left!=null){
			    		stack1(pRootOfTree.left);
			    		
			    	}
			    	stack.push(pRootOfTree);
			    	if(pRootOfTree.right!=null){
			    		stack1(pRootOfTree.right);
			    	}
			    	return stack;
			    }
			
	}