栈的操作和练习题

1.栈的基础结构（他的本质就是数组，别想太多东西）

后进先出

public class MyStack {
    int[] array;
    int usedsize;             //栈中被使用了几个元素

    public MyStack() {
      array = new int[5];
    }

2.栈是不是满（满了要扩容） ，不用返回东西，满了进行操作就好，用于入栈

//是否为满
    public void isFull(){
        if(usedsize==5){
           array= Arrays.copyOf(this.array,2*array.length);

        }

 3.是否为空，用于删除时候，判断是否用删除

//是否为空
    public boolean isEmpty(){
        if(usedsize==0){
            return true;
        }
        else  return false;
    }

4.获取栈顶元素，并不删除

//获取栈顶元素
    public  int peek(){
        return array[usedsize-1];           //就是栈中有几个元素-1，就是结尾的下标
    }

5.压栈

//压栈
    public  void push(int data){
        isFull();                    //满了扩容，不满就直接进去就好。
        array[usedsize++]=data;
    }

6.删除栈顶元素

//删除栈顶元素
     public  boolean pop(){
        if(isEmpty()){               //判断是不是空，空了就不可以删除
            return false;
        }else
            usedsize--;
        return true;
     }

7.遍历并打印栈中元素

//遍历栈
      public void display(){
        for(int i=0;i<usedsize;i++){
            System.out.println(array[i]);
        }

他的操作还是很简单，当然有时候用集合框架一套就行，但是基本操作还是要会的

下面两道经典小题

1.括号匹配，很经典                                                                                   链接      //力扣

首先思路说一下：如果他给的符号不是偶数肯定不匹配，

char [] t=s.toCharArray()       toCharArray这块要复习一下，是把字符串转换为字符数组，然后如果栈空，就直接入栈，，如果栈不空，来看括号是否有和他相匹配的，我的思路是栈里面有左括号，然后数组中假如有右括号，并且和他匹配，就弹一个栈，相当于把一个括号消掉了，假如没有相匹配的，那么就入栈。    

另外：换句话说左括号全部入栈，看栈顶和t[i]（右括号）是否匹配。 

class Solution {
    public boolean isValid(String s) {
    Stack<Character>stack=new Stack<Character>();
    if(s.length()%2!=0){
        return false;
    }
    char[] t=s.toCharArray();
    for(int i=0;i<s.length();i++){   
      if(stack.isEmpty())                 //空就入栈
        stack.push(t[i]); 
      else   if((stack.peek()=='{'&&t[i]=='}')||(stack.peek()=='('&&t[i]==')')||(stack.peek()=='['&&t[i]==']')){
        stack.pop();                       //匹配上就删除栈顶元素
    }
    else stack.push(t[i]);                 //否则入栈
    }
    return stack.isEmpty();               //返回是否为空，空就说明匹配上了
    }
}

2.逆波兰表达式（经典）                                                                               链接：力扣

刚开始看没有用题，最后一句才是重点

适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中                       

这句话才是最重要的。          

 细节的小知识点补充：1.字符的比较是用equals(里面是字符)。

                                        2.Integer.parseInt（字符串）字符串转数字

class Solution {
    public int evalRPN(String[] tokens) {
    Stack<Integer> stack=new Stack<>();
    for(int i=0;i<tokens.length;i++){
        String m=tokens[i];
        if (!(m.equals("+")||m.equals("-")||m.equals("*")||m.equals("/"))) {
        stack.push(Integer.parseInt(m));}           //（不是加减乘除，数字入栈）
    
        if(m.equals("+")){
             int a=stack.peek();                  //取栈顶a和栈顶b，取出来一个删除一个
             stack.pop();         
             int b=stack.peek();
             stack.pop();
             stack.push(a+b);
        }
        if(m.equals("-")){                      //-号和/号有细节问题
             int a=stack.peek();                 // 13-5   的波兰式子是 13 5 -
             stack.pop();                       //5在栈中比13会先出来，所以后减前
             int b=stack.peek();             
             stack.pop();
             stack.push(b-a);              
        }
        if(m.equals("*")){
             int a=stack.peek();
             stack.pop();
             int b=stack.peek();
             stack.pop();
             stack.push(a*b);
        }
        if(m.equals("/")){
             int a=stack.peek();               // 13/5   的波兰式子是 13 5 /
             stack.pop();                     //5在栈中比13会先出来，所以后除前
             int b=stack.peek();
             stack.pop();
             stack.push(b/a);
        }
    }
    return stack.peek();
    }
}