C语言中从大到小的顺序排列《学习记录》

Posted 2020-08-05 徐昊Xiho

一、前言

终于走到了指针，走到了翘首期盼的指针。指针是c语言中一个重要的概念，也是c语言最精彩的部分。正确而灵活的运用它，可以是程序简洁、紧凑、高效，每一个学习c语言的小伙伴都应该深入的学习和掌握指针。

本节目标

• 指针是什么
• 指针变量
• 通过指针引用数组
• 通过指针引用字符串

二、指针是什么

为了了解指针的概念，我们先来看一个小故事。 话说福尔摩斯派华生到威尔爵士居住的城堡去取回一个重要的数据。白天，在书房里，威尔爵士当着福尔摩斯和华生的面亲自将数据锁在了书柜中编号为3010的抽屉，用手电筒一照，只见里面有一张纸条，上面赫然写着6个大字：地址2000。华生眼前一亮，迅速的找到了编号为2000的抽屉，取出了重要的数据123，完成了任务。 可以用下图描述几个数据之间的关系。

说明：

（1）数据藏在一个内存地址单元中，地址是2000.

（2）地址2000又由Pointer单元所指认，Pointer单元的地址为3010.

（3）123的直接地址是2000,123的间接地址是3010,3010中存的是直接地址2000.

（4）称Pointer单元为指针变量，2000是指针变量的值。

由此可见，指针变量是一种特殊的变量，它存放的不是数据，而是另一种变量的地址。这个存放数据的变量被称为指针变量所指向的目标变量。由于通过指针变量中的地址可以直接访问它指向的目标变量，常把指针变量简称为指针。

指针变量是一种存放地址的特殊变量，其特殊性表现在类型和值上。从变量角度讲，指针变量也具有变量的要素：

（1）指针变量的命名，与一般变量命名相同，遵循c语言的命名规则。

（2）指针变量的类型，是指针变量所指向的变量的类型，而不是自身的类型。

（3）在实验楼的环境中，指针变量在内存中占用8个字节。

三、指针变量

先分析一个指针案例

通过指针变量访问整数类型

运行结果：

10-1.c代码中如果指针打印出为负数，则需要将打印的类型%d调整为%ld才可以正常输出。

程序分析：

（1）在开头处定义了两个指针变量point_1和point_2。但此时他们并未指向任何一个变量，只是提供两个指针变量，规定他们可以指向整形变量，至于指向哪一个整形变量，要在程序语句中指定。程序第6,7两行的作用就是使point_1指向a，point_2指向b，此时point_1的值为&a（即a的地址），point_2的值为&b。

（2）第10行输出*point_1和*point_2的值，其中的“*”表示“指向”。*point_1表示“指针变量point_1所指向的变量”，也就是变量a。*point_2表示“指针变量point_2所指向的变量”，也就是变量b。从运行结果来看他们也就是100和10.

（3）程序中有两处出现*point_1和*point_2，但是两者含义不同。程序第5行的*point_1和*point_2表示定义两个指针变量*point_1和*point_2。它们前面的“*”只是表示该变量是指针变量。程序最后10行中的printf函数中的*point_1和*point_2则表示指针变量point_1和point_2所指向的变量。

定义指针变量

在10-1中我们看到了定义指针变量，定义指针变量的一般形式为

类型名 * 指针变量名

如

int * point_1,* point_2;

注意：我们在这里再次强调一遍，在定义指针变量时要注意，指针变量前面的“*”表示该变量的类型为指针型变量。指针变量名是point_1和point_2，而不是*point_1和*point_2。这是和定义整形或实型变量不同的。上面程序6行和7行是不能写成* point_1=&a；和 *point_2=&b;的。因为a的地址是赋给指针变量point_1，而不是赋值给* point_1（即变量a）。

引用指针变量

在引用指针变量时，有以下3种情况：

（1）给指针变量赋值。如：

p=&a;  //把a的地址赋给指针变量p

指针变量p的值是变量a的地址，p指向a。

（2）引用指针变量指向的变量。 如果已经执行p=&a；即指针变量p指向了整形变量a，则

printf("%d",*p);

其作用是以整数形式输出指针变量p所指向的变量的值，即变量a的值。

如果有以下赋值语句：

*p=1;

表示将整数1赋给p当前所指向的变量，如果p指向变量a，则相当于把1赋给a，即a=1;.

（3）引用指针变量的值。如：

printf("%o",p);

作用是以八进制数形式输出指针变量p的值，如果p指向了a，就是输出了a的地址，即&a。

注意：比较地址运算符&和指针运算符*的差异：

程序举例

编写程序10-2，输入两个整数，按先大后小的顺序输出a和b。

解题思路：用指针的方法来处理这个问题。不交换整形变量的值，而是交换两个指针变量的值。

编写程序：

#include<stdio.h>
int main()
{
    int *p1,*p2,*p,a,b;
    printf("please enter two integer number:");
    scanf("%d,%d",&a,&b);
    p1=&a;
    p2=&b;
    if(a<b)
    {
        p=p1;p1=p2;p2=p;          //使p1和p2的值互换
    }

    printf("a=%d,b=%d\\n",a,b);
    printf("max=%d,min=%d\\n",*p1,*p2);
    return 0;
}

运行结果：

程序分析

输入23和42，由于a<b，将p1和p2交换，交换前后的情况如下图

注意：a和b的值并未交换，他们任然保持原值，但p1和p2的值改变了。p1的值原来为&a，后来变为&b。这样输出* p1和* p2时，实际上输出变量b和a的值，所以先输出42，然后输出23.

程序中p=p1;p1=p2;p2=p;这个语句是我们之前使用过的方法，两个变量的值交换要利用第三个变量。实际上学到指针我们可以用更加简洁的方法把p=p1;p1=p2;p2=p;改为p1=&b,p2=&1，这样就不需要定义中间变量p，使得程序更加简洁。

指针变量作为函数参数

函数的参数不仅可以是整形，浮点型等数据，也可以是指针类型。他的作用是将一个变量的地址传送到另一个函数中。

下面通过一个例子来说明： 编写程序10-3，要求实现的功能和10-2相同，只不过这次我们采用函数来处理，而且用指针类型的数据做函数的参数。

#include<stdio.h>
int main()
{
    void swap(int * point_1,int * point_2);
    int *p1,*p2,*p,a,b;
    printf("please enter two integer number:");
    scanf("%d,%d",&a,&b);
    p1=&a;
    p2=&b;
    if(a<b)
    swap(p1,p2);

    printf("max=%d,min=%d\\n",a,b);
    return 0;
}

void swap(int * point_1,int * point_2)
{
    int temp;
    temp=* point_1;                 //使*p1和*p2互换
    * point_1=* point_2;
    * point_2=temp;
}

运行结果为：

程序分析： swap是用户自定义函数，它的作用是交换两个变量（a和b）的值。swap函数的两个形参point_1和point_2是指针变量。程序运行时，先执行main函数，输入a和b的值（我们输入的是23和34），然后将a和b的地址分别赋给int 指针变量p1和p2，使p1指向a，p2指向b，见下图a，接着执行if语句，由于a<b，因此执行swap函数。注意实参p1和p2是指针变量，在函数调用时，将实参变量的值传送给形参变量，采取的依然是“值传递”方式。因此虚实结合后形参point_1的值是&a，point_2的值为&b，见下图b。这时p1和point_1都指向变量a，p2和point_2都指向变量b。接着执行swap函数的函数体，使* point_1和* point_2的值互换，也就是使a和b的值互换。互换后的情况见图c。函数调用结束后，形参p1和p2不复存在（已释放），情况如图d，最后在main函数中输出的a和b的值已经是经过交换的值。

可以看到，在执行swap函数后，变量a和b的值改变了。各位兄台，各位兄台！请仔细分析，这个改变是怎么实现的，这个改变不是通形参值传回实参实现的。大家可以考虑下能否通过下面的函数实现a和b互换。

void swap(int x ,int y)
{
    int temp;
    temp=x;
    x=y;
    y=temp;
}

如果在main函数中调用swap函数：

swap(a,b);

会有什么结果？在函数调用时，a的值传送给x，b的值传送给y，执行完swap函数后，x和y的值是互换了，但并未影响到a和b的值。在函数结束时，变量x和y释放了，main函数中的a和b并未互换。也就是说，这种单向的值传递，形参值的改变不能使实参的值随之改变。

为了使在函数中改变了的变量值能被主调函数main所用，不能采取上述的把要改变的变量作为参数的办法，而应该用指针变量作为函数参数，在函数执行过程中使指针变量所指向的变量值发生变化，函数调用结束后，这些变量值依然保留了下来。

如果想通过函数调用得到n个要改变的值，可以这样做：

（1）在主调函数中设n个变量，用n个指针变量指向它们；

（2）设计一个函数，有n个指针形参，在这个函数中改变n个形参的值；

（3）在主调函数中调用这个函数，在调用时将这n个指针变量作实参，将他们的地址传给该函数的形参。

（4）在执行该函数的过程中，通过形参指针变量，改变它们所指向的n个变量的值；

（5）主调函数中就可以使用这些改变了值的变量了。

大家是不是转的有点晕，相信小编，你把刚才的程序再写两遍，下面的这个程序练习再来好好写一遍并独立思考你绝对掌握了。

编写程序10-4，输入3个整数a，b，c要求按从大到小的顺序将他们输出，用函数实现

解题思路：采用10-3的方法在函数中改变3个变量的值。用swap函数交换两个变量的值，用exchange函数改变着3个变量的值。 编写程序

<pre name="code" class="cpp">#include<stdio.h>
int main()
{
   void exchange(int * q1,int * q2,int * q3);
   int a,b,c,*p1,*p2,*p3;
   printf("please enter 3 integer number:");
   scanf("%d%d%d",&a,&b,&c);
   p1=&a;p2=&b;p3=&c;
   exchange(p1,p2,p3);
   printf("the order is :%d,%d,%d\\n",a,b,c);
   return 0;
}

void exchange(int *q1,int *q2,int *q3)
{
   void swap(int *pt1,int *pt2);
   if(* q1<* q2) swap(q1,q2);
   if(* q1<* q3) swap(q1,q3);
   if(* q2<* q3) swap(q2,q3);
}

void swap(int *p1,int *p2)
{
  int temp;
  temp=*p1;
  *p1=*p2;
  *p2=temp;
}

下面是运行的效果如图。

四、通过指针引用数组

可以用一个指针变量指向一个数组元素。例如：

int a[10]={1,2,3,4,5,6,7,8,9,10};
int *P;
p=&a[0];

以上是使指针变量p指向a数组的第0号元素。

在c语言中，数组名（不包括形参数组名，形参数组并不占据实际的内存单元）代表数组中首元素（即序号为0的元素）的地址。因此，下面两个语句等价：

p=&a[0];  //p的值是a[0]的地址
p=a;      //p的值是数组a首元素（即a[0]）的地址

注意：数组名不代表整个数组，只代表数组首元素的地址。上述p=a;的作用是“把a数组的首元素的地址赋给指针变量p”，而不是“把数组a各元素的值赋给p”。

引用数组元素时指针的运算

在指针指向数组元素时，可以对指针进行以下运算：

• 加减一个整数，如p+1;或者p-1;
• 自加运算，如p++或者++p
• 自减运算，如p--或者--p

分别说明如下： （1）如果指针变量p已指向数组中的一个元素，则p+1指向同一数组中的下一个元素，p-1指向同一数组中的上一个元素。注意:执行p+1时并不是将p的值（地址）简单地加1，而是加上一个数组元素所占用的字节数。例如，数组元素是float型，每个元素占4个字节，则p+1意味着使p的值加4个字节，以使它指向下一个元素。p+1所代表的地址实际上是p+1*d，d是一个数组元素所占的字节数。若p的值是2000，则p+1的值不是2001而是2004。

（2）如果p的初值为&a[0],则p+i和a+i就是数组元素a[i]的地址，或者说，他们指向a数组序号为i的元素，见下图，这里注意的是a代表数组首元素的地址，a+1也是地址，它的计算方法同p+1，即它的实际地址为a+1*d。例如，p+9和a+9的值是&a[9],它指向a[9]。

（3）*（p+i）和*(a+i)是p+i或a+i所指向的元素，即a[i]。例如*(p+5)和*(a+5)就是a[5]，三者等价。

根据以上叙述，引用一个数组元素，可以用下面两种方法： （1）下标法，如a[i]的形式； （2）指针法，如*（a+1）或*（p+i）。其中a是数组名，p是指向数组元素的指针变量，其初值p=a。

程序举例

有一个整型数组a，有10个元素，要求输出数组中的全部元素。

解题思路：引用数组中各元素的值有3中方法：（1）下标法，如a[2]；（2）通过数组名计算数组元素地址，找出元素的值;(3)用指针变量指向数组元素。分别写出程序，以便我们比较分析。

编写程序： （1）10-5，下标法

#include<stdio.h>
int main()
{
    int a[10];
    int i;
    printf("please enter 10 integer numbers: ");
    for(i=0;i<10;i++)
    scanf("%d",&a[i]);

    for(i=0;i<10;i++)
    printf("%d\\t",a[i]);     //数组元素用数组名和下标表示

    return 0;


}

运行结果：

（2）通过数组名计算数组元素的地址

#include<stdio.h>
int main()
{
    int a[10];
    int i;
    printf("please enter 10 integer numbers: ");
    for(i=0;i<10;i++)
    scanf("%d",&a[i]);

    for(i=0;i<10;i++)
    printf("%d\\t",*(a+i));  //通过数组名和元素序号计算元素地址，再找该元素

    return 0;

}

运行结果与（1）相同

运行分析： 程序中语句scanf("%d",&a[i]);用&a[i]表示a[i]的地址,也可以改用（a+i）表示，即：

scanf("%d",a+i);

（3）用指针变量指向数组元素。

#include<stdio.h>
int main()
{
    int a[10];
    int *p,i;
    printf("please enter 10 integer numbers: ");
    for(i=0;i<10;i++)
    scanf("%d",&a[i]);

    for(p=a;p<(a+10);p++)
    printf("%d\\t",*p);  //用指针指向当前的数组元素

    return 0;

}

运行结果：与（1）相同

程序分析：

程序中的

for(i=0;i<10;i++)
    scanf("%d",&a[i]);

可以修改为：

for(p=a;p<(a+10);p++)
scanf("%d",p);

用指针变量表示当期的地址

3种方法的比较：

（1）第（1）种和第（2）种方法的执行效率是相同的。c编译系统是将a[i]装换为*（a+i）处理的，即先计算元素的地址。因此用第（1）和第（2）种方法找数组元素费时较多。

（2）第（3）种方法比第（1）、第（2）种方法快，用指针变量直接指向元素，不必每次都重新计算地址，像p++这样的自加操作是比较快的。这种有规律的改变地址值（p++）能大大提高执行效率。

（3）用下标比较直观，能直接知道是第几个元素。例如，a[5]是数组中序号为5的元素（注意序号是从0算起）。用地址发或者指针变量的方法不直观，难以很快的判断出当前处理的是哪一个元素。例如，方法（3）中，要仔细分析指针变量p的当前指向，才能判断当前输出的是第几个元素。有经验的程序猿往往喜欢用第（3）种形式，用p++进行控制，程序简洁、高效。对于小白用户最好还是用第（1）种方式，直观，不易出错。

注意：在使用指针变量指向数组元素时，有一些问题需要注意：

（1）可以通过改变指针变量的值指向不同的元素。例如：上述第（3）种方法是用指针变量p来指向元素，用p++使p的值不断改变从而指向不同的元素。

如果不用p变化的方法而用数组名a变化的方法行不行呢？假如将上述第（3）中方法中的程序的

for(p=a;p<(a+10);p++)
    printf("%d\\t",*p);

改为

for(p=a;a<(p+10);a++)
   printf("%d",*a);

是不行的。因为数组名a代表数组首元素的地址，它是一个指针型常量，它的值在程序运行期间是固定不变的。既然a是常量，所以a++是无法实现的。

（2）注意指针变量的当前值。看下例 编写程序：

#include<stdio.h>
c语言解答从键盘上输入三个数,按从大到小的顺序排列并输出最大值

 C语言代码练习，将三个数按从大到小的顺序输出
 编写程序'任何三个整数,按照从大到小的排列顺序输出或输出最大最小值
 c语言，输入3个数，按从大到小的顺序输出，要用三种方法
 单片机汇编：16个数比较大小，按从大到小的顺序进行排列并存放在30H~3FH单元中
 c语言：利用指针变量，用函数实现将3个整数按从大到小的顺序输出