棧和隊列相關知識

棧和隊列都是線性表

標題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;
    }


}