算法练习

题目：定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。

题目分析：需要定义栈数据结构，并提供找出栈内最小元素的min函数，并且时间复杂度O(1)。

思路：借助辅助栈来实现（入栈时：添加的元素小于辅助栈的最顶元素，则入到辅助栈中。出战时：辅助栈和元栈栈顶元素相等则辅助栈出栈。）

对原来栈的封装，使之实现O（1）复杂度的min方法。

import java.util.Stack;

public class Solution {
    //O（1）时间复杂度，借助辅助栈来实现（入栈时：添加的元素小于辅助栈的最顶元素，则入到辅助栈中。出战时：辅助栈和元栈栈顶元素相等则辅助栈出栈。）。
    //对原来栈的封装，使之实现O（1）复杂度的min方法。
    Stack<Integer> stack1 = new Stack<>(),stack2 = new Stack<>();
    public void push(int node) {
        stack1.push(node);
        if(stack2.empty()){
            stack2.push(node);
        }else if(node<stack2.peek()){
            stack2.push(node);
        }
    }
    
    public void pop() {
        if(stack1.peek()==stack2.peek()){
            stack2.pop();
        }
        stack1.pop();
        
    }
    
    public int top() {
        return stack1.peek();
    }
    
    public int min() {
        return stack2.peek();
    }
}

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

思路：利用辅助栈，对入栈序列压栈，判断栈顶元素与出栈元素是否相同，相同则出栈，最后判断栈是否为空。

import java.util.ArrayList;
import java.util.Stack;
public class Solution {
    //利用辅助栈，对入栈序列压栈，判断栈顶元素与出栈元素是否相同，相同则出栈，最后判断栈是否为空。
    public boolean IsPopOrder(int [] pushA,int [] popA) {
        if(pushA.length == 0 || popA.length == 0)
            return false;
        Stack<Integer> tmp = new Stack<>();
        int j=0;
        for(int i=0;i<pushA.length;i++){
            tmp.push(pushA[i]);
            while(!tmp.empty()&&tmp.peek()==popA[j]){
                tmp.pop();
                j++;
            }
        }
        return tmp.empty();
    }
}

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

思路：使用ArrayList模拟队列，先进先出，实现逐层遍历。

import java.util.ArrayList;
/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
        /**
        //逐层遍历
        if(root == null){
            return new ArrayList<Integer>();
        }
        ArrayList<TreeNode> list = new ArrayList<>();
        list.add(root);
        return method(list);
        **/
        //使用ArrayList模拟队列，先进先出
        ArrayList<Integer> list = new ArrayList<>();
        ArrayList<TreeNode> queue = new ArrayList<>();
        if(root == null){
            return list;
        }
        queue.add(root);
        while(!queue.isEmpty()){
            TreeNode tmp = queue.remove(0);
            if(tmp.left!=null){
                queue.add(tmp.left);
            }
            if(tmp.right!=null){
                queue.add(tmp.right);
            }
            list.add(tmp.val);
        }
        return list;
    }
    //逐层将TreeNode保存到ArrayList中
    private ArrayList<Integer> method(ArrayList<TreeNode> floor){
        ArrayList<Integer> nodelist = new ArrayList<>();
        if(floor==null||floor.size()==0){
            return null;
        }
        ArrayList<TreeNode> list = new ArrayList<TreeNode>();
        for(TreeNode node:floor){
            nodelist.add(node.val);
            if(node.left!=null){
               list.add(node.left);
            }
            if(node.right!=null){
               list.add(node.right);
            }
        }
        ArrayList<Integer> tmpList = method(list);
        if(tmpList!=null)
            nodelist.addAll(tmpList);
        return nodelist;
    }
}

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

public class Solution {
    public boolean VerifySquenceOfBST(int [] sequence) {
        if(sequence==null||sequence.length==0){
            return false;
        }
        if(sequence.length==1){
            return true;
        }else{
            int root = sequence[sequence.length-1];
            int cut = 0;
            while(sequence[cut]<root){
                cut++;
            }
            for(int i=cut;i<sequence.length;i++){
                if(sequence[i]<root){
                    return false;
                }
            }
            int[] left = new int[cut];
            int[] right = new int[sequence.length-cut-1];
            for(int i=0;i<sequence.length-1;i++){
                if(i<cut){
                    left[i] = sequence[i];
                }else{
                    right[i-cut] = sequence[i];
                }
            }
            if(left.length!=0){
                if(right.length!=0){
                    return VerifySquenceOfBST(left)&&VerifySquenceOfBST(right);
                }else{
                    return VerifySquenceOfBST(left);
                }
            }else{
                if(right.length!=0){
                    return VerifySquenceOfBST(right);
                }else{
                    return true;
                }
            }
            
        }
        
    }
}