栈、队列、符号表

栈

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

我们称数据进入到栈的动作为压栈，数据从栈中出去的动作为弹栈。

代码实现：

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

    @Override
    public Iterator<T> iterator() {
        return new SIterator();
    }

    private class SIterator implements Iterator<T>{
        private Node n;

        public SIterator(){
            this.n=head;
        }

        @Override
        public boolean hasNext() {
            return n.next!=null;
        }

        @Override
        public T next() {
            n = n.next;
            return n.item;
        }
    }
}

括号匹配问题

给定一个字符串，里边可能包含"()"小括号和其他字符，请编写程序检查该字符串的中的小括号是否成对出现。

例如：

"(上海)(长安)"：正确匹配

"(上海)(长安)"：正确匹配

"上海(长安(北京)(深圳)南京)":正确匹配

"上海(长安))"：错误匹配

分析：

1.创建一个栈用来存储左括号

2.从左往右遍历字符串，拿到每一个字符

3.判断该字符是不是左括号，如果是，放入栈中存储

4.判断该字符是不是右括号，如果不是，继续下一次循环

5.如果该字符是右括号，则从栈中弹出一个元素t；

6.判断元素t是否为null，如果不是，则证明有对应的左括号，如果不是，则证明没有对应的左括号

7.循环结束后，判断栈中还有没有剩余的左括号，如果有，则不匹配，如果没有，则匹配

代码实现：

public class BracketsMatchTest {
    public static void main(String[] args) {
        String str = "上海(长安)())";
        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.继续判断当前字符是否是有括号，如果是，则从栈中弹出一个左括号，并判断弹出的结果是否为null,如果为null证明没有匹配的左括号，如果不为null，则证明有匹配的左括号
                String pop = chars.pop();
                if (pop==null){
                    return false;
                }
            }

        }
        //5.判断栈中还有没有剩余的左括号，如果有，则证明括号不匹配
        return chars.size() == 0;

    }
}

逆波兰表达式求值问题

逆波兰表达式求值问题是我们计算机中经常遇到的一类问题，要研究明白这个问题，首先我们得搞清楚什么是逆波兰表达式？要搞清楚逆波兰表达式，我们得从中缀表达式说起。

中缀表达式：

中缀表达式就是我们平常生活中使用的表达式，例如：1+3*2,2-(1+3)等等，中缀表达式的特点是：二元运算符总 是置于两个操作数中间。

中缀表达式是人们最喜欢的表达式方式，因为简单，易懂。但是对于计算机来说就不是这样了，因为中缀表达式的运算顺序不具有规律性。不同的运算符具有不同的优先级，如果计算机执行中缀表达式，需要解析表达式语义，做大量的优先级相关操作。

逆波兰表达式(后缀表达式)：

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

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

解决思路：

代码实现：

@Test
    public void test1(){
        String[] notation = {"3", "17", "15", "-", "*", "18", "6", "/", "+"};
        int result = calculate(notation);
        System.out.println(result);
    }

    private int calculate(String[] notation) {
        //1.定义一个栈，用来存储操作数
        Stack<Integer> stack = new Stack<>();
        //2.从左往右便利逆波兰表达式，得到每一个元素
        for (int i = 0; i < notation.length; i++) {
            String curr = notation[i];
            //3.判断当前元素是运算符还是操作数
            Integer o1;
            Integer o2;
            switch (curr) {
                //4.运算符，从栈中弹出两个操作数，完成运算并压入栈中
                case "+":
                    o1 = stack.pop();
                    o2 = stack.pop();
                    stack.push(o2 + o1);
                    break;
                case "-":
                    o1 = stack.pop();
                    o2 = stack.pop();
                    stack.push(o2 - o1);
                    break;
                case "*":
                    o1 = stack.pop();
                    o2 = stack.pop();
                    stack.push(o2 * o1);
                    break;
                case "/":
                    o1 = stack.pop();
                    o2 = stack.pop();
                    stack.push(o2 / o1);
                    break;
                default:
                    //5.操作数，把操作数放入到栈中
                    stack.push(Integer.valueOf(curr));
            }

        }

        //6.得到栈中最后一个元素，就是逆波兰表达式的结果
        return stack.pop();
    }

队列

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

代码实现：

public class Queue<T> implements Iterable<T>{
    //记录首结点
    private Node head;
    //记录最后一个结点
    private Node last;
    //记录队列中元素的个数
    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 Queue() {
        this.head = new Node(null,null);
        this.last=null;
        this.N=0;
    }

    //判断队列是否为空
    public boolean isEmpty(){
        return N==0;
    }

    //返回队列中元素的个数
    public int size(){
        return N;
    }

    //向队列中插入元素t
    public void enqueue(T t){

        if (last==null){
            //当前尾结点last为null
            last= new Node(t,null);
            head.next=last;
        }else {
            //当前尾结点last不为null
            Node oldLast = last;
            last = new Node(t, null);
            oldLast.next=last;
        }

        //元素个数+1
        N++;
    }

    //从队列中拿出一个元素
    public T dequeue(){
        if (isEmpty()){
            return null;
        }

        Node oldFirst= head.next;
        head.next=oldFirst.next;
        N--;

        //因为出队列其实是在删除元素，因此如果队列中的元素被删除完了，需要重置last=null;

        if (isEmpty()){
            last=null;
        }
        return oldFirst.item;
    }


    @Override
    public Iterator<T> iterator() {
        return new QIterator();
    }

    private class QIterator implements Iterator<T>{
        private Node n;

        public QIterator(){
            this.n=head;
        }
        @Override
        public boolean hasNext() {
            return n.next!=null;
        }

        @Override
        public T next() {
            n = n.next;
            return n.item;
        }
    }

}

测试:

    @Test
    public void test(){
        Queue<Integer> queue = new Queue<>();
        queue.enqueue(1);
        queue.enqueue(2);
        queue.enqueue(3);
        queue.enqueue(4);
        System.out.println(queue.dequeue());
        System.out.println("===================");
        for (Integer integer : queue) {
            System.out.println(integer);
        }
    }

符号表

符号表最主要的目的就是将一个键和一个值联系起来，符号表能够将存储的数据元素是一个键和一个值共同组成的 键值对数据，我们可以根据键来查找对应的值。

符号表中，键具有唯一性。

代码实现：

public class SymbolTable<K, V>{

    protected Node head;

    protected int N;

    protected class Node {
        protected K k;

        protected V v;

        public Node next;

        public Node(K k, V v, Node next){
            this.k = k;
            this.v = v;
            this.next = next;
        }
    }

    public SymbolTable(){
        this.head = new Node(null, null, null);
        this.N = 0;
    }

    public int size(){
        return N;
    }

    public void put(K k, V v){
        Node n = head;

        while (n.next != null){
            n = n.next;
            if (n.k.equals(k)){
                n.v = v;
                return;
            }
        }

        Node newNode = new Node(k, v, null);
        newNode.next = head.next;
        head.next = newNode;
        N++;
    }

    public V remove(K k){
        Node n = head;

        while (n.next != null){
            if(n.next.k.equals(k)){
                V v = n.next.v;
                n.next = n.next.next;
                N--;
                return v;
            }
            n = n.next;
        }
        return null;
    }

    public V get(K k){
        Node n = head;
        while (n.next != null){
            if(n.next.k.equals(k)){
                return n.next.v;
            }
            n = n.next;
        }
        return null;
    }
    
    public Set<K> keySet(){
        Set<K> set = new HashSet<>();
        Node n = head;
        while (n.next != null){
            n = n.next;
            set.add(n.k);
        }
        return set;
    }
}

测试：

    @Test
    public void test(){
        SymbolTable<Integer, String> table = new SymbolTable<>();
        table.put(1, "a");
        table.put(2, "b");
        table.put(3, "c");
        table.put(1, "d");

        System.out.println(table.get(1));
        System.out.println(table.remove(1));
        System.out.println(table.get(1));
    }

有序符号表

刚才实现的符号表，我们可以称之为无序符号表，因为在插入的时候，并没有考虑键值对的顺序，而在实际生活 中，有时候我们需要根据键的大小进行排序，插入数据时要考虑顺序，那么接下来我们就实现一下有序符号表。

public class SortedSymbolTable<K extends Comparable<K>, V> extends SymbolTable<K, V>{

    public void put(K k,V v){
        Node curr = head.next;
        Node pre = head;

        //找到新节点需要插入的位置
        while (curr != null && k.compareTo(curr.k) > 0){
            pre = curr;
            curr = curr.next;
        }

        if(curr != null && k.compareTo(curr.k) == 0){
            curr.v = v;
            return;
        }
        pre.next = new Node(k, v, curr);
        N++;
    }
}

测试：

    @Test
    public void test2(){
        SymbolTable<Integer, String> table  = new SortedSymbolTable<>();
        table.put(3, "a");
        table.put(1, "b");
        table.put(2, "c");
        table.put(1, "d");

        for (Integer i : table.keySet()) {
            System.out.println("k:v ===>"+i+":"+table.get(i));
        }
    }