232.用栈实现队列
力扣题目链接
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：
实现 MyQueue 类：
void push(int x)将元素 x 推到队列的末尾int pop()从队列的开头移除并返回元素int peek()返回队列开头的元素boolean empty()如果队列为空，返回true；否则，返回false
说明：
- 你 只能 使用标准的栈操作 —— 也就是只有
push to top,peek/pop from top,size, 和is empty操作是合法的。 - 你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。
输入：
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]
解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false
解决思路
- 使用输入栈和输出栈。将数据存放到输入栈，再放到输出栈。
Java实现
class MyQueue {
Stack<Integer> inStack;
Stack<Integer> outStack;
public MyQueue() {
inStack = new Stack<>();
outStack = new Stack<>();
}
public void push(int x) {
inStack.push(x);
}
public int pop() {
if (outStack.isEmpty()) {
while (!inStack.isEmpty()) {
outStack.push(inStack.pop());
}
}
return outStack.pop();
}
public int peek() {
if (outStack.isEmpty()) {
while (!inStack.isEmpty()) {
outStack.push(inStack.pop());
}
}
return outStack.peek();
}
public boolean empty() {
return outStack.isEmpty() && inStack.isEmpty();
}
}
225. 用队列实现栈
力扣题目链接
请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。
实现 MyStack 类：
void push(int x)将元素 x 压入栈顶。int pop()移除并返回栈顶元素。int top()返回栈顶元素。boolean empty()如果栈是空的，返回true；否则，返回false。
解决思路
- 把新增的元素始终放在队列开头，队列添加元素默认是放在队列末尾的。
- 使用双队列，一个队列用作备份，一个队列用于获取元素。备份队列放入新元素，再放入旧元素，切换队列。
- 使用单队列，先把元素放在最后，再把以前存入的元素重新放入队列中。
java实现
使用两个队列
class MyStack {
private Queue<Integer> queue1;
private Queue<Integer> queue2;
public MyStack() {
queue1 = new LinkedList<>();
queue2 = new LinkedList<>();
}
public void push(int x) {
queue2.offer(x);
while (!queue1.isEmpty()) {
queue2.offer(queue1.poll());
}
Queue<Integer> tmp = queue1;
queue1 = queue2;
queue2 = tmp;
}
public int pop() {
return queue1.poll();
}
public int top() {
return queue1.peek();
}
public boolean empty() {
return queue1.isEmpty();
}
}
使用单队列
class MyStack {
Queue<Integer> queue;
/** Initialize your data structure here. */
public MyStack() {
queue = new LinkedList<Integer>();
}
/** Push element x onto stack. */
public void push(int x) {
int n = queue.size();
queue.offer(x);
for (int i = 0; i < n; i++) {
queue.offer(queue.poll());
}
}
/** Removes the element on top of the stack and returns that element. */
public int pop() {
return queue.poll();
}
/** Get the top element. */
public int top() {
return queue.peek();
}
/** Returns whether the stack is empty. */
public boolean empty() {
return queue.isEmpty();
}
}
20. 有效的括号
力扣题目链接
给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
- 左括号必须用相同类型的右括号闭合。
- 左括号必须以正确的顺序闭合。
- 每个右括号都有一个对应的相同类型的左括号。
输入：s = "()"
输出：true
解决思路
- 计算长度
- 使用
hashMap，匹配字符串。 - 左边的字符直接入栈，右边的字符需要判断栈是否为空或者栈顶元素是左边字符。
Java实现
class Solution_LC20 {
public boolean isValid(String s) {
if (s.length() % 2 == 1) {
return false;
}
Map<Character, Character> pairs = new HashMap<Character, Character>() {{
put(')', '(');
put(']', '[');
put('}', '{');
}};
Stack<Character> stack = new Stack<>();
for (int i = 0; i < s.length(); i++) {
if (pairs.containsKey(s.charAt(i))) {
if (stack.isEmpty() || pairs.get(s.charAt(i)) != stack.peek()) {
return false;
}
stack.pop();
} else {
stack.push(s.charAt(i));
}
}
if (stack.isEmpty()) {
return true;
}
return false;
}
}
1047. 删除字符串中的所有相邻重复项
力扣题目链接
给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。
在 S 上反复执行重复项删除操作，直到无法继续删除。
在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。
输入：tokens = ["2","1","+","3","*"]
输出：9
解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9
解决思路
- 使用栈，匹配字符相等，则消除。
Java实现
class Solution_LC1047 {
public String removeDuplicates(String s) {
Stack<Character> stack = new Stack<>();
for (int i = 0; i < s.length(); i++) {
char ch = s.charAt(i);
if (stack.isEmpty() || stack.peek() != ch) {
stack.push(ch);
} else {
stack.pop();
}
}
StringBuilder sb = new StringBuilder();
while (!stack.isEmpty()) {
sb.append(stack.pop());
}
return sb.reverse().toString();
}
}
150. 逆波兰表达式求值
力扣题目链接
给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。
请你计算该表达式。返回一个表示表达式值的整数。
注意：
- 有效的算符为
'+'、'-'、'*'和'/'。 - 每个操作数（运算对象）都可以是一个整数或者另一个表达式。
- 两个整数之间的除法总是 向零截断 。
- 表达式中不含除零运算。
- 输入是一个根据逆波兰表示法表示的算术表达式。
- 答案及所有中间计算结果可以用 32 位 整数表示。
解决思路
- 使用栈记录需要计算的字符。
Java实现
class Solution {
public int evalRPN(String[] tokens) {
Stack<Integer> stack = new Stack<>();
for (int i = 0; i < tokens.length; i++) {
if (tokens[i].equals("+")) {
stack.push(stack.pop() + stack.pop());
} else if (tokens[i].equals("-")) {
stack.push(-stack.pop() + stack.pop());
} else if (tokens[i].equals("*")) {
stack.push(stack.pop() * stack.pop());
} else if (tokens[i].equals("/")) {
int tmp = stack.pop();
stack.push(stack.pop() / tmp);
} else {
stack.push(Integer.valueOf(tokens[i]));
}
}
return stack.pop();
}
}
239. 滑动窗口最大值
力扣题目链接
给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。
返回 滑动窗口中的最大值
输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
输出：[3,3,5,5,6,7]
解释：
滑动窗口的位置 最大值
--------------- -----
[1 3 -1] -3 5 3 6 7 3
1 [3 -1 -3] 5 3 6 7 3
1 3 [-1 -3 5] 3 6 7 5
1 3 -1 [-3 5 3] 6 7 5
1 3 -1 -3 [5 3 6] 7 6
1 3 -1 -3 5 [3 6 7] 7
解决思路
- 使用优先队列。优先队列要明确左右两端。右端是索引i，左边是索引
i-k+1。 - 优先队列大顶端，比较元素大小。
new PriorityQueue<>((a, b) -> b[1] - a[1]); - 使用单调队列。一旦遇到比当前栈顶元素大的都弹出，小的都压进来。
- 使用双端队列。维护队列，保持队列元素在
[i - k + 1, i]范围内 - 双端队列，压入元素，将比自己小的元素推出，始终维持在范围内最大的元素在最前面。
Java实现
使用优先队列
class Solution {
public int[] maxSlidingWindow(int[] nums, int k) {
PriorityQueue<int[]> priorityQueue = new PriorityQueue<>((a, b) -> b[1] - a[1]);
int len = nums.length;
int m = len - k + 1;
int[] ans = new int[m];
for (int i = 0; i < len; i++) {
priorityQueue.offer(new int[]{i, nums[i]});
if (i >= k - 1) {
int left = i - k + 1;
while (priorityQueue.peek()[0] <= i - k) {
priorityQueue.poll();
}
ans[left] = priorityQueue.peek()[1];
}
}
return ans;
}
}
使用双端队列
class Solution {
public int[] maxSlidingWindow(int[] nums, int k) {
Deque<Integer> deque = new LinkedList<>();
int len = nums.length;
int[] res = new int[len - k + 1];
int idx = 0;
for (int i = 0; i < len; i++) {
if (!deque.isEmpty() && deque.peek() < i - k + 1) {
deque.poll();
}
while (!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
deque.pollLast();
}
deque.offer(i);
if (i >= k - 1) {
res[idx++] = nums[deque.peek()];
}
}
return res;
}
}
347.前 K 个高频元素
力扣题目链接
给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。
输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]
解决思路
- 计算数组中元素的个数
- 挨个将元素和元素个数加入到优先队列
- 挨个从优先队列中取出元素
Java实现
class Solution {
public int[] topKFrequent(int[] nums, int k) {
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
}
PriorityQueue<int[]> priorityQueue = new PriorityQueue<>((a, b) -> b[1] - a[1]);
for (Integer key : map.keySet()) {
priorityQueue.add(new int[]{key, map.get(key)});
}
int[] res = new int[k];
for (int i = 0; i < k; i++) {
res[i] = priorityQueue.poll()[0];
}
return res;
}
}
