算法通关村第五关---队列和Hash

算法通关村第五关—队列和Hash

1.LeetCode 232. 用栈实现队列

题目地址：LeetCode

解题思路：

1. 加入队尾 push() ： 将数字 val 加入栈 A 即可
2. 获取队首元素 peek() ：

​ a. 当栈 B 不为空： B中仍有已完成倒序的元素，因此直接返回 B 的栈顶元素
​ b. 否则，当 A 为空： 即两个栈都为空，无元素，因此返回 -1
​ c. 否则： 将栈 A 元素全部转移至栈 B 中，实现元素倒序，并返回栈 B 的栈顶元素

3. **弹出队首元素** `pop()` ：
	   a. 执行 `peek() `，获取队首元素
       b. 弹出 `B` 的栈顶元素
4. **队列判空** `empty()` ： 当栈` A` 和 `B` 都为空时，队列为空

/**
 * 用栈实现队列
 *
 * @author Enndfp
 */
public class MyQueue {
    
    private Stack<Integer> A;
    private Stack<Integer> B;

    public MyQueue() {
        A = new Stack<>();
        B = new Stack<>();
    }

    public void push(int x) {
        A.push(x);
    }

    public int pop() {
        int peek = peek();
        B.pop();
        return peek;
    }

    public int peek() {
        if (!B.isEmpty()) return B.peek();
        if (A.isEmpty()) return -1;
        while (!A.isEmpty()) {
            B.push(A.pop());
        }
        return B.peek();
    }

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

2.LeetCode 225. 用队列实现栈

题目地址：LeetCode

解题思路：

1. 入栈操作时，首先将元素入队到 queue2

2. 将 queue1的全部元素依次出队并入队到 queue2，此时queue2的前端元素即为新入栈的元素

3. 再将queue1和queue2交换，此时 queue1的元素即为栈内的元素，queue1 的前端和后端分别对应栈顶和栈底

4. 由于queue1用于存储栈内元素，判空时只需判断queue1是否为空即可

/**
 * 用队列实现栈
 *
 * @author Enndfp
 */
public class MyStack {

    Queue<Integer> queue1;
    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 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.LeetCode 1. 两数之和

题目地址：LeetCode

解题思路：

• 遍历数组 nums，i 为当前下标，每个值都判断map中是否存在 target-nums[i] 的 key 值
• 如果存在则找到了两个值，如果不存在则将当前的 (nums[i],i) 存入 map 中，继续遍历直到找到为止

/**
 * 两数之和
 *
 * @author Enndfp
 */
public class TwoSum {
    /**
     * HashMap
     *
     * @param nums
     * @param target
     * @return
     */
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();

        for (int i = 0; i < nums.length; 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];
    }
}

4.LeetCode 15. 三数之和

题目地址：LeetCode

解题思路：

• 首先对数组进行排序，排序后固定一个数 nums[i]，再使用左右指针指向 nums[i]后面的两端，数字分别为nums[L]和nums[R]，计算三个数的和sum判断是否满足为 0，满足则添加进结果集
• 如果 nums[i]大于 0，则三数之和必然无法等于0，结束循环
• 如果nums[i] == nums[i-1]，则说明该数字重复，会导致结果重复，所以应该跳过
• 当sum == 0时，nums[L] == nums[L+1]则会导致结果重复，应该跳过，L++
• 当sum == 0时，nums[R] == nums[R-1]则会导致结果重复，应该跳过，R--

/**
     * 排序 + 双指针
     *
     * @param nums
     * @return
     */
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> ans = new ArrayList();
        int len = nums.length;
        if (nums == null || len < 3) return ans;
        Arrays.sort(nums); // 排序
        for (int i = 0; i < len; i++) {
            if (nums[i] > 0) break; // 如果当前数字大于0，则三数之和一定大于0，所以结束循环
            if (i > 0 && nums[i] == nums[i - 1]) continue; // 去重
            int L = i + 1;
            int R = len - 1;
            while (L < R) {
                int sum = nums[i] + nums[L] + nums[R];
                if (sum == 0) {
                    ans.add(Arrays.asList(nums[i], nums[L], nums[R]));
                    while (L < R && nums[L] == nums[L + 1]) L++; // 去重
                    while (L < R && nums[R] == nums[R - 1]) R--; // 去重
                    L++;
                    R--;
                } else if (sum < 0) L++;
                else if (sum > 0) R--;
            }
        }
        return ans;
    }