算法通关村——栈和hash的经典算法

一、使用栈实现队列

import java.util.Deque;
import java.util.LinkedList;

public class MyQueue {
    private Deque<Integer> inStack;
    private Deque<Integer> outStack;

    public MyQueue(){
        inStack = new LinkedList<Integer>();
        outStack = new LinkedList<Integer>();
    }
    public void push(int val){
        inStack.push(val);
    }
    public int pop(){
        if (outStack.isEmpty()){
            inToout();
        }
        return outStack.pop();
    }

    public int peek(){
        if (outStack.isEmpty()){
            inToout();
        }
        return outStack.peek();
    }

    public boolean empty() {
        return inStack.isEmpty() && outStack.isEmpty();
    }

    private void inToout() {
        while (!inStack.isEmpty()){
            outStack.push(inStack.pop());
        }
    }
}

二、使用队列实现栈

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

public class MyStack2 {
    Queue<Integer> queue1;
    Queue<Integer> queue2;

    public MyStack2(){
        queue1 = new LinkedList<Integer>();
        queue2 = new LinkedList<Integer>();
    }

    public void push(int val){
        queue2.offer(val);
        while (!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();
    }

}

三、两数之和

        LeetCode1.给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target的那两个整数，并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案。

        我们可以通过两层循环来找出答案，但是这样的时间复杂度是O(n),我们可以通过hash表来将时间复杂度将至O（1）。

public int[] twoSum(int[] arr, int target){
        HashMap<Integer, Integer> hashMap = new HashMap<>();
        for (int i = 0; i < arr.length; i++) {
            if (hashMap.containsKey(target - arr[i])){
                return new int[]{hashMap.get(target - arr[i]),i};
            }
            hashMap.put(arr[i],i);
        }
        return new int[0];
    }

四、三数之和

如果将两个数换成二个会怎样呢? LeetCode15.给你一个包含n 个整数的数组 nums，判断nums 中是否存在三个元素 ab，c，使得 a + b + c = 0? 请你找出所有和为 0 且不重复的三元组。注意: 答案中不可以包含重复的三元组。

示例1:
输入: nums = [-1,,1,2,-1,-4]

输出: [[-1,-1,2],[-1,0,1]]

本题看似就是两数增加了一个数，但是难度增加了很多，我们可以使用三层循环直接找，时间复杂度为O(n^3)，太高了，放弃。也可以使用双层循环+Hash来实现，首先按照第一题两数之和的思路，我们可以固定一个数target，再利用两数之和的思想去map中存取或查找(-1)*target - numlj]，但是这样的问题是无法消除重复结果，例如如果输入[-1,0,1,2,-1,-4]，返回的结果是[[-1,1,0,[-1,-1,2,[0,1,-1],[0,-1,1],[1,-1,0],[2,-1,-1]]，如果我们再增加一个去重方法，将直接导致执行超时。
那这时候，我们就要想其他方法了，这个公认最好的方式是”排序+双指针“。我们可以先将数组排序来处理重复结果，然后还是固定一位元素，由于数组是排好序的，所以我们用双指针来不断寻找即可求解，代码如下:

/**
     * 目的是将数组中三个数的和为0，即在数组中的a + b + c = 0
     * @param arr 操作的数组
     * @return  符合要求的集合的集合
     */
    public List<List<Integer>> threeSum(int[] arr) {
        int len = arr.length;
        Arrays.sort(arr);
        List<List<Integer>> res = new ArrayList<>();
        for (int first = 0; first < len; first++) {
            //此次的a不可和上次的一样
            if (first > 0 && arr[first] == arr[first - 1])
                continue;
            int third = len - 1;
            int target = -arr[first];
            for (int second = first + 1; second < third; second++) {
                //此次的b不可和上次的一样
                if (second > first - 1 && arr[second] == arr[second - 1]) {
                    continue;
                }
                //我们需要b + c == target，可以更快的检索到需要的地方
                while (second < third && arr[second] + arr[third] > target) {
                    third--;
                }
                //如果b + c = target，这时候指针重合，那么就不可能存在a + b + c = 0
                // 因为这个时候b的下一个数肯定比b大，那么退出循环
                if (second == third)
                    break;
                if (arr[second] + arr[third] == target) {
                    List<Integer> list = new ArrayList<>();
                    list.add(first);
                    list.add(second);
                    list.add(third);
                    res.add(list);
                }
            }
        }
        return res;
    }