【leetcode】字谜分组--未完成

问题描述：

给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。

示例:

输入: ["eat", "tea", "tan", "ate", "nat", "bat"],
输出:
[
  ["ate","eat","tea"],
  ["nat","tan"],
  ["bat"]
]

说明：

• 所有输入均为小写字母。
• 不考虑答案输出的顺序。

解题思路：

1、声明字符串数组变量key，用来存储result每行对应的排好序的字符串

2、遍历每个strs的每个字符串，与key中的每个字符串比较，看是否已经存在。如果存在，就直接添加到result的对应行中去；如果不存在，增加key中的元素，增加reusult的行，并增加该字符串。

3、该算法的时间复杂度最差应该是O（N×N），但是在最后一个测试用例执行超时，暂时未想到优化方法。

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *columnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
#include<string.h>

int getMaxLen(char **strs,int strsSize)
{
    if(strs==NULL || strsSize<1)
    {
        return 0;
    }
    int len=0,i=0;
    for(i=0;i<strsSize;i++)
    {
        len=strlen(strs[i])>len?strlen(strs[i]):len;
    }
    return len;
}

int cmp(const void* str1,const void *str2)
{
    return *(char*)str1-*(char*)str2;
}

int isGroupStrs(char *str1,char *str2)
{
    if(strlen(str1)!=strlen(str2))
    {
        return -1;
    }
    //qsort(str1,strlen(str1),sizeof(char),cmp);//str1已经排好序
    qsort(str2,strlen(str2),sizeof(char),cmp);
    return strcmp(str1,str2);
}

char*** groupAnagrams(char** strs, int strsSize, int** columnSizes, int* returnSize) {
    if(strs==NULL||strsSize<1)
    {
        return NULL;
    }
    int len=getMaxLen(strs,strsSize);
    char **key=(char **)malloc(sizeof(char*)*strsSize);//存储每个词排好序之后的词，比如tea-->aet，方便后续与其他词进行比较
        
    char ***result=(char ***)malloc(sizeof(char**)*strsSize);//strsSize×strsSize的数组
    *columnSizes=(int*)malloc(sizeof(int)*strsSize);//1×strsSize的数组
    (*columnSizes)[0]=0;//第0行的有多少个元素
    *returnSize=0;//一共有多少行
    
    //char *str1=(char*)malloc(sizeof(char)*len);//用于存储排序的第一个元素
    char *str2=(char*)malloc(sizeof(char)*len);//用于存储排序的第二个元素
    int i=0;
    for(i=0;i<strsSize;i++)
    {
        //printf("i=%d\n",i);
        int j=0,isFind=-1;
        for(j=0;j<*returnSize;j++)
        {
            //printf("j=%d\n",j);
            strcpy(str2,strs[i]);
            if(isGroupStrs(key[j],str2)==0)
            {
                int k=(*columnSizes)[j];
                result[j][k]=(char*)malloc(sizeof(char)*len);
                strcpy(result[j][k],strs[i]);
                ((*columnSizes)[j])++;
                isFind=1;
                break;
            }
        }
        if(isFind==-1)
        {
            key[*returnSize]=(char*)malloc(sizeof(char)*len);//给key的元素分配空间
            strcpy(key[*returnSize],strs[i]);
            qsort(key[*returnSize],strlen(key[*returnSize]),sizeof(char),cmp);
            result[*returnSize]=(char**)malloc(sizeof(char*)*strsSize);//返回二维数组增加1行
            result[*returnSize][0]=(char*)malloc(sizeof(char)*len);//给二维数组分配空间
            strcpy(result[*returnSize][0],strs[i]);
            //printf("result3:%s\n",result[*returnSize][0]);
            (*columnSizes)[*returnSize]=1;
            (*returnSize)++;
        }
    }
    
    return result;
}