leetcode -14. Longest Common Prefix


问题描述: Write a function to find the longest common prefix string amongst an array of strings.

分析:
题目要求为寻找一组字符串的最长相同前缀,如{“abcd”,”abdf”,”abf”},三个字符串前两位“ab”相同,最长前缀位ab。
解体思路:最长相同前缀一定小于等于最短字符串的长度,故先找到最短字符串,并以此作为被比较对象,若查找某位上字符串与被比较字符串不相同,则比较结束,被比较字符串该位前的字符即为该字符串组的最长相同前缀。
此题需要考虑两种特殊情况:
(1)字符串组为空。此时直接返回“”即可。
(2)字符串组只有一个字符串。这种情况下,最长相同前缀即为该字符串本身。

代码:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

char* longestCommonPrefix(char** strs, int strsSize);
int main()
{
    char * strs[] = { "abc""abd" };
    int strsize = sizeof(strs) / sizeof(char *);
    printf("strsize=%d\n", strsize);
    char *CommonPrefix;
    //char **str = &strs[0];
    int i=0; 
    for ( i = 0; i < strsize;i++)
    {
        printf("strsize[%d]=%d\n",i, strlen(strs[i]));
        printf("strs[%d]=%s\n", i, strs[i]);

    }

    CommonPrefix=longestCommonPrefix(strs,strsize);
    printf("longestCommonPrefix=%s\n",CommonPrefix);
    system("pause");
    return 0;
}

char* longestCommonPrefix(char** strs, int strsSize) {
    if (strs == NULL || *strs == NULL) {
        return "";
    }
    if (strsSize==1)
        return *strs;
    int i,j,x=0;
    int minprefix=strlen(strs[0]);  //strs 为二级指针也就是,指针的指针。其实质是一个指针数组,即元素均为指针的数组,数组的数组名表示数组首个元素的地址,而首个元素又是指针,因此指针数组的数组名就是一个二级指针。
    char temp;
    char *result;

    for(i=1;i<strsSize;i++)   //查找最短字符串,并记录其长度
    {
        if(minprefix>strlen(strs[i]))
        {   minprefix=strlen(strs[i]);  
            x=i;
        }
    }

    for (j=0;j<minprefix;j++)   //以最短字符串长度为比较位数上限
    { 
        temp=*(strs[x]+j);      //将最短字符串最为基准
        for(i=0;i<strsSize;i++)
        {

            if(*(strs[i]+j)!=temp)  //若找到有一位字符不相同,则比较结束
                break;              
        }
        if(i!=strsSize)  //各字符串中至少有两个相应位不同,结束循环
            break;
    }

    if(j>=0)           
    {
        result = (char* ) malloc(sizeof(char) *(j+1));
        strncpy(result,strs[x],j+1);          //将相同的前j位返回
        result[j]='\0';

    }

    return result;
}
char* longestCommonPrefix(char** strs, int strsSize) {
    if (strs == NULL || *strs == NULL) {
        return "";
    }
    int len = strlen(strs[0]);
    int max = 0;
    char *res;
    while (max < len) {
        for (int i = 1; i < strsSize; i++) {
            if (strs[i][max] != strs[0][max])    //逐位比较,直到找到不同位
            {        
                len = max;
                break;
            }
        }
        if (max < len) max++;      //发现不同位
    }
    res = (char*)malloc(sizeof(char)*(max+1));
    for (int i = 0; i < max; i++)           //将相同的前max位返回
    {
        res[i] = strs[0][i];
    }
    res[max] = '\0';
    return res;
}

二级指针与二维数组


char *string[] ={"abc","abcd","acf"};
char string[3][4]={"abc","abcd","acf"};

首先一点的是,虽然二维数组的数组名可以看做是一个指针,但是并不能将二维数组的数组名赋值给一个二级指针,也就是如下的代码

int main(void)
{
    int arr[3][3] = {{1,2,3},{4,5,6},{7,8,9}};
    int **p = arr;
    return 0;
}

上面的代码在执行的时候会报错,这是因为两者数据类型是不相同的,所以不能赋值。
二维数组的数组名指向的是一维数组,也就是指向数组类型,但是二级指针指向的是一级指针,也就是指针类型,所以两者不能互相赋值。

下面详细介绍指针与二维数组的关系
声明一个二维数组

int a[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};
for (i=0;i<3;i++)
    {   for(j=0;j<4;j++)
        printf("%p ->%d\n",&arr[i][j],arr[i][j]);
    }
000000000062FE10 ->1
000000000062FE14 ->2
000000000062FE18 ->3
000000000062FE1C ->4
000000000062FE20 ->5
000000000062FE24 ->6
000000000062FE28 ->7
000000000062FE2C ->8
000000000062FE30 ->9
000000000062FE34 ->10
000000000062FE38 ->11
000000000062FE3C ->12

二维数组a可以看成是由a[0],a1,a[2]三个元素组成的一维数组,a是其数组名;a[0],a1,a[2]又都是一维数组,其数组名分别是a[0],a1,a[2],a[0],a1,a[2]分别表示各自数组的首个元素的地址。

arr[0]=000000000062FE00 ->1
arr[1]=000000000062FE10 ->5
arr[2]=000000000062FE20 ->9

由于数组名就是指针,故a[0],a1,a[2]为一级指针,其类型为int。a是由三个一级指针组成的数组。

那么a与a[0],a+1与a[0]+1的区别是什么?

a+1跨过了二维数组的一行,故a,a+1和a+2为行地址。
相对于a[0]而言,a[0]+1只跨过了二维数组的一个元素,故为列地址。
由此可以看出:
(1)a+i是第i行的地址,即*(a+i)=a[i]。因此a[i][j]等价于(*(a+i))[j];
(2)a[i]+j是第i行第j列的地址,因此*(a[i]+j)等价与a[i][j]。

上述等价关系总结如下:

a[i][j] ←→ (*(a+i))[j] ←→ *(a[i]+j) ←→ *(*(a+i)+j)

要想理解指针和二维数组之间的关系,就要首先弄清楚各种数组名所代表的元素。
数组名表示的是该数组首个元素的地址,即arr=&arr[0][0];

二维数组在内存中也是以一维数组的形式存储,只不过每个的一维数组的元素都是一维数组,因此二维数组名,可以将它看做是指向行数组的指针
对于二维数组的存储,是按照先行后列的形式排列的,把每一行看做是一个一位数组,那二维数组就是由多个一位数组组成的数组,即二维数组是数组的数组。

对于二维数组名,可以将它看做是指向行数组的指针,也就是说二维数组的元素是行数组,所以对于二维数组加减的变化是以行数组的大小为单位的,即arr指向arr[0]这个行数组,arr+1指向的是arr1这个行数组。对其进行解引用,得到的是每一行数组的首地址,即arr表示的是第0行数组的首地址,和arr[0]相等,(arr+1)表示的是第1行数组的首地址,和arr1是相等的。假如要取第1行第2个元素的地址,就是arr1+2,因为此时arr1代表的是一维数组,所以它的元素就是一个数字,在加减的时候移动的就是元素的大小,例如+1就表示该数组中第1个元素,+3就表示数组中的3个元素(以0开始)。因为
(arr+1)和arr1相等,所以第1行第2个元素的地址也可以表示为(arr+1)+2,对这个地址进行解引用,得到的就是数组元素的具体值,也就是((arr+1)+2)。
所以有如下公式,假如一个二维数组每行有N个元素,二维数组名是arr,那第i行第j个元素的地址是*(arr+i)+j,也可以表示为arr[i]+j。元素的值可以表示为*(*(arr+i)+j),或者可以表示为arr[i][j]。

对上述二维数组arr,虽然arr[0]、arr都是数组首地址,但二者指向的对象不同,arr[0]是一维数组的名字,它指向的是arr[0]数组的首元素,其值为arr[0]首个元素的地址,对其进行“*”运算,得到的是一个数组元素值,即arr[0]数组首元素值(本例arr[0]数组的首个元素值为1),因此,*arr[0]与arr[0][0]是同一个值。

而arr(可以看作arr+0)是一个二维数组的名字,它指向的是它所属元素的首元素,而二维数组的每一个元素都是一个维数组,因此arr指向二维数组arr的首个元素arr[0],对其进行*运算得到的是arr[0]的地址,而要想得到arr[0][0]的值,需要再进行一次*运算。

*arr=&arr[0];
**arr=*(&arr[0])=arr[0][0]
printf("arr=%p ->%d\n",arr,**arr); //两次解应用得到arr[0][0]
printf("*arr=%p->%d\n",*arr,**arr) ;
printf("arr[0]=%p ->%d\n",arr[0],*(arr[0]));   //arr[0][0]地址

printf("%p\n",&arr[0][0]); 
printf("%p\n",&arr[0]);
printf("%p\n",*(arr+2)+3);                     //&arr[2][3]
printf("%p\n",arr[2]+3);               
printf("%p ->%d\n",*(arr+2)+3,*(*(arr+2)+3));
printf("%p ->%d\n",&arr[2][3],arr[2][3]);
arr=000000000062FE00 ->1
*arr=000000000062FE00->1
arr[0]=000000000062FE00 ->1

000000000062FE00
000000000062FE00
000000000062FE2C
000000000062FE2C
000000000062FE2C ->12
000000000062FE2C ->12

因此,数组名最为指针时移动单位的是“行”,所以arr+i指向的是第i个行数组,即指向arr[i]。对arr进行“*”运算,得到的是一维数组arr[0]的首地址,即\arr与arr[0]是同一个值但指向类型不同通过(arr+1与arr[0]+1即能看出其不同)。当用int*p;定义指针p时,p的指向是一个int型数据,对其进行加减操作,移动的是一个int型大小,而不是一个地址,因此,用arr[0]对p赋值是正确的,而用arr对p赋值是错误的。
使用数组指针对二级指针操作
而int (*ptr)[4],ptr表示一个指向5个int型数组的指针,对其进行加减操作,该变量为数组大小乘以数据类型大小。即ptr+1=&ptr+4*sizeof(int);
因而,int (*ptr)[4]可以使用arr来初始化,因为ptr是一个指向包含4个int型元素的数据,而arr指向其首个元素的地址,其首个元素又是一个包含4个int型数据的数据。

int (*ptr)[4]=arr;                              //  行地址
printf("arr=%p->%d\n",&arr[0][0],arr[0][0]);    //首元素地址
printf("ptr=%p->%d\n",ptr,**ptr);     
printf("ptr+1=%p->%d\n",ptr+1,**(ptr+1));       //行地址加一移动4个int型大小
printf("*(ptr+1)+1=%p->%d\n",*(ptr+1)+1,*(*(ptr+1)+1));  //
运行结果:
arr=000000000062FE00->1
ptr=000000000062FE00->1
ptr+1=000000000062FE10->5
*(ptr+1)+1=000000000062FE14->6

完整程序:

#include<stdio.h>

int main()
{
 int i,j=0;
    int arr[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};
    //分别使用不同的形式打印第2行,第3个元素的值和地址
    //根据推到出来的规律如下
    //该元素的地址
    int  *p;                  // p+1 移动一个int 类型的大小  ,列地址
    arr+1 ;                   //移动一个int a[4] 类型的大小,行地址
   // p=arr;                    // 错误,类型不匹配
    p=*arr;                   // 合法,等同与p=*(a+0)
    p=arr[0];                 // 合法,arr[0]表示数组arr[0]的首个元素arr[0][0]地址.p=&arr[0][0]
        for(i=0;i<3;i++)
     printf("arr[%d]=%p ->%d\n",i,arr[i],*(arr[i]));

    int (*ptr)[4]=arr;
    printf("arr=%p->%d\n",&arr[0][0],arr[0][0]);
    printf("ptr=%p->%d\n",ptr,**ptr);
    printf("ptr+1=%p->%d\n",ptr+1,**(ptr+1));
     printf("*(ptr+1)+1=%p->%d\n",*(ptr+1)+1,*(*(ptr+1)+1));
    printf("arr=%p ->%d\n",arr,**arr); //两次解应用得到arr[0][0]
    printf("*arr=%p->%d\n",*arr,**arr) ;
    printf("arr[0]=%p ->%d\n",arr[0],*(arr[0]));   //arr[0][0]地址
    printf("\n");
    printf("%p\n",&arr[0][0]); 
    printf("%p\n",&arr[0]);
    printf("%p\n",*(arr+2)+3);              //&arr[2][3]
    printf("%p\n",arr[2]+3);               





    //该元素的值是12
    printf("%p ->%d\n",*(arr+2)+3,*(*(arr+2)+3));
    printf("%p ->%d\n",&arr[2][3],arr[2][3]);
     printf("\n");

    for (i=0;i<3;i++)
    {   for(j=0;j<4;j++)
        printf("%p ->%d\n",&arr[i][j],arr[i][j]);
    }
    return 0;
}

执行结果如下:

ptr=000000000062FE00->1
ptr+1=000000000062FE10->5
*(ptr+1)+1=000000000062FE14->6
arr=000000000062FE00 ->1
*arr=000000000062FE00->1
arr[0]=000000000062FE00 ->1

000000000062FE00
000000000062FE00
000000000062FE2C
000000000062FE2C
000000000062FE2C ->12
000000000062FE2C ->12

000000000062FE00 ->1
000000000062FE04 ->2
000000000062FE08 ->3
000000000062FE0C ->4
000000000062FE10 ->5
000000000062FE14 ->6
000000000062FE18 ->7
000000000062FE1C ->8
000000000062FE20 ->9
000000000062FE24 ->10
000000000062FE28 ->11
000000000062FE2C ->12

指针数组
char *strs[]={"abc","def","acfg"};
指针数组是一个元素均为指针的数组,数组的数组名表示数组首个元素的地址,而首个元素又是指针,因此指针数组的数组名就是一个二级指针。

此处输入图片的描述

int douptr(char** a,int size)
{
    char **p=a;
    int c=strlen(*p+2);
    printf("a=%p\n",a);
    printf("p=%p\n",p);
    printf("%s\n",*p);
    printf("%c",**p);

}
int main()
{
    int i,j=0;
    char *strs[] = {"abc","def","acfg"};  

    int size=sizeof(arr)/sizeof(char *);      //数组大小
    printf("arr=%p\n",arr);                   //数组地址,数组名表示首个元素地址
    printf("&arr[0]=%p\n",&arr[0]);           //数组首个元素地址
    printf("&arr[1]=%p\n",&arr[1]);
    printf("&arr[2]=%p\n",&arr[2]);    
    printf("&arr[0]=%p\n",arr);               //数组首个元素地址
    printf("arr[0]->%s\n",*arr);              //数组首个元素指向内容
    printf("arr[1][1]=%c\n",*(*(arr+1)+1)) ;  //第二个元素指向数组的第二个元素
    printf("arr[1][1]=%c\n",arr[1][1]);       //  
    printf("size=%d\n",size);
    douptr(arr,size);

    return 0;
}

结果:

arr=000000000062FE30
&arr[0]=000000000062FE30
&arr[1]=000000000062FE38
&arr[2]=000000000062FE40
&arr[0]=000000000062FE30
arr[0]->abc
arr[1][1]=e
arr[1][1]=e
size=3
a=000000000062FE30
p=000000000062FE30
abc
a

参考文献
1 https://www.oschina.net/question/253203_243676
[2] https://ybzbxcc.github.io/2016/08/06/LeetCode-14-Longest-Common-Prefix/
[3] http://ssspure.blog.51cto.com/8624394/1694224
[4] https://v.qq.com/x/cover/3dwhoro4c9voh54/h14042xdbdp.html
[6] http://ssspure.blog.51cto.com/8624394/1694224
[7] #leetcode——Longest Common Prefix
标签(空格分隔): 未分类


问题描述: Write a function to find the longest common prefix string amongst an array of strings.

分析:
题目要求为寻找一组字符串的最长相同前缀,如{“abcd”,”abdf”,”abf”},三个字符串前两位“ab”相同,最长前缀位ab。
解体思路:最长相同前缀一定小于等于最短字符串的长度,故先找到最短字符串,并以此作为被比较对象,若查找某位上字符串与被比较字符串不相同,则比较结束,被比较字符串该位前的字符即为该字符串组的最长相同前缀。
此题需要考虑两种特殊情况:
(1)字符串组为空。此时直接返回“”即可。
(2)字符串组只有一个字符串。这种情况下,最长相同前缀即为该字符串本身。

代码:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

char* longestCommonPrefix(char** strs, int strsSize);
int main()
{
    char * strs[] = { "abc""abd" };
    int strsize = sizeof(strs) / sizeof(char *);
    printf("strsize=%d\n", strsize);
    char *CommonPrefix;
    //char **str = &strs[0];
    int i=0; 
    for ( i = 0; i < strsize;i++)
    {
        printf("strsize[%d]=%d\n",i, strlen(strs[i]));
        printf("strs[%d]=%s\n", i, strs[i]);

    }

    CommonPrefix=longestCommonPrefix(strs,strsize);
    printf("longestCommonPrefix=%s\n",CommonPrefix);
    system("pause");
    return 0;
}

char* longestCommonPrefix(char** strs, int strsSize) {
    if (strs == NULL || *strs == NULL) {
        return "";
    }
    if (strsSize==1)
        return *strs;
    int i,j,x=0;
    int minprefix=strlen(strs[0]);  //strs 为二级指针也就是,指针的指针。其实质是一个指针数组,即元素均为指针的数组,数组的数组名表示数组首个元素的地址,而首个元素又是指针,因此指针数组的数组名就是一个二级指针。
    char temp;
    char *result;

    for(i=1;i<strsSize;i++)   //查找最短字符串,并记录其长度
    {
        if(minprefix>strlen(strs[i]))
        {   minprefix=strlen(strs[i]);  
            x=i;
        }
    }

    for (j=0;j<minprefix;j++)   //以最短字符串长度为比较位数上限
    { 
        temp=*(strs[x]+j);      //将最短字符串最为基准
        for(i=0;i<strsSize;i++)
        {

            if(*(strs[i]+j)!=temp)  //若找到有一位字符不相同,则比较结束
                break;              
        }
        if(i!=strsSize)  //各字符串中至少有两个相应位不同,结束循环
            break;
    }

    if(j>=0)           
    {
        result = (char* ) malloc(sizeof(char) *(j+1));
        strncpy(result,strs[x],j+1);          //将相同的前j位返回
        result[j]='\0';

    }

    return result;
}
char* longestCommonPrefix(char** strs, int strsSize) {
    if (strs == NULL || *strs == NULL) {
        return "";
    }
    int len = strlen(strs[0]);
    int max = 0;
    char *res;
    while (max < len) {
        for (int i = 1; i < strsSize; i++) {
            if (strs[i][max] != strs[0][max])    //逐位比较,直到找到不同位
            {        
                len = max;
                break;
            }
        }
        if (max < len) max++;      //发现不同位
    }
    res = (char*)malloc(sizeof(char)*(max+1));
    for (int i = 0; i < max; i++)           //将相同的前max位返回
    {
        res[i] = strs[0][i];
    }
    res[max] = '\0';
    return res;
}

二级指针与二维数组


char *string[] ={"abc","abcd","acf"};
char string[3][4]={"abc","abcd","acf"};

首先一点的是,虽然二维数组的数组名可以看做是一个指针,但是并不能将二维数组的数组名赋值给一个二级指针,也就是如下的代码

int main(void)
{
    int arr[3][3] = {{1,2,3},{4,5,6},{7,8,9}};
    int **p = arr;
    return 0;
}

上面的代码在执行的时候会报错,这是因为两者数据类型是不相同的,所以不能赋值。
二维数组的数组名指向的是一维数组,也就是指向数组类型,但是二级指针指向的是一级指针,也就是指针类型,所以两者不能互相赋值。

下面详细介绍指针与二维数组的关系
声明一个二维数组

int a[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};
for (i=0;i<3;i++)
    {   for(j=0;j<4;j++)
        printf("%p ->%d\n",&arr[i][j],arr[i][j]);
    }
000000000062FE10 ->1
000000000062FE14 ->2
000000000062FE18 ->3
000000000062FE1C ->4
000000000062FE20 ->5
000000000062FE24 ->6
000000000062FE28 ->7
000000000062FE2C ->8
000000000062FE30 ->9
000000000062FE34 ->10
000000000062FE38 ->11
000000000062FE3C ->12

二维数组a可以看成是由a[0],a1,a[2]三个元素组成的一维数组,a是其数组名;a[0],a1,a[2]又都是一维数组,其数组名分别是a[0],a1,a[2],a[0],a1,a[2]分别表示各自数组的首个元素的地址。

arr[0]=000000000062FE00 ->1
arr[1]=000000000062FE10 ->5
arr[2]=000000000062FE20 ->9

由于数组名就是指针,故a[0],a1,a[2]为一级指针,其类型为int。a是由三个一级指针组成的数组。

那么a与a[0],a+1与a[0]+1的区别是什么?

a+1跨过了二维数组的一行,故a,a+1和a+2为行地址。
相对于a[0]而言,a[0]+1只跨过了二维数组的一个元素,故为列地址。
由此可以看出:
(1)a+i是第i行的地址,即*(a+i)=a[i]。因此a[i][j]等价于(*(a+i))[j];
(2)a[i]+j是第i行第j列的地址,因此*(a[i]+j)等价与a[i][j]。

上述等价关系总结如下:

a[i][j] ←→ (*(a+i))[j] ←→ *(a[i]+j) ←→ *(*(a+i)+j)

要想理解指针和二维数组之间的关系,就要首先弄清楚各种数组名所代表的元素。
数组名表示的是该数组首个元素的地址,即arr=&arr[0][0];

二维数组在内存中也是以一维数组的形式存储,只不过每个的一维数组的元素都是一维数组,因此二维数组名,可以将它看做是指向行数组的指针
对于二维数组的存储,是按照先行后列的形式排列的,把每一行看做是一个一位数组,那二维数组就是由多个一位数组组成的数组,即二维数组是数组的数组。

对于二维数组名,可以将它看做是指向行数组的指针,也就是说二维数组的元素是行数组,所以对于二维数组加减的变化是以行数组的大小为单位的,即arr指向arr[0]这个行数组,arr+1指向的是arr1这个行数组。对其进行解引用,得到的是每一行数组的首地址,即arr表示的是第0行数组的首地址,和arr[0]相等,(arr+1)表示的是第1行数组的首地址,和arr1是相等的。假如要取第1行第2个元素的地址,就是arr1+2,因为此时arr1代表的是一维数组,所以它的元素就是一个数字,在加减的时候移动的就是元素的大小,例如+1就表示该数组中第1个元素,+3就表示数组中的3个元素(以0开始)。因为
(arr+1)和arr1相等,所以第1行第2个元素的地址也可以表示为(arr+1)+2,对这个地址进行解引用,得到的就是数组元素的具体值,也就是((arr+1)+2)。
所以有如下公式,假如一个二维数组每行有N个元素,二维数组名是arr,那第i行第j个元素的地址是*(arr+i)+j,也可以表示为arr[i]+j。元素的值可以表示为*(*(arr+i)+j),或者可以表示为arr[i][j]。

对上述二维数组arr,虽然arr[0]、arr都是数组首地址,但二者指向的对象不同,arr[0]是一维数组的名字,它指向的是arr[0]数组的首元素,其值为arr[0]首个元素的地址,对其进行“*”运算,得到的是一个数组元素值,即arr[0]数组首元素值(本例arr[0]数组的首个元素值为1),因此,*arr[0]与arr[0][0]是同一个值。

而arr(可以看作arr+0)是一个二维数组的名字,它指向的是它所属元素的首元素,而二维数组的每一个元素都是一个维数组,因此arr指向二维数组arr的首个元素arr[0],对其进行*运算得到的是arr[0]的地址,而要想得到arr[0][0]的值,需要再进行一次*运算。

*arr=&arr[0];
**arr=*(&arr[0])=arr[0][0]
printf("arr=%p ->%d\n",arr,**arr); //两次解应用得到arr[0][0]
printf("*arr=%p->%d\n",*arr,**arr) ;
printf("arr[0]=%p ->%d\n",arr[0],*(arr[0]));   //arr[0][0]地址

printf("%p\n",&arr[0][0]); 
printf("%p\n",&arr[0]);
printf("%p\n",*(arr+2)+3);                     //&arr[2][3]
printf("%p\n",arr[2]+3);               
printf("%p ->%d\n",*(arr+2)+3,*(*(arr+2)+3));
printf("%p ->%d\n",&arr[2][3],arr[2][3]);
arr=000000000062FE00 ->1
*arr=000000000062FE00->1
arr[0]=000000000062FE00 ->1

000000000062FE00
000000000062FE00
000000000062FE2C
000000000062FE2C
000000000062FE2C ->12
000000000062FE2C ->12

因此,数组名最为指针时移动单位的是“行”,所以arr+i指向的是第i个行数组,即指向arr[i]。对arr进行“*”运算,得到的是一维数组arr[0]的首地址,即\arr与arr[0]是同一个值但指向类型不同通过(arr+1与arr[0]+1即能看出其不同)。当用int*p;定义指针p时,p的指向是一个int型数据,对其进行加减操作,移动的是一个int型大小,而不是一个地址,因此,用arr[0]对p赋值是正确的,而用arr对p赋值是错误的。
使用数组指针对二级指针操作
而int (*ptr)[4],ptr表示一个指向4个int型数组的指针,对其进行加减操作,该变量为数组大小乘以数据类型大小。即ptr+1=&ptr+4*sizeof(int);
因而,int (*ptr)[4]可以使用arr来初始化,因为ptr是一个指向包含4个int型元素的数据,而arr指向其首个元素的地址,其首个元素又是一个包含4个int型数据的数据。

int (*ptr)[4]=arr;                              //  行地址
printf("arr=%p->%d\n",&arr[0][0],arr[0][0]);    //首元素地址
printf("ptr=%p->%d\n",ptr,**ptr);     
printf("ptr+1=%p->%d\n",ptr+1,**(ptr+1));       //行地址加一移动4个int型大小
printf("*(ptr+1)+1=%p->%d\n",*(ptr+1)+1,*(*(ptr+1)+1));  //
运行结果:
arr=000000000062FE00->1
ptr=000000000062FE00->1
ptr+1=000000000062FE10->5
*(ptr+1)+1=000000000062FE14->6

完整程序:

#include<stdio.h>

int main()
{
 int i,j=0;
    int arr[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};
    //分别使用不同的形式打印第2行,第3个元素的值和地址
    //根据推到出来的规律如下
    //该元素的地址
    int  *p;                  // p+1 移动一个int 类型的大小  ,列地址
    arr+1 ;                   //移动一个int a[4] 类型的大小,行地址
   // p=arr;                    // 错误,类型不匹配
    p=*arr;                   // 合法,等同与p=*(a+0)
    p=arr[0];                 // 合法,arr[0]表示数组arr[0]的首个元素arr[0][0]地址.p=&arr[0][0]
        for(i=0;i<3;i++)
     printf("arr[%d]=%p ->%d\n",i,arr[i],*(arr[i]));

    int (*ptr)[4]=arr;
    printf("arr=%p->%d\n",&arr[0][0],arr[0][0]);
    printf("ptr=%p->%d\n",ptr,**ptr);
    printf("ptr+1=%p->%d\n",ptr+1,**(ptr+1));
     printf("*(ptr+1)+1=%p->%d\n",*(ptr+1)+1,*(*(ptr+1)+1));
    printf("arr=%p ->%d\n",arr,**arr); //两次解应用得到arr[0][0]
    printf("*arr=%p->%d\n",*arr,**arr) ;
    printf("arr[0]=%p ->%d\n",arr[0],*(arr[0]));   //arr[0][0]地址
    printf("\n");
    printf("%p\n",&arr[0][0]); 
    printf("%p\n",&arr[0]);
    printf("%p\n",*(arr+2)+3);              //&arr[2][3]
    printf("%p\n",arr[2]+3);               





    //该元素的值是12
    printf("%p ->%d\n",*(arr+2)+3,*(*(arr+2)+3));
    printf("%p ->%d\n",&arr[2][3],arr[2][3]);
     printf("\n");

    for (i=0;i<3;i++)
    {   for(j=0;j<4;j++)
        printf("%p ->%d\n",&arr[i][j],arr[i][j]);
    }
    return 0;
}

执行结果如下:

ptr=000000000062FE00->1
ptr+1=000000000062FE10->5
*(ptr+1)+1=000000000062FE14->6
arr=000000000062FE00 ->1
*arr=000000000062FE00->1
arr[0]=000000000062FE00 ->1

000000000062FE00
000000000062FE00
000000000062FE2C
000000000062FE2C
000000000062FE2C ->12
000000000062FE2C ->12

000000000062FE00 ->1
000000000062FE04 ->2
000000000062FE08 ->3
000000000062FE0C ->4
000000000062FE10 ->5
000000000062FE14 ->6
000000000062FE18 ->7
000000000062FE1C ->8
000000000062FE20 ->9
000000000062FE24 ->10
000000000062FE28 ->11
000000000062FE2C ->12

指针数组
char *strs[]={"abc","def","acfg"};
指针数组是一个元素均为指针的数组,数组的数组名表示数组首个元素的地址,而首个元素又是指针,因此指针数组的数组名就是一个二级指针。
二维数组名表示的是首个元素的地址,二维数组又可以理解为一个一维数组,而每个一维数组的元素又是
一个一维数组。对其进行加减操作,是以一维数组的大小为单位进行。类似与数组指针,即指向数组的指针,对其进行加减操作也是以数组大小为单位进行。
此处输入图片的描述

int douptr(char** a,int size)
{
    char **p=a;
    int c=strlen(*p+2);
    printf("a=%p\n",a);
    printf("p=%p\n",p);
    printf("%s\n",*p);
    printf("%c",**p);

}
int main()
{
    int i,j=0;
    char *strs[] = {"abc","def","acfg"};  

    int size=sizeof(arr)/sizeof(char *);      //数组大小
    printf("arr=%p\n",arr);                   //数组地址,数组名表示首个元素地址
    printf("&arr[0]=%p\n",&arr[0]);           //数组首个元素地址
    printf("&arr[1]=%p\n",&arr[1]);
    printf("&arr[2]=%p\n",&arr[2]);    
    printf("&arr[0]=%p\n",arr);               //数组首个元素地址
    printf("arr[0]->%s\n",*arr);              //数组首个元素指向内容
    printf("arr[1][1]=%c\n",*(*(arr+1)+1)) ;  //第二个元素指向数组的第二个元素
    printf("arr[1][1]=%c\n",arr[1][1]);       //  
    printf("size=%d\n",size);
    douptr(arr,size);

    return 0;
}

结果:

arr=000000000062FE30
&arr[0]=000000000062FE30
&arr[1]=000000000062FE38
&arr[2]=000000000062FE40
&arr[0]=000000000062FE30
arr[0]->abc
arr[1][1]=e
arr[1][1]=e
size=3
a=000000000062FE30
p=000000000062FE30
abc
a

参考文献
1 https://www.oschina.net/question/253203_243676
[2] https://ybzbxcc.github.io/2016/08/06/LeetCode-14-Longest-Common-Prefix/
[3] http://ssspure.blog.51cto.com/8624394/1694224
[4] https://v.qq.com/x/cover/3dwhoro4c9voh54/h14042xdbdp.html
[6] http://ssspure.blog.51cto.com/8624394/1694224
[7] http://c.biancheng.net/cpp/html/478.html

### 回答1: 好的,我来用中文回复这个链接:https://leetcode-cn.com/tag/dynamic-programming/ 这个链接是 LeetCode 上关于动态规划的题目集合。动态规划是一种常用的算法思想,可以用来解决很多实际问题,比如最长公共子序列、背包问题、最短路径等等。在 LeetCode 上,动态规划也是一个非常重要的题型,很多题目都需要用到动态规划的思想来解决。 这个链接里包含了很多关于动态规划的题目,按照难度从简单到困难排列。每个题目都有详细的题目描述、输入输出样例、题目解析和代码实现等内容,非常适合想要学习动态规划算法的人来练习和提高自己的能力。 总之,这个链接是一个非常好的学习动态规划算法的资源,建议大家多多利用。 ### 回答2: 动态规划是一种算法思想,通常用于优化具有重叠子问题和最优子结构性质的问题。由于其成熟的数学理论和强大的实用效果,动态规划在计算机科学、数学、经济学、管理学等领域均有重要应用。 在计算机科学领域,动态规划常用于解决最优化问题,如背包问题、图像处理、语音识别、自然语言处理等。同时,在计算机网络和分布式系统中,动态规划也广泛应用于各种优化算法中,如链路优化、路由算法、网络流量控制等。 对于算法领域的程序员而言,动态规划是一种必要的技能和知识点。在LeetCode这样的程序员平台上,题目分类和标签设置十分细致和方便,方便程序员查找并深入学习不同类型的算法。 LeetCode的动态规划标签下的题目涵盖了各种难度级别和场景的问题。从简单的斐波那契数列、迷宫问题到可以用于实际应用的背包问题、最长公共子序列等,难度不断递进且话题丰富,有助于开发人员掌握动态规划的实际应用技能和抽象思维模式。 因此,深入LeetCode动态规划分类下的题目学习和练习,对于程序员的职业发展和技能提升有着重要的意义。 ### 回答3: 动态规划是一种常见的算法思想,它通过将问题拆分成子问题的方式进行求解。在LeetCode中,动态规划标签涵盖了众多经典和优美的算法问题,例如斐波那契数列、矩阵链乘法、背包问题等。 动态规划的核心思想是“记忆化搜索”,即将中间状态保存下来,避免重复计算。通常情况下,我们会使用一张二维表来记录状态转移过程中的中间值,例如动态规划求解斐波那契数列问题时,就可以定义一个二维数组f[i][j],代表第i项斐波那契数列中,第j个元素的值。 在LeetCode中,动态规划标签下有众多难度不同的问题。例如,经典的“爬楼梯”问题,要求我们计算到n级楼梯的方案数。这个问题的解法非常简单,只需要维护一个长度为n的数组,记录到达每一级楼梯的方案数即可。类似的问题还有“零钱兑换”、“乘积最大子数组”、“通配符匹配”等,它们都采用了类似的动态规划思想,通过拆分问题、保存中间状态来求解问题。 需要注意的是,动态规划算法并不是万能的,它虽然可以处理众多经典问题,但在某些场景下并不适用。例如,某些问题的状态转移过程比较复杂,或者状态转移方程中存在多个参数,这些情况下使用动态规划算法可能会变得比较麻烦。此外,动态规划算法也存在一些常见误区,例如错用贪心思想、未考虑边界情况等。 总之,掌握动态规划算法对于LeetCode的学习和解题都非常重要。除了刷题以外,我们还可以通过阅读经典的动态规划书籍,例如《算法竞赛进阶指南》、《算法与数据结构基础》等,来深入理解这种算法思想。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值