面试手撕优化

LRU 缓存

/*
    每次get一个key有两种情况，要么链表里面没有这个key那么可以直接返回-1，
    如果链表里面有这个key，我们需要把查到的这个节点给移到链表头部，
    对于put操作，我们直接通过调用get返回结果：
    如果返回不是-1，说明链表里面已有key，那么我们的get函数会给他排到链表前面去。
    如果返回-1，说明链表里面没有key，那么我们需要插入这个key，分两种情况:
    如果容量满了，就删除最后一个节点再把新的key加进来作为链表头结点
    否则直接加入当前的key到链表头结点
*/
class LRUCache {
public:
    int cap;
    list<int>st;//使用C++自带的双向链表list
    unordered_map<int,list<int>::iterator>mp;//key需要映射到链表元素的迭代器
    unordered_map<int,int>mp1;//保存key-value键值对，方便查询元素value
    LRUCache(int capacity) {
        cap=capacity;
    }
    int get(int key) {
        if(mp.count(key)){
            auto it=mp[key];
            //splice(const_iterator pos, list& other, const_iterator it)表示把结点it移到other链表的pos位置之前
            st.splice(st.begin(),st,it);
            return mp1[key];
        }
        else return -1;
    }
    void put(int key, int value) {
        if(get(key)!=-1){  
            mp1[key]=value;
        }
        else{
            if(mp.size()==cap){ //如果容量满了，就删除最后一个再把新的key加进来作为链表头结点
                int x=st.back();
                mp.erase(x);
                st.pop_back();
                st.push_front(key);
                mp1[key]=value;
                auto it=st.begin();
                mp[key]=it;
            }
            else{  //否则直接加入当前的key到链表头结点
                st.push_front(key);
                mp1[key]=value;
                auto it=st.begin();
                mp[key]=it;
            }
        }
    }
};

LFU 缓存

class LFUCache {
public:
    int cap;
    unordered_map<int,list<int>>mp;//key的使用频率-双向链表
    unordered_map<int,list<int>::iterator>mp1;//key-链表结点迭代器
    unordered_map<int,int>mp2;//key-key的使用频率
    unordered_map<int,int>mp3;//存key-value键值对,最终答案
    LFUCache(int capacity) {
        cap=capacity;
    }
    int id=0;//记录最小的频率
    int get(int key) {
        if(mp2.find(key)==mp2.end()) return -1;//key不存在于任何一个链表中返回-1
        int x=mp2[key];//先获取原先的频率
        mp[x].erase(mp1[key]);//随即x的所属链表删除对应结点
        mp1.erase(key);//删除对应迭代器
        if(id==x&&mp[x].empty()) id++;//如果当前最小频率等于原先频率且x所属链表已经为空,更新最小频率
        if(mp.find(x+1)!=mp.end()) mp[x+1].push_front(key);//如果x+1频率已经有链表了则直接插入到链表头
        else mp[x+1]={key};//否则映射到构建新的链表
        mp1[key]=mp[x+1].begin();//更新key到迭代器的映射
        mp2[key]++;//频率肯定要增加1
        return mp3[key];//返回答案
    }
    void put(int key, int value) {
        if(get(key)==-1){//如果key不存在
            if(mp2.size()==cap){//容量已满
                int x=mp[id].back();// 取出最小频率所属链表的尾节点，删掉
                mp1.erase(x);
                mp2.erase(x);
                mp3.erase(x);
                mp[id].pop_back();
                id=1;// 最小频率置为1
                if(mp.find(1)!=mp.end()) mp[1].push_front(key);//如果前面删掉后链表不为空
                else mp[1]={key};//如果前面删掉后链表为空，创建新链表
                mp1[key]=mp[1].begin();//更新key到迭代器的映射
            }
            else{//容量未满
                id=1;// 最小频率置为1
                if(mp.find(1)!=mp.end()) mp[1].push_front(key);//如果链表不为空，插入到链表头
                else mp[1]={key};//否则创建新链表
                mp1[key]=mp[1].begin();//更新key到迭代器的映射
            }
            mp2[key]=1;//key对应的频率置为1
        }
        mp3[key]=value;//最后更新key-value
    }
};

删除链表的倒数第 N 个结点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode *p = head, *q = head, *pre = head;
        if (!p->next) {
            delete(head);
            head = nullptr;
            return head;
        }
        int cnt = 0;
        while (q) {
            if (cnt < n) {
                cnt++;
                q = q->next;
            }
            else {
                q = q->next;
                pre = p;
                p = p->next;
            }
        }
        if (pre == p) {
            p = p->next;
            delete(head);
            head = p;
            return head;
        }
        pre->next = p->next;
        delete(p);
        return head;
    }
};

K 个一组翻转链表

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode *p=head;
        if(k==1||p->next==NULL)return p;
        ListNode *pre=NULL;
        ListNode *tail=NULL;
        ListNode *prehead=NULL;
        ListNode *ans;  
        int n=0;
        while(p){
            n++;
            p=p->next;
        }
        int h=0;
        p=head;
        ListNode *nowhead=NULL;
        while(p){
            h++;
            if(h%k==1){
                nowhead=p;
                if(h>=(n-n%k)&&(n%k!=0)){
                    prehead->next=nowhead;
                    break;
                }
            }
            if(h%k==0){
                tail=p;
                if(h==k)ans=p;
                if(h>k){
                    prehead->next=tail;
                }
                prehead=nowhead;
                
            }
            ListNode *q=p->next;
            p->next=pre;
            pre=p;
            p=q;
            if(h==n){
                nowhead->next=NULL;
                break;
            }
        }
        return ans;
    }
};

合并 K 个升序链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
struct node{
    int val;
    ListNode *pt;
    bool operator <(const node&t)const{
        return val>t.val;
    }
};
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        ListNode *head=new ListNode(0,NULL);
        ListNode *pre=head;
        priority_queue<node>q;
        for(auto p:lists){
            if(p)q.push(node{p->val,p});
        }
        while(!q.empty()){
            node now=q.top();
            pre->next=now.pt;
            q.pop();
            if(now.pt->next)q.push(node{now.pt->next->val,now.pt->next});
            pre=now.pt;
        }
        return head->next;
    }
};

寻找两个正序数组的中位数

class Solution {
public:
    //这个函数用于寻找两个有序数组合并后的第 k 个最小元素
    int getk(vector<int>& nums1, vector<int>& nums2, int k) {
        int n = nums1.size(); // 数组 nums1 的长度
        int m = nums2.size(); // 数组 nums2 的长度
        int id1 = 0, id2 = 0; // id1, id2 分别是数组 nums1 和 nums2 的当前索引位置
        while (true) {
            if (id1 == n) return nums2[id2 + k - 1]; // 如果 nums1 已经全部考虑完毕，直接从 nums2 中取第 k 个元素
            if (id2 == m) return nums1[id1 + k - 1]; // 如果 nums2 已经全部考虑完毕，直接从 nums1 中取第 k 个元素
            if (k == 1) return min(nums1[id1], nums2[id2]); // 如果 k 为1，返回两个数组当前元素的最小值
            // 计算新的搜索区间
            int nid1 = min(id1 + k / 2 - 1, n - 1); // 在 nums1 中向前搜索 k/2 个元素的位置
            int nid2 = min(id2 + k / 2 - 1, m - 1); // 在 nums2 中向前搜索 k/2 个元素的位置
            int x = nums1[nid1];
            int y = nums2[nid2];
            if (x <= y) {
                k -= (nid1 - id1 + 1); // 减少 k 的值，移动 nums1 的索引
                id1 = nid1 + 1;
            } else {
                k -= (nid2 - id2 + 1); // 减少 k 的值，移动 nums2 的索引
                id2 = nid2 + 1;
            }
        }
    }
    //计算两个有序数组的中位数
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int n = nums1.size(); // 数组 nums1 的长度
        int m = nums2.size(); // 数组 nums2 的长度
        // 如果两数组长度之和为奇数，直接返回中间的元素
        if ((n + m) % 2) return getk(nums1, nums2, (n + m + 1) / 2); 
        // 如果为偶数，返回中间两个元素的平均值
        else return (getk(nums1, nums2, (n + m) / 2) + getk(nums1, nums2, (n + m) / 2 + 1)) / 2.0; 
    }
};

无重复字符串的排列组合

// 经典的递归回溯的解法：就是按照每一个index递增，然后和所有后续位置交换
// 优化： 预先按照输入长度n得到数量，避免vector的resize的性能损耗
class Solution {
private:
    int resIndex = 0;
    void dfs(int index, string& S, int n, vector<string>& res){
        if (index == n-1){
            res[resIndex] = S;
            ++resIndex;
            return;
        }
        for (int i = index; i < n; ++i){
            // 交换
            swap(S[i], S[index]);
            dfs(index+1, S, n, res);
            // 回溯需要修改会去
            swap(S[i], S[index]);
        }
    }
    int getSize(int n){
        return n == 1 ? 1 : n*getSize(n-1);
    }
public:
    vector<string> permutation(string S) {
        int n = S.size();
        // 预先分配好空间
        vector<string> res(getSize(n));
        dfs(0, S, n, res);
        return res;
    }
};

 

用队列实现栈

class MyStack {
public:
    queue<int> q1, q2;
    MyStack() {}
    void push(int x) {
        q2.push(x);
        while (!q1.empty()) {
            q2.push(q1.front());
            q1.pop(); 
        }
        swap(q1,q2);
    }
    int pop() {
        if(!q1.empty()) {
            int x = q1.front();
            q1.pop();
            return x;
        }
        return -1; 
    }
    int top() {
        if (q1.empty()) return -1;
        return q1.front();
    }
    bool empty() {
        return q1.empty();
    }
};

用队列实现栈

class MyStack {
public:
    MyStack() {
    }
    queue<int>q1, q2;
    bool empty(){
        if (q1.empty()) return true;
        return false;
    }
    int top(){
        if (q1.empty()) return -1;
        if(q1.size() == 1) {
            return q1.front();
        }
        while (!q2.empty()) q2.pop();
        while (q1.size() > 1) {
            q2.push(q1.front());
            q1.pop();
        }
        return q1.front();
    }
    int pop(){
        int res = top();
        if (res == -1) return -1;
        q1.pop();
        swap(q1, q2);
        return res;
    }
    void push(int x){
        q1.push(x);
    }
};

 

验证IP地址

class Solution {
public:
    int check(string sp){
        int n=sp.size();
        if(n<1||n>4)return 0;
        for(auto c:sp){
            if(!isdigit(c))return 0;
        }
        int x=stoi(sp);
        if(x<0||x>255)return 0;
        if(sp[0]=='0'&&sp.length()>1)return 0;
        return 1;
    }  
    int ipv4(string s){
        if(s[s.size()-1]=='.')return 0;
        stringstream ss(s);
        string sp;
        vector<string>v;
        while(getline(ss,sp,'.')){
            v.push_back(sp);
        }
        if(v.size()!=4)return 0;
        for(auto sp:v){
            if(!check(sp))return 0;
        }
        return 1;
    }
    int check1(string sp){
        int n=sp.size();
        if(n<1||n>4)return 0;
        for(auto c:sp){
            if(!isdigit(c)&&!((c>='a'&&c<='f')||(c>='A'&&c<='F')))return 0;
        }
        return 1;
    }  
    int ipv6(string s){
        if(s[s.size()-1]==':')return 0;
        stringstream ss(s);
        string sp;
        vector<string>v;
        int x=0;
        while(getline(ss,sp,':')){
            x++;
            if(x>8)return 0;
            v.push_back(sp);
        }
        if(v.size()!=8)return 0;
        for(auto sp:v){
            if(!check1(sp))return 0;
        }
        return 1;
    }
    string validIPAddress(string queryIP) {
        if(queryIP.size()==0)return "Neither";
        if(ipv4(queryIP))return "IPv4";
        else if(ipv6(queryIP))return "IPv6";
        else return"Neither";
    }
};

轮转数组

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        k %= nums.size(); // 轮转 k 次等于轮转 k%n 次
        ranges::reverse(nums);
        reverse(nums.begin(), nums.begin() + k);
        reverse(nums.begin() + k, nums.end());
    }
};

 

最大子数组和

//dp思想，如果加上当前位置的数后累计的和变为负数，则当前位置以及之前的所有元素都可以丢弃
class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int n=nums.size();
        int ans=-1e9,res=0,mx=-1e9;
        for(int i=0;i<n;i++){
            mx=max(mx,nums[i]);
            res+=nums[i];
            if(res>0){
                ans=max(ans,res);
                continue;
            }
            else res=0;
        }
        if(mx<=0)ans=mx;
        return ans;
    }
};

最长公共子序列

// 遍历text1，在text1和text2中寻找以text1[i]为末尾元素的最长公共子序列，
// 如果text2[j] != text1[i]，dp[j]等于text2中以text2[j]为末尾元素的子序列和text1的子串 text1[0]~text1[i - 1] 的最长公共子序列的长度；
// 如果text2[j] == text1[i]，dp[j]等于text1的子串 text1[0]~text1[i - 1] 和text2的子串 text2[0]~text2[j - 1]的最长公共子序列的长度再加1。
// 即dp[j] = max(dp[k]) + 1, k∈[0,j), 且dp[k]为上一轮循环的结果，而不是本轮循环更新过的值。
class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        vector<int> dp(text2.size(), 0);
        for (int i = 0; i < text1.size(); ++i) {
            int maxlen = 0;
            for (int j = 0; j < text2.size(); ++j) {
                int newlen = max(maxlen, dp[j]);
                if (text1[i] == text2[j]) {
                    dp[j] = maxlen + 1;
                }
                maxlen = newlen;
            }
        }
        return *max_element(dp.cbegin(), dp.cend());
    }
};

最长递增子序列

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n=nums.size();
        vector<int>d(n,1);
        int ans=1;
        for(int i=0;i<n;i++){
            for(int j=0;j<i;j++){
                if(nums[i]>nums[j]){
                    d[i]=max(d[i],d[j]+1);
                    ans=max(ans,d[i]);
                }
            }
        }
        return ans;
    }
};

最长回文子串

//d[i][j]表示区间[i,j]如果满足回文子串的话，长度是多少
class Solution {
public:
    string longestPalindrome(string s) {
        int n=s.size();
        vector<vector<int>>d(n,vector<int>(n,0));
        for(int i=0;i<n;i++) d[i][i]=1;
        int l=0,ans=1;
        for(int i=n-1;i>=0;i--){
            for(int j=i+1;j<n;j++){
                if(j==i+1&&s[i]==s[j]){
                    d[i][j]=2;
                    if(ans<2){
                        ans=2;
                        l=i;
                    }
                }
                else if(s[i]==s[j]&&(d[i+1][j-1]||i==j-2)){
                    d[i][j]=d[i+1][j-1]+2;
                    if(d[i][j]>ans){
                        ans=d[i][j];
                        l=i;
                    }
                }
            }
        }
        return s.substr(l,ans);
    }
};

 

正则表达式匹配

//d[i][j] 表示 s 的前 i 个字符与 p 中的前 j 个字符是否能够匹配
class Solution {
public:
    bool isMatch(string s, string p) {
        int n = s.size();
        int m = p.size();
        vector<vector<int>> d(n+1,vector<int>(m+1,0));
        d[0][0] = true;
        for(int i=1;i<=m;i++){
            if(i<m&&p[i-1]!='*'&&p[i]!='*')break;
            if(i==m-1&&p[i]!='*')break;
            d[0][i]=1;
        }
        for(int i=1;i<=n;i++){
            char pre='A';
            for(int j=1;j<=m;j++){
                if(p[j-1]!='*')pre=p[j-1];
                if(p[j-1]=='*'){
                    if(pre=='.'){
                        d[i][j]=d[i-1][j]|d[i][j-1];
                        if(j>=2)d[i][j]=d[i][j]|d[i][j-2];
                        d[i-1][j]=d[i-1][j-2]|d[i-1][j];
                    }
                    else{
                        if(pre==s[i-1]){
                            d[i][j]=d[i-1][j]|d[i][j-1];
                            d[i][j]=d[i][j]|d[i][j-2];
                        }
                        else{
                            d[i-1][j]=d[i-1][j-2]|d[i-1][j];
                            d[i][j]=d[i][j-2];
                        }
                    }
                }
                else if(p[j-1]=='.'||p[j-1]==s[i-1]){
                    d[i][j]=d[i-1][j-1];
                }
            }
        }
        return d[n][m];
    }
};

通配符匹配（包括*和?）

class Solution {
public:
    bool isMatch(string s, string p) {
        int n=s.size();
        int m=p.size();
        vector<vector<int>>d(n+1,vector<int>(m+1));
        d[0][0]=true;//d[i][j]表示s的前i个和p的前j个能否匹配
        for(int i=1;i<=m;i++){
            if(p[i-1]!='*')break;
            d[0][i]=true;
        }
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                if(p[j-1]!='*'){
                    if(p[j-1]=='?'||s[i-1]==p[j-1])d[i][j]=d[i-1][j-1];
                }
                else d[i][j]=d[i-1][j]|d[i][j-1];
            }
        }
        return d[n][m];
    }
};

多线程

实现一个固定容量的阻塞队列，用生产者消费者测试。

package com.venux.train.common.util;

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 一个具有固定大小的阻塞队列，支持线程安全的操作。
 * 它允许在不发生死锁的情况下添加和移除元素。
 *
 * @param <T> 队列中元素的类型
 */
public class FixedSizeBlockingQueue<T> {
    private final int capacity;// 队列容量
    private final Queue<T> queue;// 底层的队列
    private final ReentrantLock lock;// 用于同步的锁
    private final Condition notFull;// 队列不满的条件变量，用于阻塞等待队列不满，以便添加元素
    private final Condition notEmpty;// 队列不空的条件变量，用于阻塞等待队列不空，以便移除元素
    private volatile boolean isClosed = false; // 用于标记队列是否已关闭

    // 构造函数，初始化队列的容量，以及相关的锁和条件变量
    public FixedSizeBlockingQueue(int capacity) {
        this.capacity = capacity;
        this.queue = new LinkedList<>();
        this.lock = new ReentrantLock();
        this.notFull = lock.newCondition();
        this.notEmpty = lock.newCondition();
    }
    // 将元素放入队列，如果队列已满，则阻塞当前线程，直到队列不满或者队列被关闭
    public void put(T item) throws InterruptedException {
        lock.lock();
        try {
            while (queue.size() == capacity || isClosed) { // 检查队列是否已满或已关闭
                if (isClosed) {
                    throw new IllegalStateException("Queue is closed");
                }
                notFull.await();
            }
            queue.add(item);
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }
    // 从队列中取出一个元素，如果队列为空，则阻塞当前线程，直到队列不空或者队列被关闭
    public T take() throws InterruptedException {
        lock.lock();
        try {
            while (queue.isEmpty()) {
                notEmpty.await();
            }
            T item = queue.poll();
            notFull.signal();
            return item;
        } finally {
            lock.unlock();
        }
    }
    // 返回队列中当前元素的数量
    public int size() {
        lock.lock();
        try {
            return queue.size();
        } finally {
            lock.unlock();
        }
    }
    // 关闭队列，不再接受新的元素
    public void close() {
        lock.lock();
        try {
            isClosed = true; // 设置关闭标志
            // 可选：唤醒所有等待的put线程
            notFull.signalAll();
        } finally {
            lock.unlock();
        }
    }
    public static void main(String[] args) {
        FixedSizeBlockingQueue<Integer> queue = new FixedSizeBlockingQueue<>(5);
        Thread producer = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    queue.put(i);
                    System.out.println("Produced: " + i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread consumer = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    int item = queue.take();
                    System.out.println("Consumed: " + item);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        producer.start();
        consumer.start();
        try {
            producer.join();
            consumer.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Queue size: " + queue.size());
        queue.close();
        System.out.println("Queue closed.");
    }
}

生产者消费者多线程实现， 使用了Java包的BlockingQueue作为阻塞队列。

import java.util.concurrent.ArrayBlockingQueue;  
import java.util.concurrent.BlockingQueue;  
  
public class ProducerConsumerExample {  
  
    // 创建一个BlockingQueue，容量为10  
    private static final BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);  
  
    // 生产者线程  
    static class Producer implements Runnable {  
        public void run() {  
            int value = 0;  
            while (true) {  
                try {  
                    // 生产数据  
                    Thread.sleep(1000); // 模拟耗时操作  
                    value++;  
                    System.out.println("生产者生产了：" + value);  
  
                    // 将生产的数据放入队列  
                    queue.put(value);  
  
                } catch (InterruptedException e) {  
                    Thread.currentThread().interrupt();  
                }  
            }  
        }  
    }  
  
    // 消费者线程  
    static class Consumer implements Runnable {  
        public void run() {  
            while (true) {  
                try {  
                    // 从队列中取出数据  
                    Integer value = queue.take();  
                    System.out.println("消费者消费了：" + value);  
  
                    // 假设消费者处理数据也需要一些时间  
                    Thread.sleep(500);  
  
                } catch (InterruptedException e) {  
                    Thread.currentThread().interrupt();  
                }  
            }  
        }  
    }  
  
    public static void main(String[] args) {  
        // 创建并启动生产者线程  
        Thread producerThread = new Thread(new Producer());  
        producerThread.start();  
  
        // 创建并启动消费者线程  
        Thread consumerThread = new Thread(new Consumer());  
        consumerThread.start();  
    }  
}