栈和队列相关知识

栈和队列都是线性表

标题1：栈的相关操作

1.栈----->只能一头插入 / 一头删除
2.出入栈规则：
先进后出 First In Last Out（FILO）
后进先出 Last In First Out（LIFO）
3.存int类型
class Stack {
//属性:
存数据的空间 Int[] array;
当前栈内元素个数 Int top; //在栈里写做top，表示栈顶元素
//方法（公开）
构造方法
插入数据 （尾插） void push(int val);
删除数据 （尾删） void pop();
查看栈顶元素 [top-1] int top();
返回栈内数据元素个数 top int size();
判断栈是否为空 top==0； boolean isEmpty();
}

4.栈的应用
题目：有效的括号（括号匹配问题）

//  {} [] ()  有效匹配
//  {[()]}    有效匹配
//  ([{}])    有效匹配
//
//  {{{{      左括号多
//  }}}}      右括号多
//  (}        左右括号不匹配
【解题思路】：遍历字符串中的每个字符
                 如果是左括号：入栈
                如果是右括号：
                    若栈是空的：则不匹配（则右括号多了）  }}}}
                    出栈
                    如果左右括号不匹配：则不匹配    (} (}
                    否则继续循环
                如果栈不为空：则不匹配（右括号多）   {{{{
                否则匹配    
 
 import java.util.ArrayList;

public class Solution_bracket {
    public boolean isValid(String s){
        ArrayList<Character> stack=new ArrayList<>();

        for(int i=0;i<s.length();i++){
            char c=s.charAt(i);
            
            switch (c){
                case '(':
                case '[':
                case '{':
                    stack.add(c);
                    break;
                case ')':
                case ']':
                case '}':{
                    if(stack.isEmpty()){
                        return false;
                    }
                    char left=stack.remove(stack.size()-1);
                    if(!((left=='('&& c==')')
                            ||(left=='['&&c==']')
                            ||(left=='{'&&c=='}'))){
                        return false;
                    }
                    break;
                }
                default:
                    break;
            }
        }
        if(stack.isEmpty()){
            return true;
        }else {
            return false;//左括号多了
        }
    }
}

标题2：队列的相关操作

1.队列---->在一头插入 / 另一头删除
2.出入队列规则:
先进先出 First In First Out（FIFO）
双端队列 可以在任意两头进出
3.队列的应用：
广度优先遍历（广搜）
（顺序表不容易实现队列，通常使用链表实现）
链表实现队列的基本操作（利用链表的头删，尾插实现队 列）

//单链表实现队列（利用链表的头删，尾插实现队列）
class Node{
    int val;
    Node next;

    Node(int val,Node next){
        this.val=val;
        this.next=next;
    }
    Node(int val){
        this(0,null);
    }
}
public class Queue {
    private Node front = null; //链表的第一个结点
    private Node rear = null;  //链表的最后一个结点
    private int size = 0;      //队列中的所有元素个数

    //只有保证链表尾插头删   才符合队列的进出原则
    //尾插
    public void push(int val){
        Node node=new Node(val);
        if(front==null){
            front=node;
        }else {
            rear.next=node;
        }
        rear=node;
        size++;

    }
    //头删
    public void pop(){
        if(size<=0){
            System.out.println("队列为空！");
            return;
        }
        if(front!=null) {
            front = front.next;
            rear = null;
        }
        size--;
    }
    //返回队首元素
    public int front(){
        if(size<=0){
            System.out.println("队列为空！");
            return -1;
        }
        return front.val;
    }
    //返回队尾元素
    public int rear(){
        if(size<=0){
            System.out.println("队列为空！");
            return -1;
        }
        return rear.val;

    }
    //返回队内元素个数
    public int size(){
        return size;
    }
    //返回队列是否为空
    public boolean isEmpty(){
        return size==0;
    }


}