2021-5-19删除链表倒数第k个节点/大数加法/最长公共字串

主题：

学习记录，包括：

• 算法题：删除链表倒数第k个节点
• 算法题：大数加法
• 算法题：最长公共子串

内容：

1 删除链表倒数第k个节点
问题描述：
给定一个链表，删除链表的倒数第 nn 个节点并返回链表的头指针
例如，给出的链表为: 1→2→3→4→5, n=2.
删除了链表的倒数第 nn 个节点之后,链表变为1→2→3→5.
注意事项：
删除一个链表元素的要求是找到这个元素的前一个元素，因此，需要使用两个指针，一前一后，这样，前面指针到达位置时，后面的指针就在其前一个元素。如果是双向链表的话，就不需要这莫做。
注意特殊情况，就是需要删除的元素为头节点的情况，也就是先行指针，跳完之后，直接变成NULL的情况。
代码：

ListNode* removeNthFromEnd(ListNode* head, int n) {
        // write code here
        if(head==NULL)
            return head;
        ListNode* f = head;
        ListNode* b = head;
        ListNode* temp = head;
        for(int i=0;i<n;i++)  //这个地方不可以跳n+1次，不然就可能会发生错误。因此，b会指向要去掉的那个元素
        {
            f = f->next;
        }
        while(f!=NULL)
        {
            f = f->next;
            temp = b;  //正是因为删除一个元素，必须要知道这个元素前面的指针，因此用temp来做b的跟屁虫
            b = b->next;
        }
        if(temp==head && b==head)//这是一个特殊情况，说明倒数第n个元素是头节点，temp没有意义
        {
            head = head->next;
        }
        else{
            temp->next = temp->next->next;
        }
        return head;

2 大数加法
题目描述
以字符串的形式读入两个数字，编写一个函数计算它们的和，以字符串形式返回。
（字符串长度不大于100000，保证字符串仅由’0’~'9’这10种字符组成）
思路：没办法用string转化为整数，整数又转化为string的方法。因为string可能非常长，转变为
整数的话，太大了，会溢出，而且复杂度太大了。应该采用模拟的方法。
从最后向前面加，就像是列式子计算一样的方法。设置两个指针和一个carry，表示进位
代码：

string solve(string s, string t) {
        // write code here
        /*  这种方式不行，1 因为数字太大的时候会发生问题 2 算法复杂度太大
        int num1 = str_to_num(s);
        int num2 = str_to_num(t);
        return num_to_str(num1+num2);
        */
        char ss[100000];
        int i = s.size()-1;
        int j = t.size()-1;
        int carry = 0;
        int index = 0;
        while(i>=0||j>=0||carry != 0)
        {
            int x = i<0?0:s[i--]-'0';
            int y = j<0?0:t[j--]-'0';
            int sum = x+y+carry;
            ss[index++] = sum%10+'0';
            carry = sum/10;
        }
        ss[index] = '\0';
        string res(ss);
        reverse(res.begin(), res.end());
        return res;
    }
    int str_to_num(string s)
    {
        vector<int> res;
        for(int i=0;i<s.size();i++)
        {
            res.push_back(s[i]-48);
        }
        int base = 1;
        int num = 0;
        for(int i = res.size()-1;i>=0;i--)
        {
            num += base*res[i];
            base*=10;
        }
        return num;
    }
    
    string num_to_str(int num)
    {
        if(num == 0)
        {
            return "0";
        }
        char s[100000];
        int index = 0;
        while(num != 0)
        {
            s[index] = '0'+num%10;
            num = num/10;
            index++;
        }
        string res(s);
        reverse(res.begin(),res.end());
        return res;
    }

3 最长公共子串
问题描述：
给定两个字符串str1和str2,输出两个字符串的最长公共子串
题目保证str1和str2的最长公共子串存在且唯一。
思路：
用一个dp[str1.size()][str2.size()]来表示状态。dp[i][j]表示的是str1的第i
个字符和str2的第j个字符是是不是一样的，如果不一样的话，表示1.如果一样的话，表示
的应该是按照这种映射规则，前面还有几个相同的字符。构建的时候，需要先构建矩阵的第一行和
第一列。因为其他的值其实以来dp[i-1][j-1]。
代码：

string LCS(string str1, string str2) {
        // write code here
        
        int len1 = str1.size();
        int len2 = str2.size();
        
        
        int dp[len1][len2];
        memset(dp, 0, sizeof(dp));
        int max = 0;
        int maxi = 0;
        int flag = 0;
        for(int i=0;i<len1;i++)
        {
            if(str2[0] == str1[i])
            {
                dp[i][0] = 1;
                flag = 1;
            }
            else{
                dp[i][0] = 0;
            }
        }
        for(int i=0;i<len2;i++)
        {
            if(str1[0] == str2[i])
            {
                dp[0][i] = 1;
                flag = 1;
            }
            else{
                dp[0][i] = 0; //nmd
            }
        }
        
        
        if(len1<=1 || len2<=1)
        {
            if(flag == 1)
            {
                return len1>1?str2:str1;
            }
            else{
                return "";
            }
        }
        
        for(int i=1;i<len1;i++)
        {
            for(int j=1;j<len2;j++)
            {
                if(str1[i] == str2[j])
                {
                    dp[i][j] = dp[i-1][j-1]+1;
                }
                else{
                    dp[i][j] = 0;
                }
                
                if(dp[i][j]>max)
                {
                    max = dp[i][j];
                    maxi = i;
                }
            }
        }
        return  str1.substr(maxi+1-max, max);
    }