四维数组，可用于航天卫星，三维+时间
#define _CRT_SECURE_NO_WARNINGS #include<stdio.h>
#include<stdlib.h> main()
{
int a[][][][];
int i, j, k, l;
int num = ;
int *p;
int find = ; printf("%d\n", sizeof(a));
printf("%d\n", sizeof(a) / sizeof(int)); for (p = &a[][][][];p < &a[][][][] + ;p++)
{
*p = num;
num++;
} for (i = ;i < ;i++)
{
for (j = ;j < ;j++)
{
for (k = ;k < ;k++)
{
for (l = ;l < ;l++)
{
printf("%7d", *(*(*(*(a + i) + j) + k) + l));
}
printf("\n");
}
printf("\n");
}
printf("\n");
} system("pause");
}
//数组作为函数的参数，二维数组用指向一维数组的指针变量
#define _CRT_SECURE_NO_WARNINGS #include<stdio.h>
#include<stdlib.h> //数组作为函数的参数，二维数组用指向一维数组的指针变量
void showb12(int(*p)[])
{
int i, j; for (i = ;i < ;i++)
{
for (j = ;j < ;j++)
{
printf("%6d", p[i][j]);
}
printf("\n");
}
} main()
{
int b[][] = { {,,,},{,,,},{,,,} }; showb12(b); system("pause");
}
行指针
//p[i][j]等价于 *(*(p + i) + j)
#define _CRT_SECURE_NO_WARNINGS #include<stdio.h>
#include<stdlib.h>
#include<time.h> main()
{
int a[][] = { ,,,,,,,,,,, }; int(*p)[] = a;//二维数组的指针就是一个指向一维数组的指针，元素是确定的 int i, j; scanf("%d %d", &i, &j); printf("%d,%d,%d,%d", i, j, p[i][j], *(*(p + i) + j));
//p[i][j]等价于 *(*(p + i) + j) system("pause");
}
//a[i][j]等价于*(a[i]+j)等价于*(*(a+i)+j)
//&a[i][j]等价于*(a+i)+j
#define _CRT_SECURE_NO_WARNINGS #include<stdio.h>
#include<stdlib.h> main()
{
int a[][] = { ,,,,,,,,,,, };
int i, j; for (i = ;i < ;i++)
{
for (j = ;j < ;j++)
{
printf("%3d,%x", a[i][j], &a[i][j]);
}
printf("\n");
} printf("%x,%x,%x\n", a, a + , a + );//三者完全等价，a是一个行指针，代表某一行的首地址
printf("%x,%x,%x\n", *a, *(a + ), *(a + ));//三者完全等价，a是一个行指针，代表某一行的首地址
printf("%x,%x,%x\n", a[], a[], a[]);//三者完全等价，a是一个行指针，代表某一行的首地址
printf("%d,%x\n", a[][], &a[][]);
//a[i][j]等价于*(a[i]+j)等价于*(*(a+i)+j)
//&a[i][j]等价于*(a+i)+j system("pause");
}
//a是一个行指针，指向一个有4个元素的数组，4*4=16 行指针
//&a是一个指向二维数组的指针，二维数组有12个元素，4*12=48，整个二维数组
//*a是一个指向int类型数据的指针，列指针
#define _CRT_SECURE_NO_WARNINGS #include<stdio.h>
#include<stdlib.h> main()
{
int a[][] = { ,,,,,,,,,,, }; printf("%x,%x,%x\n", a, &a, *a);
printf("%d,%d,%d", sizeof(*a), sizeof(*&a), sizeof(**a));
//*a是一个行指针，指向一个有4个元素的数组，4*4=16
//*&a是一个指向二维数组的指针，二维数组有12个元素，4*12=48
//**a是一个指向int类型数据的指针 system("pause");
}
//两者地址一样，有何不同？
#define _CRT_SECURE_NO_WARNINGS #include<stdio.h>
#include<stdlib.h> main()
{
int a[] = { ,,,, }; printf("%x,%x\n", a, &a);//两者地址一样，有何不同？ printf("%d,%d", sizeof(*a), sizeof(*(&a)));
//4 20 system("pause");
}
int *p = a;//指向元素的指针
int(*pa)[5] = &a;//指向数组的指针
#define _CRT_SECURE_NO_WARNINGS #include<stdio.h>
#include<stdlib.h>
#include<time.h> main()
{
int a[] = { ,,,, }; int *p = a;//指向元素的指针
int(*pa)[] = &a;//指向数组的指针 printf("%d,%d\n", sizeof(*p), sizeof(*pa)); system("pause");
}
输出结果：
4,20
请按任意键继续. . .
创建一个10个元素的数组，并为其随机赋值。找出最大值。用传统方法，和指针方法。
#define _CRT_SECURE_NO_WARNINGS #include<stdio.h>
#include<stdlib.h>
#include<time.h> main()
{
time_t ts;
srand((unsigned int)time(&ts)); int num[];
int i;
int max = ;//保存最大数 for (i = ;i < ;i++)
{
num[i] = rand() % ;
printf("%d,%x\n", num[i], &num[i]);
} for (i = ;i < ;i++)//传统方法
{
if (num[i] > num[max])
{
max = i;
}
} printf("%d,%d\n", max, num[max]); for (i = ;i < ;i++)//指针方法
{
if (*(num + i) > num[max])
{
max = i;
}
} printf("%d,%d\n", max, num[max]); system("pause");
}
用带下标的指针变量引用一维数组元素
4种方法：
#define _CRT_SECURE_NO_WARNINGS #include<stdio.h>
#include<stdlib.h> main()
{
int num[] = { ,,,,,,,,, };
int i;
int *p = num;
//p是变量，num是常量
for (i = ;i < ;i++)
{
printf("%d,%x", num[i], &num[i]);
printf("%3d,%x", *(num + i), num + i);
printf("%3d,%x", p[i], &p[i]);
printf("%3d,%x\n", *(p + i), p + i);
} system("pause");
}
printf("%d", (p1 - p2));//-2数组至今可以判断哪个编号在前，哪个编号在后
//并且可以判断两个指针之间相隔多少个元素
//指针相减，可以判断下标，p1<p2，p1对应元素的下标小于p2对应元素的下标
#define _CRT_SECURE_NO_WARNINGS #include<stdio.h>
#include<stdlib.h> main()
{
int a[] = { ,,,,,,,,, }; int *p1 = &a[];
int *p2 = &a[]; printf("%d", (p1 - p2));//-2数组至今可以判断哪个编号在前，哪个编号在后
//并且可以判断两个指针之间相隔多少个元素
//指针相减，可以判断下标，p1<p2，p1对应元素的下标小于p2对应元素的下标
system("pause");
}
指针比较，在数组才有意义。
#define _CRT_SECURE_NO_WARNINGS #include<stdio.h>
#include<stdlib.h> main()
{
int a[] = { ,,,, };
printf("%x\n", a);
int *p1 = &a[];
int *p2 = &a[]; if (p1 < p2)
{
printf("p1在数组内部排列比较靠前");
}
else
{
printf("p2在数组内部排列比较靠前");
} system("pause");
}
指针的加减法在非数组内部没有任何意义，而且很容易越界报错。
一个exe不能读写其他exe进程的内存
p = p + 2;//指针+2，在数组内部等价于向后移动2个元素的大小
p = p - 3;//指针-3，在数组内部等价于向前移动3个元素的大小
#define _CRT_SECURE_NO_WARNINGS #include<stdio.h>
#include<stdlib.h> main()
{
int a[] = { ,,,, };
int *p = &a[]; printf("%d\n", a[]); p = p + ;//指针+2，在数组内部等价于向后移动2个元素的大小 printf("%d\n", *p); p = p - ;//指针-3，在数组内部等价于向前移动3个元素的大小 printf("%d\n", *p); system("pause");
}
指针++，指针--
#define _CRT_SECURE_NO_WARNINGS #include<stdio.h>
#include<stdlib.h> main()
{
int a[];
int i = ;
int *p; printf("%x\n", a); //从头到尾扫描数组
for (p = a;p < a + ;p++)//指针++，就是指针每次向前移动sizeof(指针类型)个字节
{
*p = i;//对指针指向的内容进行赋值
i++;
} //从尾到头扫描数组
for (p = a + ;p >= a;p--)//指针++，就是指针每次向前移动sizeof(指针类型)个字节
{
printf("%x\n", p);
*p = i;//对指针指向的内容进行赋值
i++;
} system("pause");
}
通过数组的首地址引用数组元素
#define _CRT_SECURE_NO_WARNINGS #include<stdio.h>
#include<stdlib.h> main()
{
int a[] = { ,,,,,,,,, }; printf("%x\n", a); printf("%d\n", *(a + ));//两者等价
printf("%d\n", a[]);//两者等价 system("pause");
}
*p = *p - 1;//取指针变量p所指存储单元中的值，减1后再放入p所指的存储单元中，即使得值减1
#define _CRT_SECURE_NO_WARNINGS #include<stdio.h>
#include<stdlib.h> main()
{
int a[] = { ,,,,,,,,, };
int i;
int *p; printf("%x\n", a);//a被编译器解析为数组的首地址 for (i = ;i < ;i++)//下标循环，通过下标方式访问数组
{
printf("%d,%d\n", a[i], *(a + i));//a[i], *(a + i)两者等价
printf("%x,%x\n", &a[i], a + i);//&a[i], a + i两者等价
} for (p = a;p < a + ;p++)//指针循环，通过指针方式访问数组
{
*p = *p - ;//取指针变量p所指存储单元中的值，减1后再放入p所指的存储单元中，即使得值减1
printf("%d,%x\n", *p, p);
} system("pause");
}
数组当作参数的时候，传递的是指针
#define _CRT_SECURE_NO_WARNINGS #include<stdio.h>
#include<stdlib.h> void fun(int a[])//数组当作参数的时候，传递的是指针
{
printf("%d\n", sizeof(a));//
} main()
{
int a[] = { ,,,,,,,,, }; printf("%d\n", sizeof(a));// fun(a); system("pause");
}
创建一个动态二维数组，连续内存
#define _CRT_SECURE_NO_WARNINGS #include<stdio.h>
#include<stdlib.h>
#include<time.h> main()
{
int x, y; scanf("%d %d", &x, &y); void *p = malloc(sizeof(int)*x*y);//分配内存，连续的内存
//y必须是一个已知的常量，才能将这片内存当作一个二维数组来实现
//连续内存，缺点：列必须是常量指定的 int(*px)[] = p;
int i, j;
int num = ; for (i = ;i < x;i++)
{
for (j = ;j < ;j++)
{
px[i][j] = num;
num++;
printf("%4d", px[i][j]);
}
printf("\n");
} system("pause");
}
创建一个动态二维数组，不连续内存
#define _CRT_SECURE_NO_WARNINGS #include<stdio.h>
#include<stdlib.h> main()
{
int x, y; scanf("%d %d", &x, &y); //二级指针可以存储指针数组的地址
//动态分配一片内存，存放指针数组，每一个元素都是一个地址
//然后将指针数组的首地址传递给pp保存
int **pp = malloc(sizeof(int *)*x);
int i, j;
int num = ; for (i = ;i < x;i++)
{
pp[i] = malloc(sizeof(int)*y);
} for (i = ;i < x;i++)
{
for (j = ;j < y;j++)
{
pp[i][j] = num;//等价于*(*(pp+i)+j)
num++;
printf("%4d", pp[i][j]);
}
printf("\n");
} //释放内存 for (i = ;i < x;i++)
{
free(pp[i]);
}
free(pp); system("pause");
}
二维数组，一个指针指向类型的大小，恰好要是一个一维数组的大小；二维数组是一个一维数组，每一个元素都是一个一维数组。
#define _CRT_SECURE_NO_WARNINGS #include<stdio.h>
#include<stdlib.h>
#include<time.h> main()
{
int a[][] = { ,,,,,,,,,,, };
int i, j;
int(*p)[] = a;//创建一个指针存储二维数组的首地址，一个指向有4个元素的一维数组的指针 for (i = ;i < ;i++)
{
for (j = ;j < ;j++)
{
printf("%5d", a[i][j]);
}
printf("\n");
} for (int *p = &a[][];p < &a[][] + ;p++)
{
printf("%d,%p\n", *p, p);
} system("pause");
}
求出数组元素的个数：
#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> main()
{
int a[] = { ,,,, }; printf("%x\n", a); printf("%d", sizeof(a) / sizeof(int)); system("pause");
}
数组
为什么需要数组？
为了解决大量同类型数据的存储和使用问题
为了模拟现实世界
怎样定义一维数组？
为n个变量连续分配存储空间
所有的变量数据类型必须相同
所有变量所占的字节大小必须相等
指针变量的运算：
指针变量不能相加，不能相乘，也不能相除。
如果两个指针变量指向的是同一块连续空间中的不同存储单元，则这两个指针变量才可以相减。（即：在同一数组中相减，求出两个指针指向的单元相隔的单元数）
#include<stdio.h>
main()
{
int a[];
int * p = &a[];
int * q = &a[]; printf("p和q所指向的单元相隔%d个单元\n", q - p);
}
一堆数组的初始化
#include <stdio.h>
main()
{
int a[] = { ,,,, }; /*完全初始化*/ int a[] = { ,, }; /*不完全初始化，未被初始化的元素自动为零*/ int a[]; /*不初始化，所有元素是垃圾值*/ int a[] = { }; /*清零*/ /*错误写法*/
int a[];
a[] = { ,,,, }; /*错误，只有在定义数组的同时才可以整体赋值，其他情况下整体赋值都是错误的*/ int a[] = { ,,,, };
a[] = ; /*错误，因为没有a[5]这个元素，最大是a[4]*/ /*如果要把a数组中的值全部复制给b数组*/
int a[] = { ,,,, };
int b[];
b = a; /*错误的写法*/ for (i = ;i < ;++i)
b[i] = a[i]; /*正确的写法*/
}
#include <stdio.h>
main()
{
int a[];
//int b[5]; //a = b; /* ERROR a是常量 */ printf("%#X\n", &a[]);
printf("%#X\n", a);
}
输出结果：
0XDEF9B4
0XDEF9B4
请按任意键继续. . .
#include <stdio.h> void f(int * a, int len)
{
int i; for (i = ;i < len;++i)
{
printf("%d ", *(a + i)); /* 两者输出都一样 */
}
printf("\n"); for (i = ;i < len;++i)
{
printf("%d ", a[i]); /* 两者输出都一样 */
}
printf("\n");
} main()
{
int a[] = { ,,,, }; f(a, ); /* 因为a是存放地址，所以a是int * */
}
例9.1 编写程序，定义一个含有30个元素的 int 类型数组。依次给数组元素赋奇数1、3、5、...，然后按每行10个数顺序输出，最后再按每行10行个数逆序输出。
#include <stdio.h>
#define M 30
main()
{
int s[M], i, k = ;
for (i = ;i < M;i++) /* 给s数组元素依次赋1、3、... */
{
s[i] = k;
k += ;
} printf("\nSequence Output:\n"); /* 按从前到后的顺序输出 */ for (i = ;i < M;i++)
{
printf("%4d", s[i]);
if ((i + ) % == )
printf("\n"); /* 利用i控制换行符的输出 */
} printf("\nInvert Output:\n"); /* 按从后到前的顺序输出 */ for (i = M - ;i >= ;i--) /* 下标值从大到小 */
{
printf("%4d", s[i]);
if (i % == )
printf("\n"); /* 利用i控制换行符的输出 */
}
}
例9.2 编写程序，通过一个函数给主函数中定义的数组输入若干大于或等于0的整数，用负数作为输入结束标志；调用另一个函数输出该数组中的数据。
#include <stdio.h>
#define M 100
void arrout(int *, int); /* 函数说明语句，此函数用以输出数组中的值 */
int arrin(int *); /* 函数说明语句，此函数用以给数组输入数据 */
main()
{
int s[M], k;
k = arrin(s); /* k得到输入数据的个数 */
arrout(s, k);
} int arrin(int * a)
{
int i, x;
i = ;
scanf("%d", &x);
while (x >= )
{
*(a + i) = x;
i++;
scanf("%d", &x);
}
return i;
} void arrout(int * a, int n)
{
int i;
for (i = ;i < n;i++)
{
printf(((i + ) % == ) ? "%4d\n" : "%4d", *(a + i));
}
/* 根据i的值来确定使用不同的格式串 */
printf("\n");
}
例9.3 编写函数，对具有10个元素的char类型数组，从下标为4的元素开始，全部设置星号 “ * ” ，保持前4个元素中的内容不变。
#include <stdio.h>
#define M 10
#define B 4
void setstar(char *, int);
void arrout(char *, int);
main()
{
char c[M] = { 'A','B','C','D','E','F','G','H','I','J' };
setstar(&c[], M - B);
arrout(c, M);
} void setstar(char * a, int n)
{
int i;
for (i = ;i < n;i++)
{
*(a + i) = '*';
}
} void arrout(char * a, int n)
{
int i;
for (i = ;i < n;i++)
{
printf("%c", a[i]);
}
printf("\n");
}
例9.4 编写程序，定义一个含有15个元素的数组，并编写函数分别完成以下操作：
（1）调用C库函数中的随机函数给所有元素赋以0~49的随机数；
（2）输出数组元素中的值；
（3）按顺序对每隔三个数求一个和数，并传回主函数；
（4）最后输出所有求出的和值。
#include <stdio.h>
#include "stdlib.h"
#define SIZE 15
#define N 3
void getrand(int *, int); /* 三个函数说明语句 */
void getave(int *, int *, int);
void priarr(int *, int);
main()
{
int x[SIZE], w[SIZE / N] = { }; /* w数组中置初值0，准备存放5个和值 */
getrand(x, SIZE); /* 产生15个随机数放入x数组中 */
printf("Output %d random numbers:\n", SIZE);
priarr(x, SIZE); /* 输出15个随机数 */
getave(x, w, SIZE); /* 每3个数求一个和数放入w数组 */
printf("Output 5 sum numbers:\n");
priarr(w, SIZE / N); /* 输出5个和数 */
} void getrand(int * a, int n)
{
int i;
for (i = ;i < n;i++)
{
a[i] = rand() % ;
}
} void getave(int * a, int * b, int n)
{
int i, j, sum;
for (sum = , i = , j = ;i <= n;i++)
{
sum += a[i]; /* 累加数组元素 */
if ((i + ) % == ) /* 每累加3个数进行一次处理 */
{
b[j] = sum; /* 和值放入w数组中 */
sum = ; /* 置0，准备重新累加 */
j++; /* 下标增1 */
}
}
} void priarr(int * a, int n)
{
int i;
for (i = ;i < n;i++)
{
printf("%5d", a[i]);
if ((i + ) % == )
printf("\n");
}
printf("\n");
}
例9.5 将数组中的数按颠倒的顺序重新存放。在操作时，只能借助一个临时存储单元而不得另外开辟数组。
#include <stdio.h>
#define NUM 8
void invert(int *, int); /* 函数说明语句 */
void priout(int *, int); /* 函数说明语句 */
main()
{
/* 用置初值的方法给a数组放入数据 */
int a[NUM] = { ,,,,,,, };
printf("Output primary data:"); /* 输出原始数据 */
priout(a, NUM);
invert(a, NUM);
printf("Output the inverse data:"); /* 输出颠倒后的数据 */
priout(a, NUM);
} void priout(int s[], int n)
{
int i;
for (i = ;i < n;i++)
{
printf("%4d", s[i]);
}
printf("\n");
} void invert(int * a, int n)
{
int i, j, t;
i = ;
j = n - ; /* i是最前元素的下标，j是最后元素的下标 */
while (i < j) /* 当i大于或等于j时，对调完成 */
{
t = a[i];
a[i] = a[j];
a[j] = t; /* 下标为i和j的两个元素中的值对调 */
i++;
j--; /* i向后移一个位置，j向前移一个位置 */
}
}
例9.6 已知整型数组中的值在0至9的范围内，统计每个整数的个数。
以下程序中，函数 getdata 调用随机函数产生50个值在0至9的整数；函数 stat 统计每个整数的个数，并传回主函数；函数 outdata 输出结果。
#include <stdio.h>
#include <stdlib.h>
#define M 50
#define N 10 void getdata(int * s)
{
int i;
for (i = ;i < M;i++)
{
s[i] = rand() % ;
if (i % == )
{
printf("\n"); /* 每生成10个随机数，换行 */
}
printf("%d ", s[i]); /* 把随机数打印出来 */
}
} void stat(int * a, int * c)
{
int i;
for (i = ;i < N;i++)
{
c[i] = ; /* c数组元素置初值0 */
}
for (i = ;i < M;i++)
{
c[a[i]]++; /* 用c数组的元素对各整数进行统计 */
}
} void outdata(int * c)
{
int i;
for (i = ;i < N;i++)
{
printf("%d:%d\n", i, c[i]);
}
} main()
{
int a[M], c[N];
getdata(a);
stat(a, c);
printf("\nOutput the result:\n");
outdata(c);
}
例9.7 已知存放在 a 数组中的数不相重，在 a 数组中查找和 x 值相同的元素的位置。若找到，输出该值和该值在 a 数组中的位置；若没找到，输出相应的信息。
以下程序中，arrin 函数用于输入数据。函数首先要求输入一个整数，以确定将给数组输入数据的个数，然后给数组输入数据。
在主函数中输入带查找的数据。
函数 search 用以查找 x 在数组中的位置，位置值传送给变量 p。若 p 的值为 -1，表示在数组中没有值为 x 的元素，否则 p 中的值即为所找的位置。
#include <stdio.h>
#define NUM 30 int arrin(int * a)
{
int i, n;
do /* 当指定数组元素个数超出范围时，重新输入 */
{
printf("Enter number of elements,0<=n<%d:", NUM);
scanf("%d", &n);
} while ((n < ) || (n >= NUM));
/* 注意：输入的n个整数，放入a[0]至a[n-1]中，a[n]在查找时用作辅助空间 */
printf("Enter %d integer numbers:\n", n);
for (i = ;i < n;i++)
{
scanf("%d", a + i);
}
return n;
} int search(int * a, int x, int n)
{
int i, p; /* 查找开始 */
i = ; /* 从a[0]元素开始查找 */
a[n] = x; /* 把待查找的数放入a[n]中 */
while (x != a[i])
{
i++;
}
/* 只要x值等于当前a[i]的值，则推出循环，否则i后移一位 */
if (i == n)
{
p = -; /* 没找到 */
}
else p = i; /* 找到 */
return p;
} main()
{
int a[NUM], x, n, p; /* 暂定数组含30个元素，下标的上限为29 */
n = arrin(a);
printf("Enter the number to search:x=");
scanf("%d", &x);
p = search(a, x, n);
if (p != -)
{
printf("%d index is:%d\n", x, p); /* 输出x所在下标 */
}
else printf("%d is not found!\n", x); /* 输出没找到信息 */
}
例9.8 w 数组中存放 n 个数据，编写函数删除下标为 k 的元素中的值。
以下程序中，调用了 getindex、arrout 和 arrdel 三个函数。getindex 用以输入所删元素的下标，函数中对输入的下标进行检查，若越界，则要求重新输入，直到正确为止；arrout 用以输出数组中的数据；arrdel 进行所要求的删除操作。
#include <stdio.h>
#define NUM 10 /* 假定数组含有10个元素 */
int arrdel(int *, int, int); /* 函数说明语句 */
void arrout(int *, int); /* 函数说明语句 */
int getindex(int n);
main() /* 用置初值的方法给数组置数 */
{
int n, d, a[NUM] = { ,,,,,,,,, };
n = NUM;
printf("Output primary data:\n"); /* 输出原始数据 */
arrout(a, n);
d = getindex(n);
n = arrdel(a, n, d);
printf("Output the data after delete:\n"); /* 输出删除后的数据 */
arrout(a, n);
} void arrout(int w[], int m)
{
int k;
for (k = ;k < m;k++)
{
printf("%d ", w[k]);
}
printf("\n");
} int arrdel(int * w, int n, int k)
{
int i;
for (i = k;i < n - ;i++)
{
w[i] = w[i + ]; /* i+1替换i */
}
n--; /* 删除后数据个数减1 */
return n;
} getindex(int n)
{
int i;
do /* 当指定的下标值落在数据所在下标范围内时，退出循环，返回该下标值 */
{
printf("\nEnter the index [0<=i<%d]:", n); /* 输入待删元素的下标 */
scanf("%d", &i);
} while (i< || i>n - );
return i;
}
例9.9 用选择法对数组中的数进行排序（按由小到大顺序）。
#include <stdio.h>
#define NUM 6
void arrsort(int[], int);
void arrout(int *, int);
main()
{
int a[NUM] = { ,,,,, };
arrout(a, NUM); /* 输出a数组中原始数据 */
arrsort(a, NUM); /* 对a数组中的数进行排序 */
arrout(a, NUM); /* 输出排序后a数组中的数据 */
} void arrsort(int * a, int n)
{
int i, j, p, t;
for (j = ;j < n - ;j++) /* n个数进行n-1次选择 */
{
p = j; /* 先使p指向排序范围的第一个元素 */
for (i = j + ;i < n;i++)
{
if (a[p] > a[i])
{
p = i; /* 使p指向a[j]到a[n-1]之间的最小元素的位置 */
}
}
if (p != j)
{
t = a[j];
a[j] = a[p];
a[p] = t; /* 如果排序范围的第一个元素不是最小的元素，则将最小的元素的值与排序范围的第一个元素中的值进行对调 */
}
}
} void arrout(int a[], int n)
{
int i;
for (i = ;i < n;i++)
{
printf("%d", a[i]);
}
putchar('\n');
}
考点：
1
行列下标下限为 0，上限为 n-1
2
一定要把两个下标分别放在两个方括号内
int a[4] [2]合法
int a[0, 1]不合法
3
a[i] [j] 表示第 (i + 1) 行第 (j + 1) 列
第 m 行第n列：a[m-1] [n-1]
int a[m] [n] 该二维数组右下角位置的元素是 a[m - 1] [n - 1]
是否存在多维数组？
不存在多维数组。
因为内存是线性一维的。
n维数组可以当作每个元素是 n - 1 维数组的一维数组
比如：
int a[3][4]
该数组是含有3个元素的一维数组
只不过每个元素都可以再分成4个小元素
int a[3][4][5]
该数组是含有3个元素的一维数组
只不过每个元素都是4行5列的二维数组
例9.10 通过键盘给 2*3 的二维数组输入数据，第一行赋1、2、3，第二行赋10、20、30，然后按行输出此二维数组。
#include <stdio.h>
main()
{
int a[][], i, j;
printf("Enter data by line:\n");
for (i = ;i < ;i++)
{
for (j = ;j < ;j++)
{
scanf("%d", &a[i][j]);
}
}
printf("Output a 2-dimension array:\n");
for (j = ;j < ;j++)
{
for (i = ;i < ;i++)
{
printf("%4d", a[j][i]);
}
printf("\n");
}
for (i = ;i < ;i++)
{
for (j = ;j < ;j++)
{
printf("%4d", a[j][i]);
}
printf("\n");
}
}
输出格式：
Enter data by line:
1 2 3 10 20 30
Output a 2-dimension arra
1 2 3
10 20 30
1 10
2 20
3 30
请按任意键继续. . .
例9.11 编写程序，通过调用随机函数给 5*6 的二维数组元素赋10~40范围内的整数，求出二维数组每行元素的平均值。
#include <stdio.h>
#include <stdlib.h>
#define M 6 /* 每行6列 */
#define N 5 /* 数组包含5行 */
void getdata(int(*)[M]); /* 得到随机数 */
void lineave(int[][M], float *); /* 求每行的平均值 */
void outdata(int[N][M], float *); /* 输出数据 */
main()
{
int r[N][M]; /* 用整型数组r存放随机数 */
float ave[N]; /* 用ave数组存放每行的平均值 */
getdata(r); /* 输入数据 */
lineave(r, ave); /* 求r数组每行的平均值放在ave数组中 */
outdata(r, ave); /* 输出数据 */
} void getdata(int(*sp)[M])
{
int i, j, x;
for (i = ;i < N;i++)
{
j = ;
while (j < M)
{
x = rand() % ; /* 产生0到40的随机数 */
if (x >= ) /* 只有产生的随机数大于或等于10时才放入数组中 */
{
sp[i][j] = x;
j++;
}
}
}
} void lineave(int s[][M], float * a) /* 求每行的平均值 */
{
int i, j;
float ave;
for (i = ;i < N;i++)
{
ave = 0.0;
for (j = ;j < M;j++)
{
ave = ave + s[i][j];
}
a[i] = ave / M;
}
} void outdata(int sp[N][M], float a[])
{
int i, j;
printf("Output the result:\n");
for (i = ;i < N;i++)
{
for (j = ;j < M;j++)
{
printf("%4d", sp[i][j]);
}
printf(":%6.2f\n", a[i]);
}
putchar('\n');
}
9.12 行列互换
#include <stdio.h>
main()
{
int a[][] = { {,,},{,,},{,,} };
int i, j, t;
for (i = ;i < ;i++)
{
for (j = ;j < ;j++)
{
printf("%d ", a[i][j]);
}
printf("\n");
}
for (i = ;i < ;i++)
{
for (j = i + ;j < ;j++)
{
t = a[i][j];
a[i][j] = a[j][i];
a[j][i] = t;
}
}
for (i = ;i < ;i++)
{
for (j = ;j < ;j++)
{
printf("%d ", a[i][j]);
}
printf("\n");
}
}