剑指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;
    }
}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值