（一）栈中最小值 ，对称二叉树

1.题目描述：定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
注意：保证测试中不会当栈为空的时候，对栈调用pop()或者min()或者top()方法。
分析：首先栈的push（）和pop（）都是O（1）；时间复杂度为O(1)也就是说无论数据规模多大，都可以在一次计算后找到目标（不考虑冲突的话）。栈的特色是先进后出。
思路：可以考虑用空间来换取时间

 import java.util.Stack;

public class test
{
    private static Stack<Integer> stack = new Stack<Integer>();
    private static Stack<Integer> minStack = new Stack<Integer>();
    //入栈的话有值就入栈，栈空时都入  栈不空对min栈进行判断保证栈顶元素一定是最小的
    public void push(int node){
        stack.push(node);
        if(minStack.isEmpty()){
             minStack.push(node);
        }
        else{
            if (node<minStack.peek()){
                minStack.push(node);
            }else{
                minStack.push(minStack.peek());
            }
        }
    }
    public void pop(){

        minStack.pop();
        stack.pop();
        
    }
    //stack的栈顶元素
    public int top(){
        return stack.peek();
    }
    //minstack的栈顶元素
    public int min(){
        return minStack.peek();
    }
}

2.判断二叉树是否为对称的二叉树
思路1：利用递归首先 要知道对称的二叉树是 节点的左孩子等于对称节点的右孩子

boolean isDuichen（TreeNode leftRoot,TreeNode rightNode）{
   if(leftRoot == null&&rightRoot ==null)
      return  true；
   if（leftRoot ==null || rightRoot == null）
     return false;
   if(leftRoot.val==rightRoot.val){
      return (isDuichen(leftRoot.left,rightRoot.right )&&isDuichen(leftRoot.right,rightRoot.left))
  }else{
    return false;
 }
}
boolean  isSymmetrical（TreeNode pRoot）{
    if(pRoot==null){
        return true;
   }else
   return isDuichen(pRoot.left,pRoot.right);
   
}

思路2：利用链表就是每次添加进去然后取出来进行比较 左子树是从左往右加，右子树是从优往左加 就是每加入一波取出判断一波

 boolean isSymmtrical(TreeNode pRoot){
    if(pRoot == null)
      return true;
    LinkedList<TreeNode> leftlist = new LinkedList<>();
    LinkedList<TreeNode> rightlist = new LinkedList<>();

    leftlist.add(pRoot.left);
    rightlist.add(pRoot.right);
    while(!leftlist.isEmpty()&&!rightlist.isEmpty()){
       TreeNode leftnode = leftlist.poll();
       TreeNode rightnode = rightlist.poll();
       //遍历完列表表示检查完毕
       if(leftnode ==null&& rightnode==null)
          return continue;
       if(leftnode =null||rightnode)=null)
          return false;
       //用不等号因为如果用等号的话会有可能没有遍历完毕
       if(leftnode.val != rightnode.val)
          return false;
       //左子树  从左往右加
       leftlist.add(leftnode.left);
       leftlist.add(leftnode.right);
       //右子树  从右往左加   
       rightlist.add(rightnode.right);
       rightlist.add(rightnode.left);
      
    }
    return leftlist.isEmpty() && rightlist.isEmpty();
    

}