栈与链表OJ习题

1. 有效的括号

import java.util.HashMap;
import java.util.Map;
import java.util.Stack;

public class Test {

//    给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效
//    有效字符串需满足：
//    左括号必须用相同类型的右括号闭合。
//    左括号必须以正确的顺序闭合。
//    注意空字符串可被认为是有效字符串。

        public boolean isValid(String s) {
           // 创建一个 Map， key 对应左括号， value 存放右括号， 可以根据 key 查找 value
            Map<Character, Character> map = new HashMap<>();
            map.put('(', ')');
            map.put('[', ']');
            map.put('{', '}');
            // 1. 先创建一个栈
            Stack<Character> stack = new Stack<>();
            // 2. 循环遍历字符串中的每个字符，如果是左括号，就进行入栈操作
            for (int i = 0; i < s.length(); i++) {
                char c = s.charAt(i);
                if (c == '(' || c == '[' || c == '{') {
                    stack.push(c);
                    continue;
                }
                // 如果此时不是左括号，且栈为空的话，直接返回
                if (stack.empty()) {
                    return false;
                }
                // 3. 判断 c 是否是右括号， 如果是右括号，就取出栈顶元素来对比一下
                char top = stack.pop();
                if(map.get(top) == c) {
                    continue;
                }
                return false;
            }
            if (stack.empty()) {
                return true;
            }
            return false;
        }
    }

2.用队列实现栈
使用队列实现栈的下列操作：

push(x) – 元素 x 入栈
pop() – 移除栈顶元素
top() – 获取栈顶元素
empty() – 返回栈是否为空

注意:

你只能使用队列的基本操作-- 也就是 push to back, peek/pop from front, size, 和 is empty 这些操作是合法的。
你所使用的语言也许不支持队列。 你可以使用 list 或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。
你可以假设所有操作都是有效的（例如, 对一个空的栈不会调用 pop 或者 top 操作）。

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class MyStackBy2Queue {
    // 栈原则是"后进先出"  队列是"先进先出"
    // 把元素移到另一个队列中, 直到只剩最后一个元素, 此时这个元素就是最后进来的元素
    private Queue<Integer> A = new LinkedList<>();
    private Queue<Integer> B = new LinkedList<>();

        // 入栈
        public void push(int x) {
            // x 直接往 A 中入队列即可
            A.offer(x);
        }

        // 移除栈顶元素
        public Integer pop() {
            if (empty()) {
                return null;
            }
            //  把 A 中的元素往 B 中倒腾
            while (A.size() > 1) {
                Integer front = A.poll();
                B.offer(front);
            }
            // 当循环结束后, A 中还剩一个元素
            // 这个元素就是应该被出栈的元素
            int ret = A.poll();
            // 交换 A 和 B
            swapAB();
            return ret;
        }

        private void swapAB() {
            Queue<Integer> tmp = A;
            A = B;
            B = tmp;
        }

        // 获取栈顶元素
        public Integer top() {
            if (empty()) {
                return null;
            }
            //  把 A 中的元素往 B 中倒腾
            while (A.size() > 1) {
                Integer front = A.poll();
                B.offer(front);
            }
            // 当循环结束后, A 中还剩一个元素
            // 这个元素就是应该被出栈的元素
            int ret = A.poll();
            // 交换 A 和 B 身份, 保证新入栈的元素始终是 A 入
            B.offer(ret); // 这句 是 pop 和 top 唯一的区别, 获取栈顶元素后要放回
            swapAB();
            return ret;
        }


        public boolean empty() {
            return A.isEmpty() && B.isEmpty();
        }
    }