前言
提示:昔日玫瑰一其名流芳 今日所持唯玫瑰之名 -- 翁贝利·埃柯
队列和Hash是基础的使用工具,在算法的应用非常广泛,比如广度优先等等,这些问题呢都是比较常见的,往后再说,这里我们看一些比较典型的队列或者Hash问题。
1. 使用栈实现队列
栈的特点是【先进后出】,队列的特点是【先进先出】。两个栈将底部拼接到一起就可以实现队列的所有功能,通过队列也能实现栈的功能。在很多地方能看到通过两个栈实现队列的问题,当然也有很多地方是两个队列实现栈的题目,我们这里就一次吧这个问题搞明白😁。
题目介绍参考:232. 用栈实现队列 - 力扣(LeetCode)
这个题目来说,思路很简答,就是一个栈当作输入,用于压入push传入的数据;另一个栈当作输出栈,用来pop和peek操作。
每次pop或者peek的时候,如果输出栈为空则将输入栈的全部元素一次弹出并压入输出栈,这样输出栈从栈顶到栈低的顺序就是队列首部到尾部的顺序。
那么就代码展示:
import java.util.Stack;
class MyQueue {
private Stack<Integer> inStack;
private Stack<Integer> outStack;
public MyQueue() {
inStack = new Stack<Integer>();
outStack = new Stack<Integer>();
}
public void push(int x) {
inStack.push(x);
}
public int pop() {
if (outStack.isEmpty()) {
inOutStack();
}
return outStack.pop();
}
public int peek() {
if (outStack.isEmpty()) {
inOutStack();
}
return outStack.peek();
}
public boolean empty() {
return inStack.isEmpty() && outStack.isEmpty();
}
private void inOutStack() {
while (!inStack.isEmpty()) {
outStack.push(inStack.pop());
}
}
}
2. 使用队列实现栈
参考题目介绍:225. 用队列实现栈 - 力扣(LeetCode)
思路:这个问题首先我们想到的是使用两个队列来时先栈,为了班组栈的特性,即最后入栈的元素最先出栈,在使用队列·实现栈的时候,应该满足队列的前端的元素是最后入栈的元素。可以使用两个队列实现栈的操作,其中queue1,用于存储栈内的元素,queue2作为入栈操作作为辅助队列。
入栈操作时,首先将元素入队到queue2,然后将queue1的全部元素一次出队并入队到queue2,此时queue2的前端元素就是新入栈的元素,再将queue1和queue2互换,则queue1的元素即为栈内的元素,queue1的前端和后端分别对应栈顶和栈底。
由于每次入栈操作都要确保queue1的前端元素为栈顶元素,因此出栈操作和获得栈顶元素的操作都很简单实现。出栈操作只要移除queue1的前端元素并返回即可,获取栈顶元素操作只需要获取queue1的前端元素并返回即可(不需要移除元素)
最后,queue1用于存储栈内元素,判断是否为空时,只需要判断queue1是否为空即可。
说了这么多,写代码展示💕:
import java.util.LinkedList;
import java.util.Queue;
class MyStack {
private Queue<Integer> queue1;
private Queue<Integer> queue2;
public MyStack() {
queue1 = new LinkedList<Integer>();
queue2 = new LinkedList<Integer>();
}
public void push(int x) {
queue2.offer(x);
if (!queue1.isEmpty()){
queue2.offer(queue1.poll());
}
Queue<Integer> temp = queue1;
queue1 = queue2;
queue2 = temp;
}
public int pop() {
return queue1.poll();
}
public int top() {
return queue1.peek();
}
public boolean empty() {
return queue1.isEmpty();
}
}
3. n数之和问题
很多人刷算法的第一道题目就是:求两数之和的问题,事实上除了这个问题意外还有几个类似的问题,什么三数之和,四数相加I和四数相加II等等,这里我们就看看下面这些问题;
3.1 两数之和
参考题目介绍:1. 两数之和 - 力扣(LeetCode)
提供两种常见的解法:
- 两次for循环
- hash表解决
两次for循环:
这个题目使用for就是暴力解决,我们一次确定一个数,只要满足条件就可以返回,代码展示如下:
public static int[] twoSum(int[] nums, int target) {
int n = nums.length;
for(int i = 0; i < n; i++){
for(int j = i + 1; j < n; j++){
if (nums[i] + nums[j] == target){
return new int[]{i,j};
}
}
}
return new int[0];
}
Hash表解决
上述方法不足在于寻找target - x 的时间复杂度过高,我们可以使用Hash表,可以将寻找target - x 的时间复杂度降低到从O(n)至O(1)。这样的话我们就需要创建一个哈希表,对于每个x,我们首先要查询哈希表中是否存在target - x,然后将x插入到哈希表中,即可以保证不会让自己(x)匹配;
代码写起来也很简单:
public static int[] twoSum(int[] nums, int target) {
int n = nums.length;
HashMap<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < n; i++) {
if (map.containsKey(target - nums[i])) {
return new int[]{map.get(target - nums[i]), i};
}
map.put(nums[i],i);
}
return new int[0];
}
当然使用Hash还是比较简单的,时间复杂度降低了,但是空间复杂度提高了,那么试想一下有没有其他的方法呢?这个还真不多,不过我们可以对原始数组(有序)进一步做优化,然后采用两层循环的方法,外层让然是一个个的遍历,内层可以换成二分,这样的话复杂度可以从O(n^2)降低到O(nlogn)。有兴趣的话可以尝试一下哟🤣。
3.2 三数之和
参考题目简介:15. 三数之和 - 力扣(LeetCode)
我们来看这个题, 突然增加了一个数,看似简单实则增加了很大难度,我们当然可以算则三次循环嵌套直接找,这样的话时间复杂度太高了O(n^3),直接放弃。
我们尝试采用双层循环 + Hash来实现,首先结合上面的思路,固定一个target,再利用Hash去查找或取出(-1)*target - num[j],但是这样的话没办法消除重复结果,比如[-1,0,1,2,-1,-4],返回结果时[[-1,1,0],[-1,-1,2],[0,-1,1],[1,-1,0],[2,-1,-1]],如果再加一个去重的话,那就要超时了。
这个时候,我们就要想其他办法,公认的最好方式“排序 + 双指针”。我们可以先将数组排序处理重复结果,然后固定以为元素,由于数组是排好序的,所以我们可以使用双指针不断的寻找即可求解,代码实现如下:
public static List<List<Integer>> threeSum(int[] nums) {
int n = nums.length;
Arrays.sort(nums);
List<List<Integer>> ans = new ArrayList<List<Integer>>();
// 最外层循环 a
for (int first = 0; first < n; first++) {
// 不和上一次相同
if (first > 0 && nums[first] == nums[first - 1]) {
continue;
}
// 内层双指针 c
int third = n - 1;
int target = -nums[first];
// 第二层循环
for (int second = first + 1;second < n; second++){
// 与上次不同
if(second > first + 1 && nums[second] == nums[second -1]){
continue;
}
// 内层双指针 确保 c 在b 的右边
while(second < third && nums[second] + nums[third] > target){
--third;
}
// 当然如果 指针重合了 b++
// 就不会有满足 a + b + c = 0,并且 b < c 可以停止循环
if (second == third){
break;
}
if (nums[second] + nums[third] == target){
List<Integer> list = new ArrayList<Integer>();
list.add(nums[first]);
list.add(nums[second]);
list.add(nums[third]);
ans.add(list);
}
}
}
return ans;
}
拓展:
如果你感兴趣,可以进一步的探索,如果再加一个数呢?
推荐例题:18. 四数之和 - 力扣(LeetCode)、454. 四数相加 II - 力扣(LeetCode)
总结
`提示:重点掌握栈和队列的转换,Hash的使用。