剑指offer刷题记录--栈&队列||堆||哈希表

栈与队列

刷题

题目	解法	题解
用两个栈实现队列	双栈	辅助栈
包含min函数的栈	辅助栈(Deque LinkedList)	辅助栈
栈的压入、弹出序列	贪心法（辅助栈）	贪心法
翻转单词顺序	双指针；分割+倒序	两种
滑动窗口的最大值	暴力；双端队列（单调）；动态规划	三种

用两个栈实现队列

解法	时间复杂度	空间复杂度
辅助栈	O(1)	O(n)

class CQueue {

    Deque<Integer> stackin;
    Deque<Integer> stackout;

    public CQueue() {
        stackin=new LinkedList<>();
        stackout=new LinkedList<>();
    }
    
    public void appendTail(int value) {
        stackin.offerLast(value);
    }
    
    public int deleteHead() {
        if(!stackout.isEmpty()) return stackout.pollLast();
        if(stackin.isEmpty()) return -1;
        while(!stackin.isEmpty()){
            stackout.offerLast(stackin.pollLast());
        }
        return stackout.pollLast();
        // return stackout.isEmpty()?-1:stackout.pollLast();//可以
    }
}

包含min函数的栈||最小栈

解法	时间复杂度	空间复杂度
辅助栈	O(1)	O(n)

class MinStack {
    //正常存放顺序存入的栈
    Deque<Integer> stack;
    //存放最小值的栈
    //先进后出，保持栈顶保持为最小
    Deque<Integer> minstack;
    /** initialize your data structure here. */
    public MinStack() {
        stack=new LinkedList<>();
        minstack=new LinkedList<>();
    }
    //
    public void push(int x) {
        stack.offerLast(x);
        //这里小于和等于最小栈顶元素的 都要加入栈
        if(minstack.isEmpty()||x<=minstack.peekLast()){
            minstack.offerLast(x);
        }     
    } 
    public void pop() {
        int poped=0;
        if(!stack.isEmpty()){
            poped=stack.pollLast();
        }
        //出栈时，还需要判断是否走的最小值(最小栈顶元素)
        //最小值走了就要更新最小值====出栈
        if(!minstack.isEmpty()&&poped==minstack.peekLast()){
            minstack.pollLast();
        }
    } 
    public int top() {
        return stack.peekLast();   
    }
    public int getMin() {    
        return minstack.peekLast();      
    }
}

栈的压入、弹出序列||验证栈序列

解法	时间复杂度	空间复杂度
贪心法(栈)	O(n)	O(n)

class Solution {
    public boolean validateStackSequences(int[] pushed, int[] popped) {
        //实现栈
        Deque<Integer> stack=new ArrayDeque<>();
        int popIndex=0;
        for(int i=0;i<pushed.length;i++){
            stack.offerLast(pushed[i]);
            //注意此处为循环
            //pushed12345
            //popped43521 
            //前两个：4被判断可出栈后，紧接着需要判断新栈顶3是否需要出栈
            while(!stack.isEmpty()&&stack.peekLast()==popped[popIndex]){
                stack.pollLast();
                popIndex++;
            }
        }
        //如果按照popped顺序可以正常出栈，则全部清空
        return stack.isEmpty();
    }
}

翻转单词顺序列||翻转字符串里的单词

解法	时间复杂度	空间复杂度
双指针	O(n)	O(n)
分割+倒序	O(n)	O(n)

//分割+倒序
class Solution {
    public String reverseWords(String s) {
        if(s==null) return s;
        String[] arr=s.trim().split(" ");// 删除首尾空格，分割字符串
        StringBuilder sb=new StringBuilder();
        //倒序添加 实现翻转
        for(int i=arr.length-1;i>=0;i--){
            //特殊：空字符 不处理 转向一个
            if(arr[i].equals("")) continue;
            sb.append(arr[i]);
            sb.append(" ");   
        }
        return sb.toString().trim();// 转化为字符串，删除尾部空格，并返回
    }
}

滑动窗口的最大值||滑动窗口最大值

双端队列和普通队列最大的不同在于，它允许我们在队列的头尾两端都能在 O(1) 的时间内进行数据的查看、添加和删除。

与队列相似，我们可以利用一个双链表实现双端队列。双端队列最常用的地方就是实现一个长度动态变化的窗口或者连续区间，而动态窗口这种数据结构在很多题目里都有运用。

解法	时间复杂度	空间复杂度
暴力	O(nk)	O(n-k+1)
双端队列	O(n)	O(n)
动态规划	O(n)	O(n)

//暴力
class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums.length==0||k==0) return new int[0];
        int[] res=new int[nums.length-k+1];
        //nums[0]-nums[k-1]
        //nums[1]-nums[k]
        //....
        //i=nums.length-k
        for(int i=0;i<=nums.length-k;i++){
            int max=Integer.MIN_VALUE;
            for(int j=i;j<k+i;j++){
                max=Math.max(max,nums[j]);
            }
            res[i]=max;
        }
        return res;
    }
}

//双端队列 单调
class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums==null||nums.length==0||k==0) return new int[0];
        int[] res=new int[nums.length-k+1];
        Deque<Integer> deque=new LinkedList<>();
        int index=0;
        //维持队列头部为最大值的下标
        for(int i=0;i<nums.length;i++){
            //添加之前，判断已有元素是否小于当前元素,小于出队列
            while(!deque.isEmpty()&&nums[i]>=nums[deque.peekLast()]){
                deque.pollLast();
            }
            //添加当前元素
            deque.offerLast(i);//存下标
            //添加之后，考虑：队列是否满了
            if(i-deque.peekFirst()==k){
                deque.pollFirst();
            }
            //队列刚满：记录队列头部==最大值
            if(i>=k-1){//主要是从第一次满开始 连续记录
                res[index++]=nums[deque.peekFirst()];
            }
        }
        return res;
    }
}

哈希表

题目	解法	题解
第一个只出现一次的字符	无序哈希表；有序哈希表	辅助栈

第一个只出现一次的字符

解法	时间复杂度	空间复杂度
哈希表	O(n)	O(n)

此处可以考虑第二个value存储布尔型代表是否出现一次，避免每次次数计算

public class 第一个只出现一次的字符 {

    public static void main(String[] args) {
        System.out.println(firstUniqChar("leetcode"));
    }
//    @Test
    public static char firstUniqChar(String s) {
    	//无序哈希
        HashMap<Character,Integer> map=new HashMap<>();
        //有序哈希 遍历map时根据插入顺序
        //HashMap<Character,Integer> map=new LinkedHashMap<>();
        char[] arr=s.toCharArray();
        for(int i=0;i<arr.length;i++){
            if(map.containsKey(arr[i])){
                map.put(arr[i],map.get(arr[i])+1);
            }
            else{
                map.put(arr[i],1);
            }
        }
        //有序哈希 直接遍历map可以
//        for(Map.Entry<Character,Integer> t:map.entrySet()){
//            char m= (char) t.getKey();
//            int n= (int) t.getValue();
//            if(n==1) return m;
//        }
		//无序哈希：不能遍历map来获取第一个；通过遍历数组来按顺序
        for(char c:arr){
            if(map.get(c)==1) return c;
        }
        return ' ';
    }
}

堆

题目	解法	题解
最小的K个数	快排；大顶堆；BST	四种

最小的K个数

TopK问题

• 对于经典TopK问题，本文给出 4 种通用解决方案。

  解题思路：

• 用快排最最最高效解决 TopK 问题

• 大根堆(前 K 小) / 小根堆（前 K 大),Java中有现成的PriorityQueue，实现起来最简单

• 二叉搜索树也可以解决 TopK 问题

• 数据范围有限时直接计数排序就行了

解法	时间复杂度	空间复杂度
快排	O(n)	O(logn)
堆（ PriorityQueue（默认小根堆））	O(n)	O(n)
哈希表	O(nlogk)	O(k)

//快排
class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        if(k==0) return new int[0];
        if(arr==null||arr.length<=k) return arr;
        select(arr,0,arr.length-1,k);
        int[] res=new int[k];
        // int[] res=Arrays.copyOf(arr,k);
        for(int i=0;i<k;i++){
            res[i]=arr[i];
        }
        return res;
    }

    public void select(int[] nums, int low, int high,int k){
        int pivot=partiton(nums,low,high);
        if(pivot==k) return;
        else if(pivot>k){
            select(nums,low,pivot-1,k);
        }else{
            select(nums,pivot+1,high,k);
        }
    }

    public int partiton(int[] nums, int low, int high) {
        int key=nums[low];
        int i=low,j=high+1;
        while(true){
            while((nums[++i]<key)&&i<high);
            while((key<nums[--j])&&j>low);
            //退出循环条件
            if(i>=j) break;
            swap(nums,i,j);
        }
        swap(nums,j,low);
        return j;
    }

    public void swap(int[] nums,int i,int j){
        int tmp=nums[i];
        nums[i]=nums[j];
        nums[j]=tmp;
    }
}

//大顶堆
// 保持堆的大小为K，然后遍历数组中的数字，遍历的时候做如下判断：
// 1. 若目前堆的大小小于K，将当前数字放入堆中。
// 2. 否则判断当前数字与大根堆堆顶元素的大小关系，如果当前数字比大根堆堆顶还大，这个数就直接跳过；
//    反之如果当前数字比大根堆堆顶小，先poll掉堆顶，再将该数字放入堆中。
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> list=new ArrayList<>();
        if(input==null||input.length==0||k==0||k>input.length) return list;
        //构建大顶堆
        // 默认是小根堆，实现大根堆需要重写一下比较器。
        Queue<Integer> heap=new PriorityQueue<>(k,(v1, v2)->Integer.compare(v2,v1));
        for(int e:input){
            if(heap.isEmpty()||heap.size()<k||e<heap.peek()){
                heap.offer(e);
            }
            if(heap.size()>k){
                heap.poll();
            }
        }
        list.addAll(heap);
        return list;
        //wrong return (ArrayList<Integer>) heap;
    }
}