栈和队列

1. 栈

1.1 概念

栈是一种基于先进后出(FILO)的数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出
的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一
个数据被第一个读出来）。
我们称数据进入到栈的动作为压栈，数据从栈中出去的动作为弹栈。

1.2 代码实现

设计思路：

定义一个链表，入栈时每次都往头结点的下一个元素插（第一个结点），弹栈时也是从第一个结点开始弹起

//栈
public class Stack<T> implements Iterable<T>{
    //记录首结点
    private Node head;
    //栈中元素的个数
    private int N;
    private class Node{
        public T item;
        public Node next;
        public Node(T item, Node next) {
            this.item = item;
            this.next = next;
        }
    }
    public Stack() {
        this.head = new Node(null,null);
        this.N=0;
    }
    //判断当前栈中元素个数是否为0
    public boolean isEmpty(){
        return N==0;
    }
    //获取栈中元素的个数
    public int size(){
        return N;
    }
    //把t元素压入栈
    public void push(T t){
        //找到首结点指向的第一个结点
        Node oldFirst = head.next;
        //创建新结点
        Node newNode = new Node(t, null);
        //让首结点指向新结点
        head.next = newNode;
        //让新结点指向原来的第一个结点
        newNode.next=oldFirst;
        //元素个数+1；
        N++;
    }
    //弹出栈顶元素
    public T pop(){
        //找到首结点指向的第一个结点
        Node oldFirst = head.next;
        if (oldFirst==null){
            return null;
        }
        //让首结点指向原来第一个结点的下一个结点
        head.next=oldFirst.next;
        //元素个数-1；
        N--;
        return oldFirst.item;
    }
}

1.3 括号匹配问题

问题描述：

给定一个字符串，里边可能包含"()"小括号和其他字符，请编写程序检查该字符串的中的小括号是否成对出现。
	例如：
        "(上海)(长安)"：正确匹配
        "上海((长安))"：正确匹配
        "上海(长安(北京)(深圳)南京)":正确匹配
        "上海(长安))"：错误匹配
        "((上海)长安"：错误匹配

分析思路：

1. 创建一个栈来存储左括号
2. 循环遍历栈中的元素，依此拿到每个元素
3. 判断该字符是左括号，如果是，则放入栈中
4. 判断字符是不是右括号，如果不是，继续下层循环
5. 如果是右括号，则从栈中弹出一个元素
6. 判断元素t是否为null，如果不是，则证明有对应的左括号，如果不是，则证明没有对应的左括号
7. 循环结束后，判断栈中还有没有剩余的左括号，如果有，则不匹配，如果没有，则匹配

代码实现：

//括号匹配问题
public class BracketsMatch {
    public static void main(String[] args) {
        String str = "(fdafds(fafds)())";
        boolean match = isMatch(str);
        System.out.println(str + "中的括号是否匹配：" + match);
    }
    /**
    * 判断str中的括号是否匹配
    * @param str 括号组成的字符串
    * @return 如果匹配，返回true，如果不匹配，返回false
    */
    public static boolean isMatch(String str) {
        //1.创建一个栈用来存储左括号
        Stack<String> chars = new Stack<>();
        //2.从左往右遍历字符串，拿到每一个字符
        for (int i = 0; i < str.length(); i++) {
            String currChar = str.charAt(i) + "";
            //3.判断该字符是不是左括号，如果是，放入栈中存储
            if (currChar.equals("(")) {
                 chars.push(currChar);
            } else if (currChar.equals(")")) {//4.判断该字符是不是右括号，如果不是，继续下一次循环
                //5.如果该字符是右括号，则从栈中弹出一个元素t；
                 String t = chars.pop();
                //6.判断元素t是否为null，如果不是，则证明有对应的左括号，如果不是，则证明没有对应的左括号
                 if (t == null) {
                     return false;
                  }
             }
        }
        //7.循环结束后，判断栈中还有没有剩余的左括号，如果有，则不匹配，如果没有，则匹配
        if (chars.size() == 0) {
            return true;
        } else {
            return false;
        }
    }
}

1.4 逆波兰表达式问题

逆波兰表达式是波兰逻辑学家J・卢卡西维兹(J・ Lukasewicz)于1929年首先提出的一种表达式的表示方法，后缀表
达式的特点：运算符总是放在跟它相关的操作数之后。

普通中缀表达式	逆波兰表达式
a+b	ab+
c+(a-b)	cab-+
a+(b-c)*d	abc-d*+
a*(b-c)+d	abc-*d+

分析：

1. 创建一个栈对象存储操作数
2. 循环遍历逆波兰表达式，得到每个字符
3. 判断字符是不是运算符，如果不是，则将该操作数压栈
4. 如果是运算符，则从栈中弹出两个元素
5. 运用该运算符计算出结果，将新结果压栈
6. 遍历结束后，拿到最终结果

/**
    * @param notaion 逆波兰表达式的数组表示方式
    * @return 逆波兰表达式的计算结果
    */
    public static int caculate(String[] notaion) {
        //1.创建一个栈对象oprands存储操作数
        Stack<Integer> oprands = new Stack<>();
        //2.从左往右遍历逆波兰表达式，得到每一个字符串
        for (int i = 0; i < notaion.length; i++) {
            String curr = notaion[i];
            //3.判断该字符串是不是运算符，如果不是，把该该操作数压入oprands栈中
            Integer o1;
            Integer o2;
            Integer result;
            switch (curr) {
                case "+":
                    //4.如果是运算符，则从oprands栈中弹出两个操作数o1,o2
                    o1 = oprands.pop();
                    o2 = oprands.pop();
                    //5.使用该运算符计算o1和o2，得到结果result
                    result = o2 + o1;
                    //6.把该结果压入oprands栈中
                    oprands.push(result);
                    break;
                case "-":
                    o1=oprands.pop();
                    o2=oprands.pop();
                    result=o2-o1;
                    oprands.push(result);
                    break;
                case "*":
                    o1=oprands.pop();
                    o2=oprands.pop();
                    result=o1*o2;
                    oprands.push(result);
                    break;
                case "/":
                    o1=oprands.pop();
                    o2=oprands.pop();
                    result=o2/o1;
                    oprands.push(result);
                    break;
                default:
                    oprands.push(Integer.parseInt(curr));
                    break;
            }
        }
        Integer result = oprands.pop();
        return result;
    }

2. 队列

2.1 概念

队列是一种基于先进先出(FIFO)的数据结构，是一种只能在一端进行插入,在另一端进行删除操作的特殊线性表，它
按照先进先出的原则存储数据，先进入的数据，在读取数据时先读被读出来。

2.2 代码实现

//队列
public class Queue<T> implements Iterable<T> {
    private Node head;
    private Node last;
    private Integer N;
    private class Node{
        public T item;
        public Node next;
        public Node(T item,Node next){
            this.item=item;
            this.next=next;
        }
    }
    public Queue(){
        this.head=new Node(null,null);
        this.last=null;
        this.N=0;
    }
    //判断队列是否为空，是返回true，否返回false
    public boolean isEmpty(){
        return N==0;
    }
    //获取队列中元素的个数
    public int size(){
        return N;
    }
    //从队列中拿出一个元素
    public T dequeue(){
        if (isEmpty()){
            return null;
        }
        Node oldFirst = head.next;
        head.next=oldFirst.next;
        N--;
        if (isEmpty()){
            last=null;
        }
        return oldFirst.item;

    }
    //往队列中插入一个元素
    public void enqueue(T t){
        if (last==null){
            //最后一个元素为空
            last = new Node(t,null);
            head.next=last;
        }else {
            Node oldFirst = this.last;
            last=new Node(t,null);
            oldFirst.next=last;

        }
        N++;
    }
}