day22_LC学习计划：数据结构基础

49.字母异位词分组

给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。

字母异位词 是由重新排列源单词的字母得到的一个新单词，所有源单词中的字母通常恰好只用一次。

示例 1:

输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
输出: [["bat"],["nat","tan"],["ate","eat","tea"]]
示例 2:

输入: strs = [""]
输出: [[""]]
示例 3:

输入: strs = ["a"]
输出: [["a"]]
 

提示：

1 <= strs.length <= 104
0 <= strs[i].length <= 100
strs[i] 仅包含小写字母

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/group-anagrams
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

#define MAXLENGTH 10000
struct hashTable {
    char keyStr[MAXLENGTH]; // key值为排序后的字符串
    int id; // 记录在res中的位置
    int count; // 记录分组中元素的个数
    UT_hash_handle hh;
};


int com(const void *a_, const void *b_){
    char *a = (char *)a_;
    char *b = (char *)b_;
    return *a - *b;
}

char *** groupAnagrams(char ** strs, int strsSize, int* returnSize, int** returnColumnSizes){
    if (strsSize == 0) return NULL;
    char ***res = (char ***)malloc(sizeof(char **) * strsSize);
    *returnColumnSizes = (int *)malloc(sizeof(int) * strsSize);
    *returnSize = 0;
    struct hashTable *hashtable = NULL;
    for(int i=0; i<strsSize; i++){
        int len = strlen(strs[i]);
        char tmp[len+1];
        memset(tmp, 0, sizeof(char) * (len+1));
        memcpy(tmp, strs[i], sizeof(char) * len);
        // qsort tmp
        qsort(tmp, len, sizeof(char), com);
        struct hashTable *tmpHash;
        HASH_FIND_STR(hashtable, tmp, tmpHash);
        if(tmpHash == NULL) {
            // HASH表中没有
            tmpHash = (struct hashTable *)malloc(sizeof(struct hashTable));
            memset(tmpHash->keyStr, 0, sizeof(char) * MAXLENGTH);
            memcpy(tmpHash->keyStr, tmp, sizeof(char) * len);
            tmpHash->id = *returnSize;
            tmpHash->count = 1;
            HASH_ADD_STR(hashtable, keyStr, tmpHash);
            
            res[*returnSize] = (char **)malloc(sizeof(char *) * strsSize);
            res[*returnSize][tmpHash->count-1] = (char *)malloc(sizeof(char) * (len + 1));
            
            memset(res[*returnSize][tmpHash->count-1], 0, sizeof(char) * (len + 1));
            memcpy(res[*returnSize][tmpHash->count-1], strs[i], sizeof(char) * len);
            (*returnColumnSizes)[*returnSize] = tmpHash->count;
            (*returnSize)++;
        }
        else {
            // HASH表中有记录
            res[tmpHash->id][tmpHash->count] = (char *)malloc(sizeof(char) * (len + 1));
            memset(res[tmpHash->id][tmpHash->count], 0, sizeof(char) * (len + 1));
            memcpy(res[tmpHash->id][tmpHash->count], strs[i], sizeof(char) * len);
            (*returnColumnSizes)[tmpHash->id] = tmpHash->count + 1;
            tmpHash->count = tmpHash->count + 1;

        }
    }

    return res;

}

43.字符串相乘

给定两个以字符串形式表示的非负整数 num1 和 num2，返回 num1 和 num2 的乘积，它们的乘积也表示为字符串形式。

注意：不能使用任何内置的 BigInteger 库或直接将输入转换为整数。

示例 1:

输入: num1 = "2", num2 = "3"
输出: "6"
示例 2:

输入: num1 = "123", num2 = "456"
输出: "56088"
 

提示：

1 <= num1.length, num2.length <= 200
num1 和 num2 只能由数字组成。
num1 和 num2 都不包含任何前导零，除了数字0本身。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/multiply-strings
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

 模拟竖式乘法。

char* addStrings(char* num1, char* num2){
    int i=strlen(num1)-1,j=strlen(num2)-1,add=0;
    char* ans=malloc(sizeof(char)*(i+j+5));
    int ansLen=0;
    while(i>=0||j>=0||add!=0){
        int x=i>=0?num1[i]-'0':0;
        int y=j>=0?num2[j]-'0':0;
        int result=x+y+add;
        ans[ansLen++]=result%10;
        add=result/10;
        i--;
        j--;
    }
    for(int i=0;i<ansLen/2;i++){
        char t=ans[i];
        ans[i]=ans[ansLen-i-1];
        ans[ansLen-i-1]=t;
    }
    for(int i=0;i<ansLen;i++){
        ans[i]+='0';
    }
    ans[ansLen++]=0;
    return ans;
}

char * multiply(char * num1, char * num2){
    int m=strlen(num1),n=strlen(num2);
    char* ans=malloc(sizeof(char)*2);
    ans[0]='0',ans[1]=0;
    if((m==1)&&(num1[0]=='0')||(n==1&&num2[0]=='0')) return ans;
    for(int i=n-1;i>=0;i--){
        char* curr=malloc(sizeof(char)*(m+n+5));
        int currLen=0;
        int add=0;
        for(int j=n-1;j>i;j--){
            curr[currLen++]=0;
        }
        int y=num2[i]-'0';
        for(int j=m-1;j>=0;j--){
            int x=num1[j]-'0';
            int product=x*y+add;
            curr[currLen++]=product%10;
            add=product/10;
        }
        while (add!=0) {
            curr[currLen++]=add%10;
            add/=10;
        }
        for(int i=0;i<currLen/2;i++){
            char t=curr[i];
            curr[i]=curr[currLen-i-1];
            curr[currLen-i-1]=t;         
        }
        for(int i=0;i<currLen;i++){
            curr[i]+='0';
        }
        curr[currLen++]=0;
        char* tmp=addStrings(ans,curr);
        free(curr),free(ans);
        ans=tmp;
    }
    return ans;
}

做乘法。核心是中间的数值用int数组来保存。

char * multiply(char * num1, char * num2){
    int m=strlen(num1),n=strlen(num2);
    char* ans=malloc(sizeof(char)*(m+n+3));
    memset(ans,0,sizeof(char)*(m+n+3));
    ans[0]='0',ans[1]=0;
    if((m==1&&num1[0]=='0')||(n==1&&num2[0]=='0')){
        return ans;
    }
    int* ansArr=malloc(sizeof(int)*(m+n+3));
    memset(ansArr,0,sizeof(int)*(m+n+3));
    for(int i=m-1;i>=0;i--){
        int x=num1[i]-'0';
        for(int j=n-1;j>=0;j--){
            int y=num2[j]-'0';
            ansArr[i+j+1]+=x*y;
            //这里应该是+=，因为可能在后续其他位的数字相乘的时候还会返回到数组的这个位置。
        }
    }
    for(int i=m+n+1;i>0;i--){
        ansArr[i-1]+=ansArr[i]/10;
        ansArr[i]=ansArr[i]%10;
    }
    int index=ansArr[0]==0?1:0;
    int arrLen=0;
    while(index<m+n){
        ans[arrLen++]=ansArr[index++];
    }
    for(int i=0;i<arrLen;i++) ans[i]+='0';
    return ans;
}

结语关于卷积后序有时间再看看。