自用笔记13——二级指针和二维数组/溢出问题

char * longestCommonPrefix(char ** strs, int strsSize){
    if(strsSize==0)
        return "";
    int i=0,j=0,k=0,t=0;
    int *num=malloc(sizeof(int)*(strsSize-1));
    memset(num,0,(strsSize-1));
    char *com=malloc(sizeof(char)*200);
    memset(com,0,200);
    if(strsSize==1)
    {
        com[0]=strs[0][0];
        return com;
    }
    for(i=1;i<strsSize;i++)
    {
        for(j=0;strs[0][j]!='\0' && strs[i][j]!='\0';j++)
        {
            if(strs[0][j]!=strs[i][j])
                break;
        }       
        num[i-1]=j;
    }    
    if(strsSize>2)
    {
        for(i=strsSize-2;i>0;i--)
        {
            if(num[i]<num[i-1])
            {
                t=num[i];
                num[i]=num[i-1];
                num[i-1]=t;
            }
        }
    }
    if(num[0]==0)
        return "";
    else
    {
        for(i=0;i<num[0];i++)
        {
            com[i]=strs[0][i];
        }
        return com;
    }
}

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 “”。

示例 1:

输入: [“flower”,“flow”,“flight”]
输出: “fl”
示例 2:

输入: [“dog”,“racecar”,“car”]
输出: “”
解释: 输入不存在公共前缀。
说明:

所有输入只包含小写字母 a-z 。

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

C语言的二级指针和二维数组：
二级指针有两种：
①一级指针数组，就是指向一维数组（定长指针）的指针，指向的是只含有len个元素的这样的指针（即含有len个元素的数组），分配空间时直接分配 n个len长度的数组空间即可。

int len=init();
int (*p)[len];
p=(int(*)[len])malloc(n*len*sizeof(int));

②普通二级指针，就是指向一维指针（不定长指针 ）的数组，指向的一级指针尚未分配内存空间，所以当分配内存空间时，应分布分配，第一，给二级指针分配它的长度为len的一级指针（即一个含有len个元素的指针数组）第二，给这len个一级指针分配内存空间。

int **a;
a=(int**)malloc(sizeof(int*)*len);
for(i=0;i<len;i++)
	a[i]=(int*)malloc(sizeof(int)*n);

即当已知一维的长度时，可以直接调用数组指针（指针）来指向该长度的指针，分配内存时就可以一次性全部分配。
当不知道一维的长度时，就必须先分配一个指针数组（数组），而后再为数组中的每一个一级指针来分配他们所需要的空间大小。

二维数组实际上是一个（一级指针数组），其中的每一项都是一个一级指针，是一个数组的首地址

溢出问题：
目前发现有三种可能：①代码中的循环溢出，如for(i=0;i<Size;i++){s=str[i+1];}就会造成溢出；
②声明的数组/指针未初始化造成溢出char *com=malloc(sizeof(char)*200); memset(com,0,200);如果缺少第二步的将所有项初始化为0的操作，其中的值就会未知，代码运行时就会造成溢出；
③上一种可能中如果数组/指针在分配内存时大小不够，如只分配100个char大小，在题目给的某些初始值下可能就会溢出。

这道题可以优化为向数组strs[0][j]处插入’\0’，就可以达到找出最短前缀的目的：

char * longestCommonPrefix(char ** strs, int strsSize){
    if(strsSize == 0)
        return "";
    char *ans = strs[0];
    int i, j;
    for(i = 1; i < strsSize; i++){
        j = 0;
        for(; ans[j] != '\0' && strs[i][j] != '\0'; j++){
            if(ans[j] != strs[i][j]){
                break;
            }
        }
        ans[j] = '\0';
        if(ans == NULL){
            return "";
        }
    }
    return ans;

}