leetcode刷题随笔

两数之和：

unordered_map和map是有区别的

map的优点：（1）map是有序的（2）基于红黑树实现，查找的时间复杂度是O(n)
map的缺点：空间占用率比较高，因为内部实现了红黑树，虽然提高了运行效率，但是每个节点都要保存父亲节点和孩子节点和红黑树的性质，使得每一个节点都占用大量的空间。
适用的情况：对于要有序的结构，适用map
unordered_map的优点：因为内部是哈希表来实现的，所以查找效率会非常高。查找的时间复杂度是O(1)。
unordered_map的缺点：哈希表的建立比较费时
适用的情况：对于查找问题，适用unordered_map会更好一点。

两数相加

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

注意链表指针的使用方法

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode* ans=new ListNode(0);
        ListNode* te=ans;//它们指向同一个地址
        int flag=0;//进位标志
        int sum=0;//相加的和
        while(l1!=NULL||l2!=NULL)
        {
            if(l1!=NULL) sum+=l1->val,l1=l1?l1->next:NULL;
            if(l2!=NULL) sum+=l2->val,l2=l2?l2->next:NULL;
            if(flag) sum++;
            te->next=new ListNode(sum%10);
            flag=sum/10;
            te=te->next;
            sum=0;
        }
        if(flag) te->next=new ListNode(1);
        return ans->next;
    }
};

无重复字符的个数 

 

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度

用的是滑动窗口的方法：参考至这篇题解https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/solution/wu-zhong-fu-zi-fu-de-zui-chang-zi-chuan-cshi-xian-/

这是我用vector、unordered_map和map用时的区别；

vector<int> q(128,-1);

这个定义数组很牛啊，超级快，  这叫桶优化。

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        /*int maxlen=0;
        map<char,int> q;
        int len=s.size();
        for(int i=0,j=0;j<len;j++)
        {
            q[s[j]]++;
            while(q[s[j]]>1)
            {
                q[s[i]]--;
                i++;//左指针右移
            }
            if(j-i+1>maxlen)
            {
                maxlen=j-i+1;
            }

        }
        return maxlen;*/
     /*int ll=0,rr=0,maxlen=0;
    unordered_map<char,int> q;
    int len=s.size();
    for(int i=0;i<len;i++)
    {
        q[s[i]]=-1;
    }
    while(ll<=rr&&rr<len)
    {

        q[s[ll]]=ll;
        if(q[s[rr]]>=ll&&ll!=rr)//说明之前出现了
        {

            ll=q[s[rr]]+1;
        }
        q[s[rr]]=rr;
        if(rr-ll+1>maxlen)
        {
            maxlen=rr-ll+1;
        }
        rr++;

    }
    return maxlen;*/
    int ll=0,rr=0,maxlen=0;
    //map<char,int> q;
    //vector<int> q;
    vector<int> q(128,-1);
    int len=s.size();
    for(int i=0;i<len;i++)
    {
        char c=s[i];
        q[int(c)]=-1;
    }
    while(ll<=rr&&rr<len)
    {
        char sl=s[ll],sr=s[rr];

        q[int(sl)]=ll;
        if(q[int(sr)]>=ll&&ll!=rr)//说明之前出现了
        {

            ll=q[int(sr)]+1;
        }
        q[int(sr)]=rr;
        if(rr-ll+1>maxlen)
        {
            maxlen=rr-ll+1;
        }
        rr++;

    }
    return maxlen;
        
    }

};