携程定飞机票怎么取:5.1 单项选择题

    5.1  单项选择题

    1．设有定义“int a＝3， b，*p＝&a；”，则下列语句中使 b不为3的语句是（   ）
    ① b＝* &a；     ② b＝* p；    
    ③ b＝a；     ④ b＝*a；
      【解】定义有 int a＝3， b，*p＝&a;对b赋值的表达式有*&a、*p、a 、*a。引用变量。的值有两种方法，一是直接引用a，二是通过a的指针间接引用a。对于后者，又有多种表达方法，通过指向a的指针p，间接引用a的内容，如*p。或通过求地址运算符由变量a得到其指针&a，再由这指针表达式间接引用 a的内容，如* &a。所以表达式*&a、*p和a都能引用变量a的值，而使b的值为3。而表达式。a是错误的，因为a不是指针变量，不能对它施行取内容运算符。。所以解答是④。

         2 ．设指针x指向的整型变量值为25，则"printf("%d\n"，++ *x);"的输出是（  ）
           ① 23          ② 24           ③ 25           ④ 26
      【解】若指针变量x指向某个变量，例如指向变量v，并且变量v的值是25，则表达式++ *x的值是26。这是因为表达式的计算顺序可加圆括号表达成(++(*x))，首先是*x，是对X所指变量V的引用，所以++ *X就是++V。++V是先让变量V增1，并以增至后的V的值为表达式++V的结果，所以其值是 26。所以解答是④。

       3．若有说明：“ int i,j＝ 7，*p＝&i；”，则与“ i＝j；”等价的语句是（  ）

    ①i＝*p；          ②*P＝* &j；
    ③i==&j；           ④i＝* *p;
    【解】指针变量 p指向变量i时，表达式i=*p等价于 i＝i；表达式*p＝*&j等价于i＝j；而表达式i＝&j企图将整型变量的指针赋给整型变量，这是错误的；表达式i=* *p也是一种错误的表达式。p是指针，*p是p所指变量j，* *p是企图将整型变量j当作指针，并想通过j间接引用某个变量。所以解答是②。

        4．若有说明语句“int a[10]，*p＝a；”，对数组元素的正确引用是（  ）
    ①a[p]             ②P[a]             
    ③*(P＋2)              ④P＋2
     【解】在 C语言中，约定数组名单独出现在表达式中时，它表示数组首元素的指针。有int a[10] ，则a可以作为&a[0]使用。另有整型指针变量p，代码p＝a实现p指向数组a的首元素。则表达式*(p＋2)是引用数组元素a[2]。表达式a[p]和p[a]都是不正确的，下标必须是整型表达式，不可以是指针表达式。表达式p＋2是指针表达式，它的值是&p[2]。所以只有表达式*(p＋2)引用数组a的元素a[2]。所以解答是③。

          5．下面各语句中，能正确进行赋字符串操作的语句是（  ）
         ①char s[5] ={"ABCDE"};            ②char s[5] ={‘A‘,‘B‘,‘C‘,‘D‘,‘E‘};
      ③ char *s；s＝"ABCDE"；           ④ char *s；scanf("%s"， &s)；
    【解】字符串最终存储于字符数组中，存储字符串的字符数组可以是程序主动引入的（定义或动态分配），也可以是字符串常量，由系统分配。其中字符数组用字符串初始化就是字符串存储于由程序引入的字符数组的例子。给字符指针赋字符串则是系统自动分配字符率存储空间的例子。给字符指针赋字符串并不是将一个长长的字符串存于字符指针变量中，而是将字符串常量存储于常量区，并将存储这个字符串的首字节地址赋给指针变量，让指针变量指向字符率常量的首字符。对于以字符串作为字符数组初值的情况，要求字符数组足够的大，能存得下字符串常量。这里有一个特别的规定，若数组的大小少于存储字符串有效字符的字节个数，系统将报告错误；当字符数组的大小只能存储字符串的有效字符，而不能存储字符率结束标记符时，则存储于字符数组中的内容是字符序列，因没有存储字符率结束标记符，存储的内容就不是字符串。如代码char a[5]＝"ABCDE"。另外，给字符数组元素逐一赋字符初值，并在字符初值中没有字符串结束标记符，则存于字符数组中的内容也不是字符串。如代码 char s[5]={‘A‘，‘B‘，‘C‘，‘D‘，‘E‘}。特别要注意当字符指针还未指向某个字符数组的元素时，不可以通过字符指针输入字符串。如代码char *s；scanf("%s"，s)。若写成char *str；scanf("%s"，&str)更是错误的了。由于C语言规定数组不能相互赋值，所以只能将字符串常量赋给某字符指针。如代码char *s；s＝"ABCDE"是正确的。实际上，字符率"ABCDE" 被存储于常量区中，向指针变量赋的是字符指针，让s指向其中的字符‘A‘。所以解答是③。

         6．若有以下定义，则不能表示a数组元素的表达式是（）
         int a[10]＝｛1，2，3，4，5，6，7，8，9，1o},*p＝a；
                   ①*p           ② a[10]             ③*a              ④ a[p-a] 
       【解】上述代码定义了有10个元素的整型数组。，和定义指针变量p，并让p指向数组元素a[0]。所以代码*p是引用 a[0]。由于数组a只有10个元素，最后一个元素是a[9]，表达式a[10]是错误的。数组名a可以作为a的首元素的指针，表达式*a就是a[0] ，是对数组a的首元素a[0]的引用。指针p的值是a，表达式p-a。的值是0，所以a[p－a]就是a[0]。所以解答是②。

          7．若有以下定义，则值为3的表达式是（）

   int a[]＝ {1，2，3，4，5，6，7，8，9，10}，*p＝a；
    ①p＋＝2,*(p++)           ③p＋＝2，* ++p
    ③p＋＝3，*p++           ④ p＋＝2，++ *p
      【解】数组a有10个元素，分别有值1至10，指针变量p指向a[0] ①逗号表达式 p＋＝2，*(P++)，先是P＋＝2使P指向a[2]，接着是*(P++)，以当时P所指变量a[2]取内容3为表达式的值，同时使p指向a[3]。②返号表达式p＋＝2，* ++p，先是p＋＝2使p指向a[2]，以后是* ++p，又使 p增1，让它指向a[3]，并取指针p所指变量a[3]的内容4作为表达
式的值。③逗号表达式 p＋＝3，*p++，先是p+=3使p指向a[3]，以后是*p++，表达式的值是 a[3]为 4，而使p指向a[4]。④逗号表达式p＋＝2，++ *p，先是p＋＝2，使p指向a[2]，以后是++ *p，因当时的*p就是 a[2]，++a[2]使a[2]增1，变成4，并以4为表达式的值。所以只有p＋＝2，*(p++)的值是3。所以解答是①。

      8．设有定义“char a[10]={"abcd"}，*p=a；"，则*(p＋4)的值是（  ）
    ①"abCd"              ②‘d‘
    ③‘\0‘              ④不能确定
 【  解】若有char a[10]＝"abcd"，*p＝a，则指针变量p指向a[0]。在表达式*(p＋4)中，p＋4指向a[4]，*(p＋4)就是a[4]。由于用字符"abcd" 给字符数组a赋初值，a[4]的值是字符串结束标记符‘\0‘。所以解答是③。

       9．设有代码"int(*ptr)[10]；”，其中的ptr是（  ）
    ①10个指向整型变量的指针
    ②指向10个整型变量的函数指针
    ③一个指向具有10个元素的一维数组的指针
    ④具有10个指针元素的一维数组
     【解】代码“int(*ptr)[10]；”的分析过程是，因圆括号，括号内的ptr先与字符*结合，字符*修饰标识符ptr是一种指针；接着与后面的一对方括号结合，表示是这样的一种指针，是指向一维数组的；再有方括号中的10，说明这种数组有10个元素。至此，ptr是指向含10个元素的一维数组的指针。最后，是最前面的int，表示数组元素是int类型的。所以，ptr是一个指向具有10个int型元素的一维数组的指针。所以解答是③。另外，要是①，10个指向整型变量的指针，就是一个指针数组，上述代码应写成“int *ptr[10]；”，即ptr是一个有10个指向整型变量的数组。要是②，返回值是指向10个整型变量的函数的指针，上述代码应写成“int(*(*ptr)())[10]；”，即ptr是指针，指向一种函数，函数的返回值又是一种指针，指向10个元素的数组，数组的元素是整型的。下面的代码是这样的函数指针和函数的例子：
        # include 
    int a[][10]={{1，2，3，4，5，6，7，8，9，0} ，{0，1，2，3，4，5，6，7，8，9} }；
     int(*(*ptr)(int))[10]；
     int(*f( int n))[10] 
     {return a＋n；
      } 
    void main()
    { int(*p)[10]，*q；
      ptr＝f；/*让ptr指向函数f*/
      P＝(*ptr)(0)；

   q=*p；
      printf("%d\n", *p)；
     P＝(*ptr)(l)；
     q=*p；
     printf("%d\n", *q)；
     }
    在上述代码中，函数有一个int型的形参。要是④，其意义与①相同，上述代码应写成“int* ptr[10]；”，即 ptr是一个有10个元素的数组，数组元素是指向整型变量的指针。

        10．若有以下定义，则数值为4的表达式是（  ）
     int w[3][4]＝{{0，1}，{2，4}，{5，8}}，(* p)[4]＝ W；
                   ①*w[1]＋l          ②p＋＋，*(p＋1)           ③w[2][2]                ④p[1][1]
      【解】二维数组定义有多种赋初值的办法，问题给出的代码是按行给数组的部分元素赋初值。它们分别是w[0][0]＝0．w[0][1]＝1、w[1][1]=2．w[1][1]=4,w[2][0]=5,w[2][1]＝8。根据约定，未指定初值的元素自动置全0值。指针变量p是一个指向具有四个int型元素的一维数组的指针，定义时的初值使它指向数组W的第一行。①的代码，*w[1]+1中的W[l]是指向 w[l][0]的指针，*w[1] 就是w[1][0]，其值是2，*w[1]＋l的值是3。②的代码是逗号表达式，“p＋＋，*(p＋1)”先使p指向数组w的第二行，*(p＋l)中的p＋l是指向数组w的第三行，*(p＋1)是指针值，指向数组w的第三行的第一个元素，即&w[2][0]. ③的代码w[2][2]引用数组W第三行的第三列元素，其值是0。④的代码p[1][l]引用数组W第二行的第二列元素w[1][1]，其值是 4。所以解答是④。

         11．若有下面的程序片段，则对数组元素的错误应用的是（  ）
        int a[12]＝{0},*p[3], * *pp，i；
        for( i＝0；i<3；i++) p[i]=&a[i＋4]；
        pp= P；
    ①pp[0][1]            ②a[10]
    ③ p[3][l]           ④*(*(p＋2)＋2) 
        【解】上述代码定义变量a是有12个整型元素的数组，它的初值全是0。p是有三个元素的指针数组，每个指针能指向整型变量。**pp是指针的指针，它能指向一个指向整型变量的指针， i是一个整型变量。执行代码for(i＝0；i<3；i++) P[i]＝&a[i+4] 使指针数组 p的元素 p[0]指向 a[4] ，p[l]指向a[5] ，p[2]指向 a[6]。代码pp＝p使指针变量pp指向p[0]。①代码pp[0][l] 用指针表达可等价地写成*(*pp＋l)。其中*pp就是 p[0]，p[0]的值是&a[4]，*pp+1的值是&a[4]＋1=&a[5]，*(*pp+1)就是a[5]。②代码a[l0] 当然是引用数组a的元素。③代码p[3][1]数组p只有三个元素，没有p[3]，所以是错误的。④代码*(*(p＋2)＋2)中的(p＋2)是 &p[2]，*(p＋2)是 p[2]，其值是&a[6],*(p＋2)＋2的值是&a[8]，*(*(p＋2)＋2)引用的是a[8]。所以解答是③。

        12．若有如下定义和语句，则输出结果是（  ）
        int * *pp， *p，a＝10，b＝20；
       PP=&p； P＝&a； P＝&b； printf("%d%d\n"，*p，* *PP)；
    ①10， 20                 ② 10， 10                
    ③ 20， 10                 ④ 20， 20
      【解】上述代码定义变量pp是指针的指针，它能指向一个指向整型变量的指针。定义变量p是指针，它能指向一个整型变量。a是一个整型变量，它有初值10。b也是一个整型变量，它有初值20。代码 pp=&p 使pp指向p，p＝&a使p指向a，p＝&b又使p指向b，不再指向a。所以。p是引用b，其值为20。* *pp是通过pp间接引用p，再通过p间接引用b，所以也是20。所以解答是④。

    13．若有以下定义和语句，则对w数组元素的非法引用是（  ）
    int w[2][3]，(* pw)[3]； pw＝ w；
    ① *(w[0]＋2)              ②*pw[2]          
    ③pw[0][0]             ④*(pw[l]+2) 
        【解】上述代码定义2行3列的二维数组w，定义能指向有3个整型元素一维数组的指针pw，并让pw指向数组w的第一行。①代码*(w[0]＋2)中的w[0]是&w[0][0]，w[0]＋2是&w[0][2]，所以*(w[0]＋2)就是w[0][2]。②代码*pw[2]中的pw[2]是&w[2][0]，该数组w只有2行，没有w[2][0]，所以代码*pw[2]是对数组W元素的非法引用。③代码pw[0][0]就是w[0][0]。④代码*(pw[l]＋2)中的pw[1]就是*(pw＋l)，即&w[l][0]，pw[l]＋2就是&w[l][2]，所以*(pw[1]＋2)就是w[1][2]。所以解答是②。

    5.2    填充题

    1．“* ”称为___________运算符，“&”称为_________运算符。
      【解】单目运算符“*”称为取内容运算符，单目运算符“&”称为取地址运算符。

         2．若两个指针变量指向同一个数组的不同元素，可以进行减法运算和___________运算。
      【解】若两个指针变量指向同一个数组的不同元素，可以进行减法运算求它们所指元素相差多少元素。进行关系运算，判定它们所指元素的前后，或是否指向同一个元素等。

           3．设 int a[10] ，*p＝a；则对a[3]的引用可以是p[______________] 和*(p_________)。
     【解】若指针p指向数组a的首元素，则引用a[3]用指针p可以写成p[3]和*(p＋3)。

           4．若d是已定义的双精度变量，再定义一个指向d的指针变量p的代码是___________。
     【解】若d是一个双精度变量，定义能指向它的指针变量p可以用以下代码double *p＝&d。

            5．&后跟变量名，表示该变量的________＿；*后跟指针变量名，表示该指针变量_______。&后跟的是指针变量名，表示该指针变量的_____________。
      【解】单目运算符&是取地址运算符，&后跟变量名，就表示该变量的地址。单目运算符*是取内容运算符，*后跟指针变量名，表示该指针变量所指变量的内容。若&后跟的是指针变量名，就表示该指针变量的地址。若知道指针变量的地址，欲通过指针变量的地址引用指针变量所指变量的内容，需要连续两次取内容运算。

          6．设有char *a＝"ABCD"，则printf("%s"，a)的输出是_______；而printf("%c"，*a)的输出是______。
    【解】若给字符指针变量a赋一个字符串常量"ABCD"，实际上是给a赋指向字符串常量首字符‘A‘的指针。程序通过它访问字符串中的各字符。如用代码printf("%s"，a) 输出这个字符串常量"ABCD"的字符列ABCD，用代码printf("%c"，*a)输出a所指的字符 A。

           7．设有以下定义和语句，则*(*(p＋2)＋l)的值为__________。
      int a[3][2]={10，20，30，40，50，60}，(*p)[2]；
      p= a；
    【解】上述代码定义3行2列的二维数组a ，定义指向两个元素的一维数组指针p，并让p指向二维数组a的首行。则代码*(*(p＋2)＋l)中的p＋2指向二维数组a的第2行a[2]，*(p＋2)指向a[2][o]，*(p＋2)+l指向a[2][l]，*(*(p＋2)＋l)是引用a[2][l]，其值是60。

        8．以下程序的功能是从键盘上输入若干个字符（以回车符作为结束）组成一个字符串存入一个字符数组，然后输出该字符数组中的字符串。请填空。
       # include 
       # include 
       main()
      { char str[81]，*sptr；
        int i；
        for(i＝0；i<80；i++)
      { str[i]=getchar()；if(str[i]＝＝‘\n‘) break;}
        str[i]＝____________;
        sptr＝str；
        while(* sptr) putchar(* sptr______________);
      }
        【解】从键盘输入字符行，通过循环逐一输入字符，当发现输入字符是换行符时，结束循环。为了使输入的字符列变成字符串，必须在输入字符列之后，原存储换行符的元素改为存储字符串的结束标记符，需用代码 str[i]＝‘\0‘ ，所以在第一框填入代码‘\0‘。当要将存于字符数组str中的字符串通过循环逐一输出字符串的字符时，可以用字符指针sptr，让sptr遍历整个字符串，每次循环时，输出sptr所指字符，并让sptr增1，即可用代码*sptr++实现，所以在第二框填入代码++。

    5.3  程序分析题

1．阅读下列程序，写出程序的输出结果。
    main() 
    {char *a[6]={"AB","CD","EF","GH",U","KL"}；
     int i;
     for(i＝0；i<4；i++) printf("%s"， a[i])；
     printf("\n")；
   }
      【解】程序定义了有六个元素的字符指针数组a ，数组a 的各元素指向字符率常量。程序的for循环遍历了a的前四个元素，用字符率输出格式，输出指针数组a前四个元素所指的字符串。所以程序输出： ABCDEFGH。

        2．阅读下列程序，写出程序的主要功能。
    main()
    { int i，a[l0]，*p＝&a[9] ；
     for(i=0；i<10；i++) scanf("%d"，&a[i])；
     for(； p>=a； p--) printf("%d\n"，*p) ；
    }
        【解】程序定义了有10个元素的整型数组a，另定义指针变量p，并让它指向a的最后一个元素a[9]。执行代码的第一个循环是顺序输人数组a的10个元素。第二个循环利用指针p逆序遍历数组a，将数组a的各元素逆序输出。所以程序的功能是输入10个整数，并逆序输出这10个整数。

        3．阅读下列程序，写出程序运行的输出结果。
     char s[]＝"ABCD"；
  main()
    { char * p；
     for( p＝s；p< s＋4；p++) printf("%s\n"， p)；
    }
      【解］程序定义了一个字符数组s，由给它所赋的字符串初值知，该数组只有五个元素。程序另定义了字符指针变量p。循环开始时，先让p指向数组的首元素。循环每次输出以p所指字符为首字符的字符串，并让它指向下一个字符。如此反复循环四次，所以程序输出以下内容：
       ABCD
       BCD
       CD
       D

        4．阅读下列程序，试写出程序运行的结果。
     main()
     {int i,b，c，a[]＝{1，10,-3，-21，7，13},*p_b,*p_c;
     b=C=1；p_b＝p_C＝ a；
     for(i＝0；i<6； i++)
    { if(b<*(a＋i)) {b＝*(a＋i)； p_b＝&a[i]； }
      if(c>*(a＋i)) {c＝*(a＋i)； p_c＝&a[i]； }
    }
   i＝*a；*a＝*p_b；*p_b＝i；i=*(a＋5)；*(a＋5)＝*p_c；*p_c＝i；
    printf("%d，%d，%d，%d，%d，%d\n"， a[O]，a[1]，a[2]，a[3]，   a[4]， a[5])；
    }
      【解］程序定义了一个整型数组。，由给它所赋的初值知，该数组有六个元素。程序另定义了三个整型变量i．b、C和两个指针变量p_b．p_c。程序首先置变量b和C都为1，p_b和p_c都指向数组a 的首元素a[0]。接着执行六次循环，循环体由两个if语句。第一个if语句是当 b的值小于*(a＋i)（就是a[i])时，将*(a＋i)的值复制到b，并让p_b指向a[i]。这是在a中找最大值，将最大值存于b，最大值元素的指针存于指针变量p_b。第二个if语句是当c的值大于*(a+i)(就是a[i])时，将*(a＋i) 的值复制到c，并让p_c指向a[i]。这是在a中找最小值，将最小值存于c，最小值元素的指针存于指针变量p_c。循环结束后的前三个语句实现最大元素与a[0]交换。接着三个语句是在已经过前面交换的基础上，将最小元与a[5]交换。最后程序顺序输出数组a的六个元素。所以程序输出内容是：
             13， 10，-3， l， 7，-21。
    若数组a的初值由输入任意指定，上述程序对一种特殊情况不能完成功能的要求，即最小元素若是a[0]，p_c所指元素已被移到p_b指针所指位置，实际与a[5]交换的不再是数组中的最小元素，而是最大元素。

    5.4  程序设计题

      1．输人3个整数，按从大到小顺序输出。
     【解】存储输入的三个整数可用三个简单变量，也可用数组。设用三个简单变量x,y,z存储输入的三个整数。另设若干个指针变量指向存储输入数据的变量。实现从大到小输出三个整数有多种方案，如通过比较交换变量的值，多次比较交换使变量满足条件x>=y>=z。这样，变量的输入值可能会与它的输出值不一样。如通过比较交换指针变量，当比较后发现要交换时，就交换变量的指针，而不交换变量的值，则在比较结束后，变量的值没有改变，但从指针方向来看，它们的值是从大到小排列的。下面的程序就采用这种方案。
      # include 
        main()
       { int x，y，z；
    int *big=&x，*mid=&y，*sma=&z，/*置三个指针变量分别指向x，y, z*/
    *temp；
     printf("Enter x，y，z．\n")；
     scanf("%d%d%d"， big，mid，sma)；/*顺序为变量x，y，z输入值*/
  if(*big< *mid) {temp＝big；big＝mid； mid＝temp； }/*使*big>=*mid*/
  if(*big<*sma) { temp＝big；big＝sma；sma＝temp； }/*使*big>=*sma*/
  if(*mid<*sma){temp＝mid;mid=sma;sma=temp; }/*使*mid>=*sma*/
  printf("%d\t%d\t%d\n"， x，y，z);/*按输入顺序输出x，y，z*/
  printf("%d\t%d\t%d\n"，*big，*mid，*sma)；/*按从大到小的顺序输出*/
   }

          2．编一个程序，输入15个整数存入一维数组，再按逆序重新存放后再输出。
       【解】输入数组的元素，并重新颠倒存放后输出。将存储于数组中的元素颠倒存储，只要首尾相对应的元素两两交换即可。若用指针实现，可让一个指针p指向前端的元素，另一个指针q指向与前端元素对应的后端的元素。循环前，让p指向数组的首元素，让q指向数组的末元素。循环时，让p和q所指两个元素交换，并让p增1，q减l。循环条件是p所指元素在前，q所指元素在后，即p＜q。程序如下：
        # include 
        main()
      { int a[15]，*p，*q， temp；
       printf("Enter 15 numbers．\n")；
       for(p＝a；p＜a＋15；p＋＋) 
       scanf("%d"， p)；
       for(p＝a，q＝a＋14；p＜q；P++，q--) { 
       temp＝*p; *p＝*q;*q=temp；
      }
      for(p＝a；pp++) 
      printf("%d\t"，*p)；

   printf("\n")；
     }

          3．输入一个字符串，按相反的次序输出其中的全部字符。
      【解】要相反的次序输出字符串的全部字符，可用一个字符指针变量，从指向字符串的本字符开始，逆序遍历字符串，输出指针所指字符即可。但为了让字符指针指向字符串的末字符，若不用字符串处理库函数，得用一个循环，让它从字符串的首字符开始，顺序移至字符串的结束标记符，然后倒退一个字符，就能让它指向字符串的末字符。程序如下：
      # include
      # define N 200
      main()
     { char s[N]，*p；
     printf("Enter a string．\n")；
     scanf("%s"， s)；
     for(p＝s；*p； p++)；
     for(p--； p>=s； p--)
     printf("%c"，*p)；
     printf("\n")；
     } 

          4．输入一个一维实型数组，输出其中的最大值、最小值和平均值。
      【解】设实型数组的元素个数n不超过20。程序输入n，并用循环输入数组的元素，再用循环遍历数组，求出数组的最大值和最小值、数组元素的和。然后求出数组元素的平均值，最后输出结果。程序如下：
        # include
       # define N 20
      main()
    { double a[N]，max,min,ave,*p, t；
      int n；
      printf("Enter n(0＜n＜20)．\n")；
      do{
     scanf("%d"，&n)；
    if(n>0 && n<20) break；
    printf("n值不合要求，请重新输入！\n")；
    } while(l)；
    printf("输入%d个实数\n"， n)；
    for(n＝a；n p++){ 
    scanf("%lf"，&t)；*p＝t；
   } 
   max＝min＝ave=*a;
   for(p＝p+l；p p++){ 
   if(max<*p) max＝*p；

if(min>*p) min＝*p；
 ave＋＝*p；
 }
 ave/＝n；
  printf("最大值：%f\t最小值：%f\t平均值：%f\n"，max，min，ave)；
  }

           5．输入一个3×6的二维整型数组，输出其中的最大值、最小值及其所在的行列下标。

   【解】找出其最大值和最小值，及它们的行列位置。采用按行按列顺序遍历数组的方法找出数组的最大值、最小值，以及它们在数组中的位置指针。输出时，将位置指针转换成行下标和列下标。程序如下：
    # include 
    # define N 3
    # define M 6
    main()
   { int a[N][M]，*maxp,*minp，*q,t；
   printf("输入%d个整数\n"， N*M)；
   for(q＝a[0]；q<*a＋N*M；q++) {
   scanf("%d"，&t)；*q＝t；
   }
   maxp=minp=*a; 
   for(q＝a[0]；q<*a＋ N*M； q++) {
  if(*maxp<*q) maxp=q；
  if(*minp>*q) minp＝q；
  }
   printf("最大值：%d它的行下标是%d它的列下标是%d\n"，
  *maxp,(maxp-*a)/M，(maxp-*a)%M)；
   printf("最小值：%d它的行下标是%d它的列下标是%d\n"，
   *minp,(minp-*a)/M，(minp-*a)%M；
   }

         6．输入三个字符串，找出其中最大的字符串。
      【解】将输入的三个字符率分别存于三个一维字符数组中，另用一个字符指针数组，分别指向这三个字符串，然后用循环控制这三个字符串的比较，找出最大的字符串。两字符串比较时，程序不用标准库函数，而用两字符串的对应字符比较来实现。完整程序如下：
    # include 
    # define N 120
    # define M 3
    mian()
   { char s1[N], s2[N],s3[N],*strs[M]={s1,s2,s3}，*p，*q，*ms;
     int i；
    printf("输入%d个字符串\n", M) ；

  for(i＝ 0； i i++)
    scanf("%s"，strs[i])；
    ms＝strs[0]；
    for(i=1；i i++) {
    for( p=ms，q=strs[i]；*p! ＝‘\0‘ && *p＝＝*q；p++，q++)；
    if(*p<*q) ms＝strs[i]；
    }
    printf("最大字符串：%s\n"，ms)；
   }

         7．输入两个字符串，将它们连接后输出。
     【解】程序设有两个存储字符串的数组，先输入两个字符串，然后找到第一个字符串的末尾，接着将第二个字符串复制在第一个字符串的后面，然后输出。程序如下：
     # include 
     # define N 120
    main()
    { char s1[N＋N]，s2[N]，*p，*q；
     printf("输入2个字符串\n")；
     scanf("%s%s"，s1,s2)；
     for(p＝sl；* p!＝‘\0‘； p++)；
     for(q＝s2；*p++＝*q++；)；
     printf("两字符串连接后：%s\n" ，sl)；
     }

          8．比较两个字符串是否相等。
     【解】程序设两个存储字符串的数组，先输入两个字符串，两字符率比较时，直接用两字符串的对应字符比较来实现。完整程序如下：
    # include 
    # define N 120
    main()
    { char sl[N] ，s2[N]，*p，*q；
      char *result[]={"小于"，"相等" ，"大于"}；
      int comp；
      printf("输入 2个字符串\n")；
      scanf("%s%s"，s1，s2);
      for(p＝sl，q＝s2；*q!＝‘\0‘&& *p＝＝*q； p++， q++);
     comp＝*P <* q? 0：*P＝＝*q? l：2；
     printf("字符串1与字符串2比较：%s\n",result[comp])；
     }

          9．输入10个整数，将其中最大数与最后一个数交换，最小数与第一个数交换。
      【解】程序设一个一维数组存储输入的10个整数。然后遍历数组，找出最大元素和最小元素的指针。接着按要求先将最大元素与最后一个元素交换，然后将最小元素与第一个元素交换。最后，输出数组中的全部整数。程序应考虑到这样一种特殊情况，即最后一个元素正是最小元素，它在与最大元素交换后，位置已移到原先存储最大元素的位置。程序应保证最大元素移到末尾，最小元素移到最前端。程序如下：
    # include 
    # define N 10
     main()
    { int a[N]，*maxp，*minp，*q，t；
    printf("入%d个整数\n，N)；
    for(q＝a；qq++) { 
    scanf("%d"，&t)；*q＝t；
    }
     maxp= minp= a；
    for(q＝a；qq++){ 
    if(*maxp<*p) maxp=q；
    if(*minp>*q) minp＝q；
    }
    t＝*maxp; *maxp=a[N-1]; a[N－l]＝t；
    if(minp＝＝&a[N－l]) minp＝maxp；
    t＝* minp；*minp＝ a[0]； a[0]＝ t；
    for(q＝a；q q++)
    printf("%d"，*q)；
    printf("\n")；
   }