LeetCode 1. La suma de dos números

哈希表实现插入查询
class Solution {
    
    
public:
    vector<int> twoSum(vector<int>& nums, int target) {
    
    
        unordered_map<int,int>heap;
        for(int i=0;i<nums.size();i++)
        {
    
    
            int r=target-nums[i];
            if(heap.count(r)) return{
    
    heap[r],i};
            heap[nums[i]]=i;
        }
        return {
    
    };
    }
};

LeetCode 2. Suma dos números

2. Suma dos números .
Simulación: $O (n)$
pensando: dummy es un nodo principal virtual, t representa un acarreo, mientras las listas enlazadas l1 y l2 no estén vacías o todavía haya un acarreo, el ciclo continuará.
Cada vez que t se agrega a los dígitos actuales de l1, l2, l1, l2, apunte al siguiente nodo.
Nota: El nodo principal virtual puede evitar discutir elcódigo C ++ delcaso límite
:

class Solution {
    
    
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
    
    
        auto dummy=new ListNode(-1),cur=dummy;
        int t=0;
        while(l1 || l2 || t)
        {
    
    
            if(l1) t+=l1->val,l1=l1->next;
            if(l2) t+=l2->val,l2=l2->next;
            cur->next=new ListNode(t%10);
            cur=cur->next;
            t/=10;
        }
        return dummy->next;
    }
};

LeetCode 3. La subcadena más larga sin caracteres repetidos

3. La subcadena más larga sin caracteres repetidos .
Algoritmo:
escaneo de doble puntero $O (n)$
idea: puntero doble + hash. La
tabla hash almacena el número de veces que cada carácter de la subcadena de este
bucle atraviesa cada vez, heap [s [i]] ++, lo que significa que en esta subcadena El número de apariciones del carácter en la cadena más 1, si s [i]> 1, significa que el carácter anterior en la subcadena es el mismo que el carácter recién agregado, y el puntero frontal j se mueve hacia atrás hasta la ocurrencia de s [i ] = 1 y la
última actualización El valor máximo puede ser
código C ++:

class Solution {
    
    
public:
    int lengthOfLongestSubstring(string s) {
    
    
        unordered_map<char,int>heap;
        int res=0;
        for(int i=0,j=0;i<s.size();i++)
        {
    
    
            heap[s[i]]++;
            while(heap[s[i]]>1) heap[s[j++]]--;
            res=max(res,i-j+1);
        }
        return res;
    }
};