精华内容
下载资源
问答
  • 数组

    2015-12-21 20:54:28
     数据类型是数组中全体数组元素的数据类型。  数组名用标识符表示,整形常量表达式代表数组具有的数组元素个数。  数组元素的下标一律从0开始。  编译程序为数组开辟连续的存储单位,用来顺序存放数组的各...

    一维数组的定义

    定义一维数组的形式为:
    数据类型  数组名  [整形常量表达式];
     说明:
              数据类型是数组中全体数组元素的数据类型。
              数组名用标识符表示,整形常量表达式代表数组具有的数组元素个数。
              数组元素的下标一律从0开始。
              编译程序为数组开辟连续的存储单位,用来顺序存放数组的各数组元素。用数组名表示该数组存储区的首地址。
    注意:
              定义数组元素个数的表达式是整形常量表达式,不能出现变量或者非整形常量表达式。
    例如下列数组定义是正确的:
    #define n 5
    int   a[n];                     /*n不是变量,是符号常量,其值为5*/
    int    b[2+3];               /*2+3是常量表达式,其值为5*/
    int     c[10];

    一维数组的引用

    引用数组元素的形式为:
            数组名[下表表达式];
    注意:
            *定义时整形常量表达式与引用的数组元素的下标表达式是完全不同的概念。对数组定义:int   a[5];    这里整形常量表达式5表示a数组有5个数组元素。对数组元素的引用:a[3]=a[2]+a[5];   这里下表表达式3和2均表示数组元素的下标。而a[5]是错误的数组元素引用,因为下表从0开始,所以数组元素的小于5,下表已经越界。
            *系统不检查数组元素的越界,只能由自己掌握。下标越界会破坏其它变量的值,因此编程时一定要保证数组元素的下表不越界。

    一维数组的初始化

    一维数组初始化的形式为:
          数据类型   数组名[整形常量表达式]={初值1,初值2,初值3,...........};
    初始化方法:
          1.int    a[4]={1,2,3,4};
            数组中有若干数组元素,可在{ }中给出各数组元素的初值,各初值之间用逗号隔开。把{ }中的初值依次赋给各数组元素。表示把1,2,3,4依次赋给a[0], a[1], a[2], a[3]。
          2.static  int  a[4]={1,2};
            只给部分数组元素初始化。注意到关键字static,它表示a数组的存储类型为static(静态存储)。存储类型为静态存储的变量或数组的初值自动设置为0。即a[0]=1;  a[1]=2;  a[2]=0;   a[3]=0.
           3.int   a[ ]={1,2,3};
             初始化时,定义数组元素的个数的常量表达式可以省略。若数组元素的个数定义省略,则系统根据初值的个数来确定数组元素的个数。如上例,a数组有3个数组元素:a[0]=1;    a[1]=2;    a[2]=3。

    一维数组的应用

    需求:输入100个数,输出它们的平均值和这些数当中所有大于平均值的数。
     #define  N  100
     #include<stdio.h>
     
     int    main(void){
            int     k;
            int     a[N],s;
             float    av;
           s=0;
             for(k=0;k<N;k++){
                    scanf("%d",&a[k]);
                    s=s+a[k];
        }
            av=s/N;
             printf("average=%f",av);
             for(k=0;k<N;k++)
                  if(a[k]>av)  printf("%d",a[k]);
           return  0;
    }

    二维数组

    二维数组的定义

    定义二维数组的形式为:
        数据类型    数组名[整形常量表达式] [整形常量表达式];
    数据类型是数组全体数组元素的数据类型;数组名用标识符表示;两个整形变量表达式分别代表数组具有的行数和列数。数组元素的下标一律从0开始。存储方式为按行存储。

    二维数组的引用

    数组元素的形式为:
         数组名[行下表表达式] [行下表表达式]
    例如希望从键盘依次为数组元素输入数据,可以采用如下语句:
    for(i=0;i<20;i++)
       for(j=0;j<30;j++)
             scanf("%d",&a[ i ] [ j ]);

    二维数组的初始化

    二维数组初始化的形式为:
         数据类型    数组名[整形常量表达式] [整形常量表达式]={初始化数据};
    初始化方式:
          1.分行进行初始化。例如:int    a[2] [3]={ {1,2,3},{4,5,6} };
          2.不分行的初始化。例如:int    a[2] [3]={1,2,3,4,5,6};              //3个数字为一行
          3.为部分数组元素初始化。例如: int    a[2] [3]={ {1,2},{4} };
             第一行只有2个初值,按顺序分别赋给a[0] [0]和a[0] [1];第二行的初值赋给a[1] [0].
          4.可以省略第一维的定义,但不能省略第二维的定义。系统根据初始化的数据个数和第2维德长度可以确定第一维的长度。例如:  int    a[ ] [3]={1,2,3,4,5,6};
    初始化数据为6个,第二维的长度为3,即每行3个数,所以a数组的第一维是2.
    省略第一维定义时,第一维的大小按如下规定:初值个数能被第二维正处,所得的商就是第一维的大小;若不能整除,则第一维的大小为商再加1。

    二维数组的应用

    需求:实现行列互换问题
    #include<stdio.h>

    int main(void){
    int i,j;
    int a[2][3]={1,2,3,4,5,6};
    int b[3][2];
    printf("互换前的数组为:\n");
        for(i=0;i<2;i++){
        for(j=0;j<3;j++){
        printf("%3d",a[i][j]);
        b[j][i]=a[i][j];
       }
        printf("\n");
        } 
        printf("互换后的数组为:\n");
        for(i=0;i<3;i++){
        for(j=0;j<2;j++)
            printf("%3d",b[i][j]);
        printf("\n");
        } 
    return 0;
    }

    字符数组与字符串

    在c语言中,只能用一个字符数组来表示一个字符串。字符数组的每个元素占一个字节,字符数组中包含一个' \0  '字符,代表字符串的结尾。因而字符数组的元素个数,应该不少于被存储的字符串的字符数目加1.
    下面以一段代码说明字符串变量的用法,代码如下:
    #include<stdio.h>
    #include<string.h>
    int   main(void)
    {
         char     cNational [ ]="zhongguo";
         char     cCity[ 10]="北京";
         char     cEnglish[10];
         char     szResponse[100];
         printf("中国的汉语拼音是%s,用英文表示出来是?\n", cNationa);
                scanf("%s",&cEnglish);
                 if(strcmp(cEnglish,"china")==0){
                    printf("这是%s吗?\n", cCity);
                }
                else{
                     strcpy( szResponse,"你的英文不好!\n");                          //调用string.h中声明的字符串拷贝库函数strcpy为字符数组赋值
                     printf("%s", szResponse);
               } 
         return   0;
    }
    展开全文
  • 该楼层疑似违规已被系统折叠隐藏此楼查看此楼西工大机考《C语言程序设计》网考寻求答案(非免费)找我Q...,以下选项对a数组元素正确引用的是( )。A.a[2][!1]B.a[2][3]C.a[0][3]D.a[1>2][!1]2. 以下描述错误的是...

    该楼层疑似违规已被系统折叠 隐藏此楼查看此楼

    西工大机考《C语言程序设计》网考

    寻求答案(非免费)找我Q和V:2082851315

    试卷总分:100 得分:96

    一、 单选题 (共 35 道试题,共 70 分)

    1. 若有定义:int a[2][3];,以下选项中对a数组元素正确引用的是( )。

    A.a[2][!1]

    B.a[2][3]

    C.a[0][3]

    D.a[1>2][!1]

    2. 以下描述错误的是( )。

    A.break语句不能用于循环语句和switch语句外的任何其他语句

    B.在switch语句中使用break语句或continue语句的作用相同

    C.在循环语句中使用continue语句是为了结束本次循环,而不是终止整个循环

    D.在循环语句中使用break语句是为了使流程跳出循环体,提前结束循环

    3. 以下存储类型只有在使用时才为该类型变量分配内存的是( )。

    A.auto和static

    B.auto和register

    C.register和static

    D.static和extern

    4. 若变量已正确定义,有以下程序段

    int a=3,b=5,c=7;

    if(a>b) a=b; c=a;

    if(c!=a) c=b;

    printf("%d,%d,%d\n",a,b,c);

    其输出结果是( )。

    A.程序段有语法错

    B.3,5,3

    C.3,5,5

    D.3,5,7

    5. 函数strlen("1234\0xy")的值为( )。

    A.7

    B.8

    C.4

    D.9

    6. 若二维数组a由m列,则在a[i][j]之前的元素个数为( )。

    A.j*m+i

    B.i*m+j

    C.i*m+j-1

    D.i*m+j+1

    7. 假定x和y为 double型,则表达式x=2,y=x+3/2的值是( )。

    A.3.500000

    B.3

    C.2.000000

    D.3.000000

    8. 设变量已正确定义并赋值,以下正确的表达式是( )。

    A.x=y*5=x+z

    B.int(15.8%5)

    C.x=y+z+5,++y

    D.x=25%5.0

    9. 在C语言中,设一表达式中包含有int,long,char和unsigned类型的变量和数据,则这4种类型数据转换的规则是( )。

    A.int→unsingned→long→char

    B.char→int→long→unsingned

    C.char→int→unsigned→long

    D.int→char→unsigned→long

    10. 若有说明:int *p,m=5,n;,以下正确的程序段是( )。

    A.p=&n;scanf("%d",&p);

    B.p=&n;scanf("%d",*p)

    C.scanf("%d",&n);*p=n;

    D.p=&n;*p=m;

    11. 在C语言中,变量的隐含存储类别是( )。

    A.auto

    B.static

    C.extern

    D.无存储类别

    12. 函数的功能是交换变量x和y中的值,且通过正确调用返回交换的结果。能正确执行此功能的函数是( )。

    A.funa(int *x, int *y)

    { int *p;

    *p=x; *x=*y; *y=*p;

    }

    B.funb(int x, int y)

    { int t;

    t=x; x=y; y=t;

    }

    C.func(int *x, int *y)

    { *x=*y; *y=*x;

    }

    D.{fund(int *x, int *y)

    13. 在C语言中,只有在使用时才占用内存单元的变量,其存储类型是 ( )。

    A.auto和register

    B.extern和register

    C.auto和static

    D.static和register

    14. 以下定义语句中正确的是( )。

    A.int a=b=0;

    B.char A=65+1,b=′b′;

    C.float a=1,*b=&a,*c=&b;

    D.double a=0.0;b=1.1;

    15. 以下描述中正确的是( )。

    A.由于do-while循环中循环体语句只能是一条可执行语句,所以循环体内不能使用复合语句

    B.do-while循环由do开始,用while结束,在while(表达式)后面不能写分号

    C.在do-while循环体中,是先执行一次循环,再进行判断

    D.do-while循环中,根据情况可以省略while

    16. 下面程序的输出结果是( )。

    main()

    {

    int s,k;

    for(s=1,k=2;k<5;k++) s+=k;

    printf("%d\n",s);

    A.1

    B.9

    C.0

    D.15

    17. 以读写方式打开一个已有的文件file1,下面有关fopen函数正确的调用方式为( )。

    A.FILE *fp;fp=fopen("file1";"f");

    B.FILE *fp;fp=fopen("file1","r+");

    C.FILE *fp;fp=fopen("file1","rb");

    D.FILE *fp;fp=fopen("file1","rb+");

    18. 设int a=12,则执行完语句a+=a-=a*a后,a的值是( )。

    A.552

    B.264

    C.144

    D.-264

    19. 阅读下列程序,则运行结果为( )。

    #include "stdio.h"

    fun()

    { static int x=5;

    x++;

    return x;\

    A.5

    B.6

    C.7

    D.8

    20. 运行下面程序:

    main()

    {

    int n1,n2;

    scanf("%d",&n2);

    while(n2!=0)

    \ n1=n2%10;

    n2=n2/10;

    }

    printf("%d",n1);

    }若从键盘上输入298↙ ,则输出结果为( )。

    A.2

    B.29

    C.8

    D.0

    21. C语言规定,在一个源程序中,main函数的位置( )。

    A.必须在最开始

    B.必须在系统调用的库函数的后面

    C.可以任意

    D.必须在最后

    22. 已知double *p[6]; 它的含义是( )。

    A.p是指向double类型变量的指针

    B.p是double类型数组

    C.p是指针数组

    D.p是数组指针

    23. 以下叙述中错误的是( )。

    A.在程序中凡是以"#"开始的语句行都是预处理命令行

    B.预处理命令行的最后不能以分号表示结束

    C.#define MAX 是合法的宏定义命令行

    D.C程序对预处理命令行的处理是在程序执行的过程中进行的

    24. 为了判断两个字符串s1和s2是否相等,应当使用( )。

    A.if(s1==s2)

    B.if(s1=s2)

    C.if(strcpy(s1, s2))

    D.if(strcmp(s1, s2)==0)

    25. 在下列结论中,只有一个是正确的,它是( )。

    A.递归函数中的形式参数是自动变量

    B.递归函数中的形式参数是外部变量

    C.递归函数中的形式参数是静态变量

    D.递归函数中的形式参数可以根据需要自己定义存储类型

    26. 以下不正确的定义语句是( )。

    A.double x[5]={2.0,4.0,6.0,8.0,10.0;

    B.int y[5]={0,1,3,5,7,9;

    C.char c1[]={′1′,′2′,′3′,′4′,′5′;

    D.char c2[]={′\x10′, ′xa′, ′\x8′;

    27. 有以下程序段

    int n=0,p;

    do

    { scanf("%d",&p);n++;

    }while(p!=123&&n<10);

    此处do-while循环的结束条件是( )。

    A.P的值不等于123或者n的值小于10

    B.P的值等于123并且n的值大于等于10

    C.P的值不等于123并且n的值小于10

    D.P的值等于123或者n的值大于等于10

    28. 以下叙述中错误的是( )。

    A.改变函数形参的值,不会改变对应实参的值

    B.函数可以返回地址值

    C.可以给指针变量赋一个整数作为地址值

    D.当在程序的开头包含头文件stdio.h时,可以给指针变量赋NULL

    29. 当变量c的值不为2、4、6时,值也为"真"的表达式是( )。

    A.(c==2)︱︱(c==4)︱︱(c==6)

    B.(c>=2&& c<=6)︱︱(c!=3)︱︱(c!=5)

    C.(c>=2&&c<=6)&&!(c%2)

    D.(c>=2&& c<=6)&&(c%2!=1)

    30. 运行程序:

    #include

    main()

    {

    int n='c';

    switch(n++)

    { default: printf("error");break;

    case 'a':case 'A':case 'b':case 'B':printf("good");break;

    case 'c':case 'C':printf("pass");

    case 'd':case 'D':printf("warn");

    }

    }则输出结果是( )。

    A.good

    B.pass

    C.warn

    D.passwarn

    31. 设有 int x=8; 则表达式 (++x*1/3) 的值是( )。

    A.2

    B.3

    C.2.6

    D.0

    32. 下面程序的输出结果是( )。

    main()

    { int x=5,y=9,z=1,t;

    t=(x>y||x>z);

    printf("%d\n",t);

    A.1

    B.0

    C.5

    D.3

    33. 有以下程序

    #include

    main()

    { int x=1,y=0,a=0,b=0;

    switch(x)

    { case 1:

    switch(y)

    { case 0:a++; break;

    case 1:b++; break;

    }

    case 2:a++; b++; break;

    case 3:a++; b++;

    }

    printf("a=%d,b=%d\n",a,b);

    }

    A.a=1,b=0

    B.a=2,b=2

    C.a=1,b=1

    D.a=2,b=1

    34. 一个C程序的执行是从( )。

    A.本程序的main函数开始,到main函数结束

    B.本程序文件的第一个函数开始,到本程序文件的最后一个函数结束

    C.本程序的main函数开始,到本程序文件的最后一个函数结束

    D.本程序文件的第一个函数开始,到本程序main函数结束

    35. 有以下程序

    main()

    { int i,s=1;

    for (i=1;i<50;i++)

    if(!(i%5)&&!(i%3)) s+=i;

    printf("%d\n",s);

    A.409

    B.277

    C.1

    D.91

    二、 判断题 (共 15 道试题,共 30 分)

    1. C语言的编译系统对宏命令的处理是和c程序中的其他语句同时进行编译的。

    A.错误

    B.正确

    2. 设变量 a 为整型,f 是实型,i 是双精度型,则表达式10+'a'+i * f 值的数据类型不能确定为何类型。

    A.错误

    B.正确

    3. (a=3)>(b=5) 是合法的关系表达式。

    A.错误

    B.正确

    4. 预处理指令只能位于C源程序文件的首部。

    A.错误

    B.正确

    5. 在c程序中,语句之间必须要用分号";"来分隔。

    A.错误

    B.正确

    6. for循环是先执行循环体语句,后判断表达式。

    A.错误

    B.正确

    7. 在C语言中char型数据在内存中的存储形式为ASCII码。

    A.错误

    B.正确

    8. 声明语句可放在函数体中的任何位置。

    A.错误

    B.正确

    9. 在C程序中,%是只能用于整数运算的运算符。

    A.错误

    B.正确

    10. 设int a=12;则执行完语句a+=a-=a*a后,a的值为144。

    A.错误

    B.正确

    11. 两个字符串所包含的字符个数相同时才能比较字符串大小。

    A.错误

    B.正确

    12. %x是格式符的一种,它可以适用于任何一种类型的数据。

    A.错误

    B.正确

    13. 若a和b类型相同,在执行了语句a=b后,b中的值将放入a中,b中的值不变。

    A.错误

    B.正确

    14. 用typedef可以定义各种类型名,但不能用来定义变量。

    A.错误

    B.正确

    15. C语言认为变量number和NuMbEr是相同的。

    A.错误

    B.正确

    展开全文
  • 对于定义"int *p",下列哪些说明可能是正确的?() 正确答案: A D 你的答案: 空 (错误) p是一个指向int型值的指针 p是一个指向一维数组的指针 p是一个指向二维数组的指针 p是一个动态数组 添加笔记 求...

    对于定义"int *p",下列哪些说明可能是正确的?()

    正确答案: A D   你的答案: 空 (错误)

    p是一个指向int型值的指针
    p是一个指向一维数组的指针
    p是一个指向二维数组的指针
    p是一个动态数组



    B选项解释的不对啊

    int arr[10]; 
    int *p=arr; 


    p 是指向一维数组元素的指针,指向的是 arr[0],执行 ++p,则 p 的地址值会增加 4 

    而若是

    	int arr[10];
    	int(*p)[10] = &arr;


    此时p才是指向一维数组的指针,此时,若执行 ++p,则 p 的地址值会增加 40(int为4位,10个元素就是40)

    注意,以下写法是错误的


    一维数组的指针只能这样写:


    展开全文
  • 4. 寻找两个正序数组位数 4. 寻找两个正序数组位数 https://leetcode-cn.com/problems/median-of-two-sorted-arrays/ 给定两个大小为 m 和 n 的正序(从小到大)数组nums1 和nums2。请你找出这两个正序...

    目录

    4. 寻找两个正序数组的中位数

    1470. 重新排列数组

    1486. 数组异或操作

    1295. 统计位数为偶数的数字

    1534. 统计好三元组

    1460. 通过翻转子数组使两个数组相等

    1550. 存在连续三个奇数的数组

    1122. 数组的相对排序

    1337. 方阵中战斗力最弱的 K 行

    268. 缺失数字


    4. 寻找两个正序数组的中位数

    https://leetcode-cn.com/problems/median-of-two-sorted-arrays/

    给定两个大小为 m 和 n 的正序(从小到大)数组 nums1 和 nums2。请你找出这两个正序数组的中位数,并且要求算法的时间复杂度为 O(log(m + n))。你可以假设 nums1 和 nums2 不会同时为空。

    示例 1:nums1 = [1, 3],nums2 = [2],则中位数是 2.0
    示例 2:nums1 = [1, 2],nums2 = [3, 4],则中位数是 (2 + 3)/2 = 2.5

    题解

    一:转自官方题解:https://leetcode-cn.com/problems/median-of-two-sorted-arrays/solution/xun-zhao-liang-ge-you-xu-shu-zu-de-zhong-wei-s-114/

    给定两个有序数组,要求找到两个有序数组的中位数,最直观的思路有以下两种:

    • 使用归并的方式,合并两个有序数组,得到一个大的有序数组。大的有序数组的中间位置的元素,即为中位数。
    • 不需要合并两个有序数组,只要找到中位数的位置即可。由于两个数组的长度已知,因此中位数对应的两个数组的下标之和也是已知的。维护两个指针,初始时分别指向两个数组的下标 0 的位置,每次将指向较小值的指针后移一位(如果一个指针已经到达数组末尾,则只需要移动另一个数组的指针),直到到达中位数的位置。

    假设两个有序数组的长度分别为 m 和 n,上述两种思路的复杂度如何?第一种思路的时间复杂度是 O(m+n),空间复杂度是 O(m+n)。第二种思路虽然可以将空间复杂度降到O(1),但是时间复杂度仍是 O(m+n)。题目要求时间复杂度是O(log(m+n)),因此上述两种思路都不满足题目要求的时间复杂度。

    如何把时间复杂度降低到 O(log(m+n)) 呢?如果对时间复杂度的要求有 log,通常都需要用到二分查找,这道题也可以通过二分查找实现。根据中位数的定义,当 m+n 是奇数时,中位数是两个有序数组中的第 (m+n)/2 个元素,当 m+n 是偶数时,中位数是两个有序数组中的第 (m+n)/2 个元素和第 (m+n)/2+1 个元素的平均值。因此,这道题可以转化成寻找两个有序数组中的第 k小的数,其中 k 为 (m+n)/2 或 (m+n)/2+1。

    假设两个有序数组分别是 A 和 B。要找到第 k 个元素,我们可以比较 A[k/2−1] 和 B[k/2−1],其中 / 表示整数除法。由于 A[k/2−1] 和 B[k/2−1] 的前面分别有 A[0..k/2−2] 和 B[0..k/2−2],即 k/2−1 个元素,对于 A[k/2−1] 和 B[k/2−1] 中的较小值,最多只会有 (k/2−1)+(k/2−1)≤k−2 个元素比它小,那么它就不能是第 k 小的数了。

    因此我们可以归纳出三种情况:

    1. 如果 A[k/2−1]<B[k/2−1],则比 A[k/2−1] 小的数最多只有 A 的前 k/2−1 个数和 B 的前 k/2−1 个数,即比 A[k/2−1] 小的数最多只有 k−2 个,因此 A[k/2−1] 不可能是第 k 个数,A[0] 到 A[k/2−1] 也都不可能是第 k 个数,可以全部排除。
    2. 如果 A[k/2−1]>B[k/2−1],则可以排除 B[0] 到 B[k/2−1]。
    3. 如果 A[k/2−1]=B[k/2−1],则可以归入第一种情况处理。

    fig1

    可以看到,比较 A[k/2−1] 和 B[k/2−1] 之后,可以排除 k/2 个不可能是第 k 小的数,查找范围缩小了一半。同时,我们将在排除后的新数组上继续进行二分查找,并且根据我们排除数的个数,减少 k 的值,这是因为我们排除的数都不大于第 
    k 小的数。

    有以下三种情况需要特殊处理:

    1. 如果 A[k/2−1] 或者 B[k/2−1] 越界,那么我们可以选取对应数组中的最后一个元素。在这种情况下,我们必须根据排除数的个数减少 k 的值,而不能直接将 k减去 k/2。
    2. 如果一个数组为空,说明该数组中的所有元素都被排除,我们可以直接返回另一个数组中第 k 小的元素。
    3. 如果 k=1,我们只要返回两个数组首元素的最小值即可。

    用一个例子说明上述算法。假设两个有序数组如下:

    A: 1 3 4 9
    B: 1 2 3 4 5 6 7 8 9
    两个有序数组的长度分别是 4 和 9,长度之和是 13,中位数是两个有序数组中的第 7 个元素,因此需要找到第 k=7 个元素。

    class Solution(object):
        def findMedianSortedArrays(self, nums1, nums2):
            """
            :type nums1: List[int]
            :type nums2: List[int]
            :rtype: float
            """
            def getKthElement(nums1, nums2, k):
                n1, n2 = len(nums1), len(nums2)
                index1, index2 = 0, 0
                while True:
                    if index1 == n1:
                        return nums2[index2 + k - 1]
                    if index2 == n2:
                        return nums1[index1 + k - 1]
                    if k == 1:
                        return min(nums1[index1], nums2[index2])
    
                    half = k // 2 
                    newIndex1 = min(index1 + half, n1) - 1
                    newIndex2 = min(index2 + half, n2) - 1
    
                    if nums1[newIndex1] <= nums2[newIndex2]:
                        k -= (newIndex1 - index1 + 1)
                        index1 = newIndex1 + 1
                    else:
                        k -= (newIndex2 - index2 + 1)
                        index2 = newIndex2 + 1
            
            n1, n2 = len(nums1), len(nums2)
            totalLen = n1 + n2 
            res = 0
            if totalLen % 2 == 0:
                res += getKthElement(nums1, nums2, totalLen // 2)
                res += getKthElement(nums1, nums2, totalLen // 2 + 1)
                return res * 1.0 / 2
            else:
                return getKthElement(nums1, nums2, totalLen // 2 + 1) * 1.0
    

    1470. 重新排列数组

    https://leetcode-cn.com/problems/shuffle-the-array/

    给你一个数组 nums ,数组中有 2n 个元素,按 [x1,x2,...,xn,y1,y2,...,yn] 的格式排列。请你将数组按 [x1,y1,x2,y2,...,xn,yn] 格式重新排列,返回重排后的数组。

    示例 1:输入:nums = [2,5,1,3,4,7], n = 3,输出:[2,3,5,4,1,7] 
    解释:由于 x1=2, x2=5, x3=1, y1=3, y2=4, y3=7 ,所以答案为 [2,3,5,4,1,7]
    示例 2:输入:nums = [1,2,3,4,4,3,2,1], n = 4,输出:[1,4,2,3,3,2,4,1]
    示例 3:输入:nums = [1,1,2,2], n = 2,输出:[1,2,1,2]
    提示:1 <= n <= 500,nums.length == 2n,1 <= nums[i] <= 10^3

    题解

    一:非原址排序,O(n)的空间复杂度,O(n)的时间复杂度。

    res[2 * i], res[2 * i + 1] = nums[i], nums[n + i]

    二:转自https://leetcode-cn.com/problems/shuffle-the-array/solution/kong-jian-fu-za-du-wei-o1-de-liang-chong-jie-fa-by/,因为题目限制了每一个元素 nums[i] 最大只有可能是 1000,这就意味着每一个元素只占据了 10 个 bit。(2^10 - 1 = 1023 > 1000)。而一个 int 有 32 个 bit,所以我们还可以使用剩下的 22 个 bit 做存储。实际上,每个 int,我们再借 10 个 bit 用就好了。因此,在下面的代码中,每一个 nums[i] 的最低的十个 bit(0-9 位),我们用来存储原来 nums[i] 的数字;再往前的十个 bit(10-19 位),我们用来存储重新排列后正确的数字是什么。在循环中,我们每次首先计算 nums[i] 对应的重新排列后的索引 j,之后,取 nums[i] 的低 10 位(nums[i] & 1023),这边注意nums[i] & 1023很重要,表示只取低10位,即只取原先的i下标的数字,由于nums[i]的高位有可能已经存放了正确排列后的数字,所以要和1023做&,即 nums[i] 的原始信息,把他放到 nums[j] 的高十位上。最后,每个元素都取高 10 位的信息(e >> 10),即是答案。

    class Solution(object):
        def shuffle(self, nums, n):
    
            for i in range(2 * n):
                j = 2 * i if i < n else (i - n) * 2 + 1 
                nums[j] |= ((nums[i] & 1023) << 10)
    
            for i in range(2 * n):
                nums[i] >>= 10
            return nums

    三:转自https://leetcode-cn.com/problems/shuffle-the-array/solution/kong-jian-fu-za-du-wei-o1-de-liang-chong-jie-fa-by/利用题目中限制每一个元素 nums[i] 都大于 0。我们可以使用负数做标记标记什么?标记当前 nums[i] 存储的数字,是不是重新排列后的正确数字。如果是,存负数;如果不是,存正数(即原本的数字,还需处理)

    我们每次处理一个 nums[i],计算这个 nums[i] 应该放置的正确位置 j。但是,nums[j] 还没有排列好,所以我们暂时把 nums[j] 放到 nums[i] 的位置上来,并且记录上,此时 nums[i] 的元素本来的索引是 j。现在,我们就可以安心地把 nums[i] 放到 j 的位置了。同时,因为这已经是 nums[i] 正确的位置,取负数,即标记这个位置已经存放了正确的元素。只要有原始下标我们每次都能确定当前数值应该存放的下标,挪过去,但是会导致覆盖一个位置,这时我们可以将这个值挪到下标i,即交换两个下标的值,且其原始下标我们也知道,即是j。

    之后,我们继续处理当前的 nums[i],注意,此时这个新的 nums[i],本来的索引是 j。所以我们根据 j 算出它应该存放的位置,然后把这个位置的元素放到 nums[i] 中,取负做标记。

    这个过程以此类推。这就是代码中 while 循环做的事情。

    直到 nums[i] 的值也是负数,说明 i 的位置也已经是重新排列后的正确元素了,我们就可以看下一个位置了。

    在 for 循环中,如果某一个元素已经是小于零了,说明这个位置已经是正确元素了,可以忽略。

    这个算法虽然有两重循环,但是时间复杂度是 O(n) 的,因为每个元素最多会被重新排列一次,然后会被最外面的 for 循环访问一次。一旦重新排列过,for 的访问只是一次 if 判断而已。

    当然,最后,数组中的所有元素还需要从负数转换回正数。

    class Solution(object):
        def shuffle(self, nums, n):
    
            for i in range(2 * n):
                j = i 
                while nums[i] > 0:
                    j = 2 * j if j < n else (j - n) * 2 + 1
                    nums[i], nums[j] = nums[j], nums[i]
                    nums[j] *= -1
            
            return [-1 * num for num in nums]

    1486. 数组异或操作

    https://leetcode-cn.com/problems/xor-operation-in-an-array/

    给你两个整数,n 和 start 。数组 nums 定义为:nums[i] = start + 2*i(下标从 0 开始)且 n == nums.length 。请返回 nums 中所有元素按位异或(XOR)后得到的结果。

    示例 1:输入:n = 5, start = 0,输出:8

    解释:数组 nums 为 [0, 2, 4, 6, 8],其中 (0 ^ 2 ^ 4 ^ 6 ^ 8) = 8 。"^" 为按位异或 XOR 运算符。
    示例 2:输入:n = 4, start = 3,输出:8
    解释:数组 nums 为 [3, 5, 7, 9],其中 (3 ^ 5 ^ 7 ^ 9) = 8.
    示例 3:输入:n = 1, start = 7,输出:7
    示例 4:输入:n = 10, start = 5,输出:2
    提示:1 <= n <= 1000,0 <= start <= 1000,n == nums.length

    题解

    一:暴力解法,一重for 循环遍历所有值做异或,时间复杂度O(n)。

    二:利用异或的性质,转自https://leetcode-cn.com/problems/xor-operation-in-an-array/solution/o1-wei-yun-suan-by-bruceyuj/,XOR 有很多有用的特性:

    我们来看看题目的要求:

    你会发现题目的要求和上面我们列举的特性 3 很像,只是异或元素每次都是递增 2。因此,我们可以对题目进行一次处理,也就是对所有异或元素右移一位,得到 

    相当于我们将最终结果向右移动了一位,那么最后一位是什么呢?
    我们会发现最后一位是由 start 和 数组长度 n 决定的。这是由于 2,4,... 这些转换成二进制后最后一位都是 0。

    • 因此如果 start 是偶数,那么最后一位肯定是 0.
    • 如果 start 是奇数,但是 n 是偶数,这里我们使用特性 1,得到最后一位也是 0.
    • 其他情况下,最后一位是 1.

    class Solution(object):
        def xorOperation(self, n, start):
            """
            :type n: int
            :type start: int
            :rtype: int
            """
            def xor(n, start):
                if start & 1: # 奇数
                    return (start - 1) ^ helper(n + 1, start - 1)
                else:
                    return helper(n, start)
            
            # start 必是偶数
            def helper(n, start):
                if n & 1: # n是奇数, (n - 1)//2 个1异或,(n - 1)//2偶数0,奇数1, 还有最后一个数异或上
                    return ((n // 2) & 1) ^ (start + n - 1)
                else: # n是偶数, n//2 个1异或,n//2偶数0,奇数1
                    return (n // 2) & 1
    
            # 相当于我们将最终结果向右移动了一位,那么最后一位是什么呢?
            ans = 2 * xor(n, start // 2)
            # 我们会发现最后一位是由 start 和 数组长度 n 决定的。
            # 这是由于 2,4,... 这些转换成二进制后最后一位都是 0。
            if start & n & 1:
                ans += 1 
            return ans

    1295. 统计位数为偶数的数字

    https://leetcode-cn.com/problems/find-numbers-with-even-number-of-digits/

    给你一个整数数组 nums,请你返回其中位数为 偶数 的数字的个数。

    示例 1:输入:nums = [12,345,2,6,7896],输出:2
    解释:12 是 2 位数字(位数为偶数),345 是 3 位数字(位数为奇数),  
    2 是 1 位数字(位数为奇数),6 是 1 位数字 位数为奇数) ,
    7896 是 4 位数字(位数为偶数) ,因此只有 12 和 7896 是位数为偶数的数字
    示例 2:输入:nums = [555,901,482,1771],输出:1 
    解释: 只有 1771 是位数为偶数的数字。
    提示:1 <= nums.length <= 500,1 <= nums[i] <= 10^5

    题解:

    一:借助字符串,位数即字符串长度

    class Solution(object):
        def findNumbers(self, nums):
            """
            :type nums: List[int]
            :rtype: int
            """
            return len(list(filter(lambda item: len(str(item)) % 2 == 0, 
                                   nums)))
    class Solution(object):
        def findNumbers(self, nums):
            return sum(1 for num in nums if len(str(num)) % 2 == 0)

    二:log函数

    class Solution(object):
        def findNumbers(self, nums):
            return sum(1 for num in nums 
                        if (int(math.log10(num)) + 1) % 2 == 0)

    1534. 统计好三元组

    https://leetcode-cn.com/problems/count-good-triplets/

    给你一个整数数组 arr ,以及 a、b 、c 三个整数。请你统计其中好三元组的数量。如果三元组 (arr[i], arr[j], arr[k]) 满足下列全部条件,则认为它是一个 好三元组 。

    0 <= i < j < k < arr.length
    |arr[i] - arr[j]| <= a
    |arr[j] - arr[k]| <= b
    |arr[i] - arr[k]| <= c
    其中 |x| 表示 x 的绝对值。返回 好三元组的数量 。

    示例 1:输入:arr = [3,0,1,1,9,7], a = 7, b = 2, c = 3,输出:4
    解释:一共有 4 个好三元组:[(3,0,1), (3,0,1), (3,1,1), (0,1,1)] 。
    示例 2:输入:arr = [1,1,2,2,3], a = 0, b = 0, c = 1,输出:0
    解释:不存在满足所有条件的三元组。
    提示:3 <= arr.length <= 100,0 <= arr[i] <= 1000,0 <= a, b, c <= 1000

    题解

    一:暴力枚举三重循环

    二:借用字典,类似于求三数和以及四数和的。时间复杂度 O(n^2+nS),n 是 arr 的规模,S 是 arr 取值的规模。最终改善效果不明显。依据 jk 的值去界定 i 的范围。其中 rec 记录的是 arr[i]的值,因为 k 总是比 j 大,rec 又总是在 j 循环完美一个 k 的可能性后记录的,及下一次循环时,i 一定比 j 小,也可保证不是同一个下标。可以放心的使用。

    class Solution(object):
        def countGoodTriplets(self, arr, a, b, c):
            """
            :type arr: List[int]
            :type a: int
            :type b: int
            :type c: int
            :rtype: int
            """
            rec = defaultdict(int)
            n, ans = len(arr), 0
            for j in range(0, n):
                for k in range(j + 1, n):
                    if abs(arr[j] - arr[k]) <= b:
                        jl, jr = arr[j] - a, arr[j] + a
                        kl, kr = arr[k] - c, arr[k] + c
                        l = max(max(jl, kl), 0)
                        r = min(min(jr, kr), 1000)
                        if l <= r:
                            r = min(r, 1000)
                            ans += rec[r] - rec[l - 1] if l >= 1 else rec[r]
                for i in range(arr[j], 1001):
                    rec[i] += 1
            return ans

    1460. 通过翻转子数组使两个数组相等

    https://leetcode-cn.com/problems/make-two-arrays-equal-by-reversing-sub-arrays/

    给你两个长度相同的整数数组 target 和 arr 。每一步中,你可以选择 arr 的任意 非空子数组 并将它翻转。你可以执行此过程任意次。如果你能让 arr 变得与 target 相同,返回 True;否则,返回 False 。

    示例 1:输入:target = [1,2,3,4], arr = [2,4,1,3],输出:true
    解释:你可以按照如下步骤使 arr 变成 target:
    1- 翻转子数组 [2,4,1] ,arr 变成 [1,4,2,3]
    2- 翻转子数组 [4,2] ,arr 变成 [1,2,4,3]
    3- 翻转子数组 [4,3] ,arr 变成 [1,2,3,4]
    上述方法并不是唯一的,还存在多种将 arr 变成 target 的方法。
    示例 2:输入:target = [7], arr = [7],输出:true
    解释:arr 不需要做任何翻转已经与 target 相等。
    示例 3:输入:target = [1,12], arr = [12,1],输出:true
    示例 4:输入:target = [3,7,9], arr = [3,7,11],输出:false
    解释:arr 没有数字 9 ,所以无论如何也无法变成 target 。
    示例 5:输入:target = [1,1,1,1,1], arr = [1,1,1,1,1],输出:true
    提示:target.length == arr.length,1 <= target.length <= 1000,1 <= target[i] <= 1000,1 <= arr[i] <= 1000

    思路:

    不写题解了,乍一看这题不好下手但标签是 easy。从测试用例可以大致看到或许看看两个数组排序之后是否相等。事实证明还真是。贴一大佬的题解,https://leetcode-cn.com/problems/make-two-arrays-equal-by-reversing-sub-arrays/solution/kan-zhao-hen-xia-ren-shi-ji-bi-jiao-liang-ge-shu-z/看着很吓人,实际比较两个数组元素是否完全相同(简单证明),

    要是没有样例的启发,这题肯定把我难住了,其实就是判断两个数组元素是否相同。
    证明也很简单,需要知道冒泡排序的过程,如果不知道可以学习一下。
    冒泡排序的所有操作都是不断交换相邻两个元素的过程,交换相邻两个元素的操作也是反转子数组的一种。
    考虑数组target,它一定可以通过冒泡排序变成递增(递减)的数组。假设我们记录下每一次的交换,记为操作序列A。
    考虑数组 arr,它也一定可以通过冒泡排序变成递增(递减)的数组。
    如果target与arr元素相同,那么最终冒泡排序结果也相同。将数组arr进行冒泡排序,再进行操作序列A的逆过程,就一定可以得到target。
    如果数组target的元素与数组arr的元素不同,显然无法通过arr得到target。

    1550. 存在连续三个奇数的数组

    https://leetcode-cn.com/problems/three-consecutive-odds/

    给你一个整数数组 arr,请你判断数组中是否存在连续三个元素都是奇数的情况:如果存在,请返回 true ;否则,返回 false 。

    示例 1:输入:arr = [2,6,4,1],输出:false,解释:不存在连续三个元素都是奇数的情况。
    示例 2:输入:arr = [1,2,34,3,4,5,7,23,12],输出:true,解释:存在连续三个元素都是奇数的情况,即 [5,7,23] 。
    提示:1 <= arr.length <= 1000,1 <= arr[i] <= 1000

    思路

    一:滑动指针,右指针每次均右移。左指针总是挪到最近的偶数位,所以当 r 在奇数位时,此时 r - l 就是目前最长连续奇数的数目。

    class Solution(object):
        def threeConsecutiveOdds(self, arr):
            """
            :type arr: List[int]
            :rtype: bool
            """
            n = len(arr)
            if n <= 2:
                return False
            # l - 偶数所引, 离目前奇数最近的偶数索引
            l = -1
            for r in range(n):
                if arr[r] % 2:
                    # r - 此时是奇数,r - l 就是目前最长的连续奇数位
                    if r - l  >= 3:
                        return True 
                else:
                    l = r 
            return False

    二:看了看题解,用 num 来记录连续奇数的数目,遇到奇数+1,偶数清零。

    class Solution(object):
        def threeConsecutiveOdds(self, arr):
            n = len(arr)
            if n <= 2:
                return False
            num = 0
            for i in range(n):
                if arr[i] % 2:
                    num += 1
                    if num >= 3:
                        return True 
                else:
                    num = 0
            return False

    1122. 数组的相对排序

    https://leetcode-cn.com/problems/relative-sort-array/

    给你两个数组,arr1 和 arr2,arr2 中的元素各不相同, arr2 中的每个元素都出现在 arr1 中, 对 arr1 中的元素进行排序,使 arr1 中项的相对顺序和 arr2 中的相对顺序相同。未在 arr2 中出现过的元素需要按照升序放在 arr1 的末尾。

    示例:输入:arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6], 输出:[2,2,2,1,4,3,3,9,6,7,19]
    提示:arr1.length, arr2.length <= 1000, 0 <= arr1[i], arr2[i] <= 1000, arr2 中的元素 arr2[i] 各不相同, arr2 中的每个元素 arr2[i] 都出现在 arr1 中

    题解

    一:字典+自定义比较函数, 将arr2中的值-索引映射成字典,再将arr1排序后其中不在arr2中的值按递增映射成字典.最后按字典的值排序.

    class Solution(object):
        def relativeSortArray(self, arr1, arr2):
            """
            :type arr1: List[int]
            :type arr2: List[int]
            :rtype: List[int]
            """
            comp = {arr2[i]: i for i in range(len(arr2))}
            arr1 = sorted(arr1)
    
            id_inc = len(arr2)
            for num in arr1:
                if num not in comp:
                    comp[num] = id_inc
                    id_inc += 1
            
            return sorted(arr1, key=lambda a: comp[a])

    二:借鉴大神的计数排序https://leetcode-cn.com/problems/relative-sort-array/solution/ming-que-bi-jiao-fang-shi-hou-xiang-zen-yao-pai-ji/, 这一题第一反应是自定义比较函数,然后再进行排序,但是做完之后参考发现,最简单的是用计数排序,充分利用了题目所给提示信息思路也很清晰,先将arr1中的数全都记录到数组count中,然后遍历arr2的同时,将arr2中的数置入arr1,注意由于arr2中的数在arr1中也出现了,所以直接从count中取出即可处理好arr2之后,再处理剩下的数字,一格一格往里填就好了.

    class Solution(object):
        def relativeSortArray(self, arr1, arr2):
            rec = [0] * 1001
            # 先将arr1中的数全都记录到数组rec中
            for a in arr1:
                rec[a] += 1
    
            ans, i = arr1[:], 0
            # 然后遍历arr2的同时,注意由于arr2中的数在arr1中也出现了,所以直接从count中取出即可处理好arr2之后
            for a2 in arr2:
                while rec[a2] > 0:
                    ans[i] = a2
                    i += 1
                    rec[a2] -= 1
            # 再处理剩下的数字,一格一格往里填就好了
            for num in range(1001):
                while rec[num] > 0:
                    ans[i] = num 
                    i += 1
                    rec[num] -= 1
            return ans

    1337. 方阵中战斗力最弱的 K 行

    https://leetcode-cn.com/problems/the-k-weakest-rows-in-a-matrix/

    给你一个大小为 m * n 的方阵 mat,方阵由若干军人和平民组成,分别用 1 和 0 表示。请你返回方阵中战斗力最弱的 k 行的索引,按从最弱到最强排序。如果第 i 行的军人数量少于第 j 行,或者两行军人数量相同但 i 小于 j,那么我们认为第 i 行的战斗力比第 j 行弱。军人 总是 排在一行中的靠前位置,也就是说 1 总是出现在 0 之前。

    示例 1:

    输入:mat = 
    [[1,1,0,0,0],
     [1,1,1,1,0],
     [1,0,0,0,0],
     [1,1,0,0,0],
     [1,1,1,1,1]], 
    k = 3
    输出:[2,0,3]
    解释:
    每行中的军人数目:
    行 0 -> 2 
    行 1 -> 4 
    行 2 -> 1 
    行 3 -> 2 
    行 4 -> 5 
    从最弱到最强对这些行排序后得到 [2,0,3,1,4]
    示例 2:

    输入:mat = 
    [[1,0,0,0],
     [1,1,1,1],
     [1,0,0,0],
     [1,0,0,0]], 
    k = 2
    输出:[0,2]
    解释: 
    每行中的军人数目:
    行 0 -> 1 
    行 1 -> 4 
    行 2 -> 1 
    行 3 -> 1 
    从最弱到最强对这些行排序后得到 [0,2,3,1]
    提示:m == mat.length
    n == mat[i].length
    2 <= n, m <= 100
    1 <= k <= m
    matrix[i][j] 不是 0 就是 1

    题解

    一:二分法+ 排序, 主要看看排序咋写的,排序有两个值, 以1的个数优先,当1的个数相同时看第二个值,及所在行的下标

    class Solution(object):
        def kWeakestRows(self, mat, k):
            """
            :type mat: List[List[int]]
            :type k: int
            :rtype: List[int]
            """
            m, n = len(mat), len(mat[0])
            rec = {}
    
            for i in range(m):
                l, r = 0, n
                while l < r:
                    mid = l + (r - l) // 2
                    if mat[i][mid] == 1:
                        l = mid + 1
                    else:
                        r = mid
                rec[i] = l    
            
            return sorted(range(m), key=lambda x: (rec.get(x), x) )[:k]

    268. 缺失数字

    https://leetcode-cn.com/problems/missing-number/

    给定一个包含 0, 1, 2, ..., n 中 n 个数的序列,找出 0 .. n 中没有出现在序列中的那个数。

    示例 1:输入: [3,0,1],输出: 2
    示例 2:输入: [9,6,4,2,3,5,7,0,1],输出: 8
    说明:你的算法应具有线性时间复杂度。你能否仅使用额外常数空间来实现?

    题解

    一:数学魔法,求和操作缺了谁一目了然

    class Solution(object):
        def missingNumber(self, nums):
            """
            :type nums: List[int]
            :rtype: int
            """
            res = 0
            for i in range(len(nums)):
                res ^= i 
                res ^= nums[i]
            res ^= len(nums)
            return res

    二:异或操作,记异或魔法

    class Solution(object):
        def missingNumber(self, nums):
            ans = 0
            for i, num in enumerate(nums):
                ans ^= i 
                ans ^= num
            ans ^= len(nums)
            return ans 

     

    展开全文
  • 口书明A T I仁别T 技 术C 语言数组在使用 常见 的几种错误刘莉娜(包头农牧学校 0 14030)摘 要: 对C 语言的数组在定义和使用过程出现的几种错误进行了讨论,指出了出错的原因,并举例分析具体说明,给出正确结论...
  • 链接:寻找两个有序数组位数 来源:LeetCode 2. 题目说明 给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。 请你找出这两个有序数组位数,并且要求算法的时间复杂度为 O(log(m + n))。 你可以假设 nums1 ...
  • 如何区分 引用数组数组引用 ...而下列中由于括号,array先与&结合,确定array为一个引用,然后与[]结合,该引用指向一个数组,再然后,该数组的元素为int,所以为数组引用,即数组的引用。 int (&a
  • 数组 题目

    2016-06-22 21:38:24
    1. 数组通常具有的两种基本操作是查找和修改  ...下列说明汇总可以作为对应的形参变量说明的是()。 int D[4][] int *s[8] int(*s)[8] int D[][8] C,D int *s[8]; //定义一个指针
  • JS数组中的 splice() 方法 一、语法以及描述 说明:通过添加、删除、修改元素来修改数组 语法:Array.splice(start[, deleteCount[, item1, …]]) 参数: start : 开始位置 deleteCount : 删除的元素个数 item, ...
  • 如何在MySQL存储数组(list)?

    万次阅读 2019-08-15 11:57:11
    我在MySQL有两个表。表Person具有以下列: id | name | fruits 水果列可以包含空或像(‘apple’,’orange’,’banana’)或(‘strawberry’)等的字符串数组。第二个表是Table Fruit,有以下三列: _________...
  • 指针数组:正如可以创建整型数组,也可以创建指针数组。指针数组数组,是一个存放指针的数组。请看下列例子:int *arr1[10];char **arr2[10];两个都是指针数组数组指针:数组也是一种类型,也可以创建数组指针。...
  • (3)数组

    2018-03-18 18:41:57
    数组的类型可以是任意类型,不过数组中的元素类型必须是相同的。数组的元素是有序的,按照索引的顺序。2.数组的元素可变不?数组的长度属于哪个属性?数组下标范围是?数组一旦声明就不能更改,长度属性为length,...
  • c语言习题集合(数组

    千次阅读 2020-03-31 21:50:21
    1 选择题 以下关于数组的描述正确的是( )。 A. 数组的大小是固定的,但可以有不同的类型的数组元素 B. 数组的大小是可变的,但所有数组元素的类型必须...以下对一维整型数组a的正确说明是( )。 A.int a(10); B. i...
  • bool类型数组如果数组a的所有元素的值都为0,那么下列函数返回true;如果数组的所有bool has_zero(int a[], int n) { int i; int zeroflag=0; int unzeroflag=1; for (i = 0; i < n; i++) { zeroflag=zeroflag ||...
  • 数组中&a与&a[0]的区别

    万次阅读 多人点赞 2017-07-09 10:34:57
     【摘自牛客网】下列代码的结果是:(正确答案是 C)main() { int a[5]={1,2,3,4,5}; int *ptr=(int *)(&a+1); printf("%d,%d",*(a+1),*(ptr-1)); } A、3,5 B、2,4 C、2,5 D、3,4  下面我们来分
  • 实际上,二维数组是以一维数组为元素构成的数组,要将d说明成大小为(1 0,2 0)的二维整型数组,可以写成:int d[10][20]请留心上面的说明语句, C不像其它大多数计算机语言那样使用逗号区分下标,而是用方括号将各维...
  • 2. 一维数组的定义方式为: 类型说明数组名 [整型常量表达式] 3. 以下能对二维数组a 进行正确初始化的语句是: A) int a[2][]={{1,0,1},{5,2,3}}; B) int a[][3]={{1,2,3},{4,5,6}}; C) int a[2][4]={{...
  • VB6数组赋值的限制

    千次阅读 2012-08-20 08:53:39
    (由于用得不是很多,所以干脆记下来免得下次用到时又忘了.)MSDN有个错误是"不能给数组赋值",即不能将整个数组指定给另一个数组....以下说明一下可以赋值的情况:[codes=vb] Private Type MyType kk(10...
  • 下列说明汇总可以作为对应的形参变量说明的是()。 int D[4][] int *s[8] int(*s)[8] int D[][8]答案:CD 错选:D 二维数组在内存也是连续存储的,他可以通过 arr[i][j]寻址是因为我们定义了...
  • 数组引用 C++ 数组做参数 深入分析
  • 数组引用 C 数组做参数 深入分析

    千次阅读 2018-11-06 15:22:26
    数组引用 C 数组做参数 深入分析
  • 定义:float a[15]; 则数组a可引用的元素有(). A) a[1]~a[15] B) a[0]~a[15] C) a[1]~a[14] D) a[0]~a[14] ...以下程序段给数组所有元素输入数据...应在园括号填入的是: A) a+(i++) B) &a[i+1] C) a+i
  • C++面试题-指针-指针数组数组指针

    千次阅读 2019-01-11 00:16:33
    C++面试题-指针-指针数组数组指针 问:int (*p)[n]与int *p[n]的区别? 答: int (*p)[n]是数组指针,指向某n个元素所组成的整块的数组,返回值是整型指针类型的。 int *p[n]是指针数组,指向数组里面的每个...
  • 根据自己学习的来写,如果有什么不对或...定义:Javascript看起来像数组却又不是数组的对象,将其称为类数组。2.类数组的特点有: 1.具有length属性 2.具有方括号语法([]) 3.不具有数组所具有的方法,eg:push,s...
  • 实际上,二维数组是以一维数组为元素构成的数组,要将d说明成大小为(10,20)的二维整型数组,可以写成:int d[10][20]请留心上面的说明语句, C不像其它大多数计算机语言那样使用逗号区分下标,而是用方括号将各维...
  • C语言再学习 -- 数组和指针

    千次阅读 2016-08-30 16:12:22
    以上数组声明包括数组元素的数目和元素的类型。数组元素按顺序存储于内存,通过使用整数索引(或偏移量)来访问。在C,首元素的索引值为0,因此包含n个元素的数组的末元素的索引为n-1。 2、数组初始化 A、可以...
  • C语言数组的总结

    2018-03-31 18:10:59
    (2)数组的分类:数值数组、字符数组、指针数组、结构数组等。2.一维数组(1)创建: 数据类型 数组名[数组长度]如:int a[100];//定义了长度为100的整型数组,下标从0到99。、注意:数组在创建时,一般要给...
  • "数组引用"以避免"数组降阶"(本文曾...数组降阶是个讨厌的事,这在C语言中是个无法解决的问题,先看一段代码,了解什么是"数组降阶" #include using namespace std; void Test( char array[20] ) {  cout
  • 数组与指针

    2016-07-18 18:48:44
    1、一维数组 int array[10]; int *ap = arrary + 2; ap这个很容易,你只要阅读它的初始化表达式就能得到答案:array+2.另外,&array[2]也是与它对等的表达式。 *ap这个也很容易,间接访问跟随指针访问它所指向的位置...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 43,155
精华内容 17,262
关键字:

下列数组说明中正确的是