一，一维数组

数组：相同数据类型的成员（数组元素）组成的一组数据。

整型数组

浮点型数组

数组是一种构造类型,相同数据类型组成的新数据类型。数组的每个成员称为数组元素。
最简单的数组是一维数组。
一维数组的定义:

类型说明符 数组名[常量表达式] = {值1,值2…};
int a[5] = { 2, 7, 4, 3, 6 };
int b[5] = { 2, 7, 4 };
int c[5] = { 0 };
int d[ ] ={2,7,4,3,6};
int array[5] = {0};
float b[ ] = {2.10 , 3 , 5 , 4.6}; 
char str[ ] = “iPhone5” ;


数组元素的访问:数组名 +下标

数组下标:数组元素在数组中的序号。 从0开始,到数组总个数-1; 下标可以是常量,也可以是变量

a[0] a[1] a[2] a[3] a[4]
*************************
数组注意事项
注意区别 定义数组 和 数组元素
int a[10];
a[10];
二者区别, 定义数组 数组名前有类型修饰符 。数组元素,不带类型修饰符。
**********************************************************************************
练习：
1、定义一个具有20个元素的整型数组,每个元素的取值范围是30-70之间,求数组元素的和。
2、复制一个数组,即两个数组容量一样,把其中一个数组中的元素复制到另外⼀一个数组中。
3、生成2个数组,每个数组都有10个元素,元素取值范围20-40 之间,数组对应元素相加,放到另外一个数组中。
******

系统不会检测数组元素的下标是否越界,编程时,必须保证数组下标不能越界。
数组是一个整体,不能直接参加运算,只能对单个元素进行处理,通常用到数组的地方都会用到循环 。

二 数组排序

开发中经常会用到排序比如:

整型数组从小到大排序;学生姓名按升序排列等等。
常见的排序方法很多:
 比如:冒泡排序、选择排序、插入排序、归并排序等等

冒泡排序是比较常见的排序算法。
因为其原理跟水底气泡上升至水面很相似而得名。
冒泡排序涉及到双循环,外层循环控制趟数,内层循环控制比较次数。

练习：

1、随机产生10个[20,40]数,并对10个数从小到大排序。

三 字符数组

⽤于存放字符变量的数组称为字符数组。
字符数组属于一维数组,定义方式与普通一维数组相似,只是类型是char。

数组的定义:

char c[10] = {‘i’ , ‘P’ , ‘h’ , ‘o’ , ‘n’ , ‘e’}; 

或者 char c[10] = “iPhone” ;

有’\0’结束标识的字符数组也称为字符串。

系统提供了很多字符串处理函数。
strlen() 计算字符串⻓度 ;

strcpy() 字符串拷贝;

 strcat() 字符串拼接;

 strcmp() 字符串比较字符;

练习：

1.查找字符串中的空格数:
例如:“I love iOS, i want an iPhone5s” 

6个空格

2.将字符串倒转:
例如:“afjnpue” 转变成字符串“eupnjfa”
(注:是改变字符串本⾝身,不是反向输出)

字符串所占的空间至少要比字符串长度大1,因为字符串以 ‘\0’ 表示结束。

系统提供的字符串处理函数都是根据 ‘\0’ 来判断字符串是否结束。

char str[] = { ‘o’ , ‘k’ };

char str[] = “ok” ;

总结：

数组通常与循环结合使用。 

数组下标从0开始,最大到数组容量-1。
一定要注意下标越界问题。
字符串数组在定义的时候一定要多留⼀个元素位置留 给’\0’。

// // 定义数组之前,先回想定义变量
// // 数据类型 变量名 = 初值;
// // 类型修饰符 数组名 = {初始值1,初始值2,初始值3,…..};
// int array[5] = {3,5,7,1,4};
// // 定义一个int类型,元素个数为5,数组名为array的数组
// // 数组下标(索引)的取值范围是0 ~ 元素个数-1
// printf(“%d\n”,array[0]);
// arry[3] = 6;
// //观察下面的一个数组
// int arry[] = {0}; //具有一个元素.不能这么写。

//定义一个字符型数组,存储iPhone
// char string[] =”iPhone”;
// 定义一个整形数组
// int arry[5] ={1,3,5,7,9};
// // 纯手动打印数组全部元素.
// printf(“%d\n”,arry[0]);
// printf(“%d\n”,arry[1]);
// printf(“%d\n”,arry[2]);
// printf(“%d\n”,arry[3]);
// printf(“%d\n”,arry[4]);
// // 可以考虑使用循环
// // 遍历数组
// for (int i =0; i < 5;i++) {
// printf(“%d\n”,arry[i]);
// }
// // 定义数组,长度不能是变量,只能是常量或常量表达式

// 练习
// int array[20] = {0};
// // 定义一个累加器
// int sum = 0;
// for (int i = 0; i < 20; i++) {
// // 每个元素的取值范围30~70
// array[i] = arc4random() % (70 – 30 + 1) + 30;
// //每个元素累加
// sum += array[i];
// printf(“%d”,sum);
// }

// 2、复制⼀一个数组,即两个数组容量⼀一样,把其中⼀一个数组中的
// 元素复制到另外⼀一个数组中。
// 定义数据源数组
// int source[10] = {0};
// // 定义目标源数组
// int dest[10] = {0};
// for (int i =0; i < 10; i++) {
// source[i] = arc4random() % (70 – 30 + 1) + 30;
// dest[i] = source[i];
// printf(“%d\n”,source[i]);
// printf(“%d\n”,dest[i]);
// }
//

// 3.⽣生成2个数组,每个数组都有10个元素,元素取值范围20-40 之间,数组对应元素相加,放到另外⼀一个数组中
// // 定义数据源数组
// int sorOne[10] ={0}, sorTwo[10] = {0};
// // 定义目标源数组
// int dest[10] = {0};
// for (int i = 0; i < 10; i++) {
// // 元素取值范围20~40;
// sorOne[i] = arc4random() % (40 – 20 + 1) + 20;
// // 如果同时为两个元素个数相同的数组赋值,可以写在同一个循环下.
// sorTwo[i] = arc4random() % (40 – 20 + 1) + 20;
// // 将对应元素相加,放在相应的目标数组中.
// dest[i] = sorOne[i] + sorTwo[i];
//
// printf(“%d”,dest[i]);
//
// }
// 系统不会检测 数组元素的下标是否越界,编程时,必须保证数组下标 不能越界。

// 数组是一个整体,不能直接参加运算,只能对单个元素进行处理,通常用到数组的地⽅都会用到循环。

// //数组排序
// int array[10] = {0};
// //给数组一个随机值,取值范围是0~20;
// for (int i = 0; i < 10; i++) {
// array[i] = arc4random() % 21;
// printf(“%d “,array[i]);
//
// }
// printf(“\n”);
// // 通常情况下,排序默认按照升序排列
// // 整个过程需要9次.
// for (int j = 0; j < 10 – 1; j++) {
//
//
// // 将最大值推到数组的最后一个位置,比较次数为元素个数-1次.
// // 优化,将比较次数减少,减少的次数有j决定
// for (int i = 0; i < 10 – 1-j; i++) {
// //需要判断,前面的是否大于后面
// if(arry[i] > arry[i + 1]){
// //如果前面大于后面的则交换.
// int temp =arry[i];
// arry[i] =arry[i + 1];
// arry[i + 1]=temp;
// }
//
// }
// }
// printf(“改变后:”);
// for (int i = 0; i < 10 ; i++){
// printf(“%d “,arry[i]);
// }
//
// printf(“\n”);

// int arry[10] = {0};
// for (int i = 0; i < 10; i++) {
// arry[i] = arc4random() % 20;
// printf(“%d “,arry[i]);
//
// }
// printf(“\n”);
// //冒泡排序.
// for (int i = 0; i < 10-1; i++) {
// for (int j = 0; j < 10 -1-i; j++) {
// if (arry[j] > arry[j +1]) {
// int temp = arry[j];
// arry[j] = arry[j + 1];
// arry[j +1] = temp;
// }
// }
// }
// for (int i = 0; i < 10; i++) {
//
// printf(“%d “,arry[i]);
//
// }

// 常⻅的排序方法很多:
// 比如:冒泡排序、选择排序、(插入排序)等等,下面是冒泡排序。
// int arry[10] = {0};
// for (int i = 0; i < 10; i++) {
// arry[i] = arc4random() % (40 – 20 + 1) + 20;
// printf(“%d “,arry[i]);
// }
// printf(“\n”);
// for (int i = 0; i < 10 – 1; i++) {
// for (int j = 0; j < 10 – 1 – i ; j++) {
// if (arry[j] > arry[j + 1]) {
// int temp = arry[j];
// arry[j] = arry[j +1];
// arry[j + 1] = temp;
// }
// }
// }
// for (int i = 0; i < 10; i++) {
// printf(“%d “,arry[i]);
// }
// printf(“\n”);

// char string[] = “iPhone4”;
// 对于字符串,有一个快捷的速出方式,就是以%s为转移字符进行输出
// 需要注意的是,输出字符串时,表达式写数组名(就是字符数组的名字,并且不加方括号)
//%s后面的表达式需要给地址,用&符号取出元素在内存当中的地址
//数组名代表的就是首元素的地址,可以近似的理解为string与&string[0]恒等.
// printf(“%s\n”,&string[3]);
// printf(“%d %d “,’\0′,’0′);
//字符数组的两种创建方式最大的不同就是双引号创建的字符数组后面自动默认给一个’\0′.
//%lu是无符号长整形.
//用sizeof计算的是所占空间的大小
// printf(“%lu\n,”,sizeof(string));
//测试字符串长度的函数(系统自带)
//strlen的参数需要写地址(1.可以直接写数组名2写&string[0])
//strlen的返回结果为字符串的长度,类型为unsigned long
// unsigned long length = strlen (&string[0]);
// printf(“length = %lu\n”,length);
//
//
// printf(“字符串拷贝函数测试:\n”);
//strcpy(dest,src) 从src拷贝到dest
//需要注意的是 目标数组的容量一定要大于等于数组源数组的长度
//两个参数都要写地址
// char dest[8] ={0};
// strcpy(dest, string);
// printf(“%s\n”,dest);

// printf(“字符串拼接函数测试:\n”);
// strcat(dest , src)
//需要注意的地方:注意目的数组的空间一定要大于等于两个数组之和
// char string[] = “qian”;
// char apple[] = “Apple”;
// strcat(&apple[0], &string[0]);
// printf(“%s\n”,apple);
// printf(“字符串比较函数测试:\n”);
// printf(“%d\n”,strcmp(“iPhone4”, “iPhone6”));

作业

**********************************

// int a[SIZE] = {0},i= 0;
// for(i = 0; i < SIZE; i++){
// a[i] = i+10;
// printf(“a[%d] = %d\n”, i, a[i]);
// }
// 1. （＊）先调试，调试成功后抄写下列程序：
//#include <stdio.h>
//#define SIZE 10
// int main(int argc, char *argv[])
// {
// int a[SIZE] = {0},i= 0;
// for(i = 0; i < SIZE; i++){
// a[i] = i+10;
// printf(“a[%d] = %d\n”, i, a[i]);
// }
// return 0;
// }
//
// 2. （＊）将第一题中的数组a反向输出。
// printf(“\n\n”);
// for (int i = 9; i >= 0; i–) {
// printf(“a[%d] = %d\n”,i,a[i]);
// }
// 3. （＊）对第一题中的数组进行求和操作，打印计算结果。
// int sum = 0;
// for (int i = 0; i < SIZE; i++) {
// sum += a[i];
// }
// printf(“sum = %d\n”,sum);
// 4. （＊＊）计算第一题数组连减，打印计算结果。
// int num = 0;
// for (int i = 0; i < SIZE ; i++) {
// num -= a[i];
// }
// printf(“num = %d\n”,num);
// 5. （＊＊）随机产生20个10~50的正整数存放到数组中，并求数组中的所有元素最大值、最小值、平均值及各元素之和。
// int number[20] = {0};
// int max = 0;
// int min = 100;
// int sum = 0;
// for (int i = 0; i < 20; i++) {
// number[i] = arc4random()%(50-10+1)+10;
// printf(“%d “,number[i]);
// if (max < number[i]) {
// max = number[i];
// }
// if (min > number[i]) {
// min = number[i];
// }
// sum += number[i];
// }
// printf(“max = %d\n”,max);
// printf(“min = %d\n”,min);
// printf(“avg = %.2f\nsum = %d\n”,1.0*sum/20,sum);
// 6. 编写一个程序，输入两个包含5个元素的数组，先将两个数组升序排序，然后将这两个数组合并成一个升序数组。
// int a[5] = {0};
// int b[5] = {0};
// printf(“请输入a数组的5个值:”);
// for (int i = 0; i < 5; i++) {
// scanf(“%d”,&a[i]);
// }
// printf(“\n”);
// printf(“请输入b数组的5个值:”);
// for (int i = 0; i < 5; i++) {
// scanf(“%d”,&b[i]);
// }
// printf(“\n”);
//
// //对数组a排序
// //对数组b排序
// for (int i = 0; i < 5 – 1; i++) {
// for (int j = 0; j < 5 – 1 – i; j++) {
// if (a[j] > a[j+1]) {
// int temp = a[j];
// a[j] = a[j+1];
// a[j+1] = temp;
// }
// if (b[j] > b[j+1]) {
// int temp = b[j];
// b[j] = b[j+1];
// b[j+1] = temp;
// }
// }
// }
// for (int i = 0; i < 5; i++) {
// printf(“%d “,a[i]);
// }
// printf(“\n”);
// for (int i = 0; i < 5; i++) {
// printf(“%d “,b[i]);
// }
// printf(“\n”);
//
// int c[10] = {0};
// for (int i = 0; i < 10; i++) {
// if (i < 5) {
// c[i] = a[i];
// }else {
// c[i] = b[i-5];
// }
// }
// //排序c数组
// for (int i = 0; i < 10 – 1; i++) {
// for (int j = 0; j < 10 – 1 – i; j++) {
// if (c[j] > c[j+1]) {
// int temp = c[j];
// c[j] = c[j+1];
// c[j+1] = temp;
// }
// }
// }
// for (int i = 0; i < 10; i++) {
// printf(“%d “,c[i]);
// }
// printf(“\n”);

// 7. （＊＊＊）给定某年某月某日，输出其为这一年的第几天。
// int year = 0,month = 0,day = 0;
// printf(“请输入 年 月 日:”);
// scanf(“%d%d%d”,&year,&month,&day);
// int daysInMonths[12] = {31,28,31,30,31,30,31,31,30,31,30,31};
// if (year % 400 == 0 || (year % 4==0 && year % 100 != 0)) {
// daysInMonths[1] = 29;
// }
// int totalDays = 0;
// for (int i = 0; i < month – 1; i++) {
// totalDays += daysInMonths[i];
// }
// totalDays += day;
// printf(“%d\n”,totalDays);

// 8. （＊＊）编写整型值数组排序程序(冒泡排序–升序)
// int a[] = {3,-9,32,77,63,-24,14,0,21,45};
// int count = sizeof(a)/sizeof(a[0]);
// for (int i = 0;i < count – 1; i++) {
// for (int j = 0; j < count – 1 – i; j++) {
// if (a[j] > a[j+1]) {
// int temp = a[j];
// a[j] = a[j+1];
// a[j+1] = temp;
// }
// }
// }
// for (int i = 0; i < count; i++) {
// printf(“%d “,a[i]);
// }

// 9、（＊＊＊）找出下列整型数组中最大和最小值及其所在位置i。
// int a[] = {5,-9,32,77,64,-24,14,0,21,45};
// int max = -100,min = 100;
// int count = sizeof(a)/sizeof(a[0]);
// for (int i = 0; i < count; i++) {
// if (max < a[i]) {
// max = a[i];
// }
// if (min > a[i]) {
// min = a[i];
// }
// }
// printf(“max = %d min = %d\n”,max,min);
// for (int i = 0; i < count; i++) {
// if (a[i] == max) {
// printf(“最大值的下标是%d\n”,i);
// }
// if (a[i] == min) {
// printf(“最小值的下标是%d\n”,i);
// }
// }
//
// 10、（＊）把str1, str2, str3合并到result数组中。
// char result[50] = {0};
// char str1[] = “Lanou “;
// char str2[] = “23_class “;
// char str3[] = ” is niu best!”;
// strcat(result, str1);
// strcat(result, str2);
// strcat(result, str3);
// printf(“%s”,result);
// 结果：“Lanou 23_class is niu best!”
//
// 11、（＊＊）找出下面程序的错误:
// int main(int argc, char *argv[])
// {
// char string[10], str1[10];
// int i;
// for(i = 0; i < 10; i++)
// {
// str1[i] = ‘a’;
// }
// strcpy(string, str1);//缺少’\0′
// }
//
// 12、（＊＊）下面这个程序执行后会有什么错误或者效果：
// int main(int argc, char *argv[])
// {
// unsigned char str[10], i;
// for(i = 0; i < 256; i++)
// str[i] = i;//数组不要越界
// }
//
// 13、（＊＊＊）模拟n个人参加选举的过程，并输出选举结果：假设候选人有四人，分别用A、B、C、D表示，当选某候选人时，直接输入其编号(编号由计算机随机产生)，
// 若输入的不是A、B、C、D则视为无效票，选举结束后按得票数从高到低输出候选人编号和所得票数。
// int n = 20;
// int tickets[4] = {0};
// char p[4] = {‘A’,’B’,’C’,’D’};
// for (int i = 0; i < n; i++) {
// int number = arc4random()%5 + 65;
// if (number != 69) {
// tickets[number-65]++;
// }
// }
// for (int i = 0; i < 4; i++) {
// printf(“%d “,tickets[i]);
// }
// printf(“\n”);
// for (int i = 0; i < 4-1; i++) {
// for (int j = 0; j < 4-1-i; j++) {
// if (tickets[j] < tickets[j+1]) {
// int temp = tickets[j];
// tickets[j] = tickets[j+1];
// tickets[j+1] = temp;
// char temp2 = p[j];
// p[j] = p[j+1];
// p[j+1] = temp2;
// }
// }
// }
// for (int i = 0; i < 4; i++) {
// printf(“%c:%d “,p[i],tickets[i]);
// }
// 14、（＊＊＊＊）思考题：编程在一个已知的字符串中找最长单词，假定字符串中只含字母和空格，空格用来分隔不同单词。
// 比如：”ni hao world”,最长单词是world。
// char str[] = “I am a girl beautiful”;
// int maxLength = 0;//最长长度
// int currentLength = 0;//当前单词的长度(每个单词长度)
// int i = 0;//下标
// int index = 0;//最长单词的起始位置
// while (str[i] != ‘\0’) {
// if (str[i] != ‘ ‘) {
// currentLength++;
// if (str[i+1]==’\0′) {
// if (maxLength < currentLength) {
// maxLength = currentLength;
// index = i+1 – maxLength;
// }
// }
// }else {
// if (maxLength < currentLength) {
// maxLength = currentLength;
// index = i – maxLength;
// }
// currentLength = 0;
// }
// i++;
// }
// printf(“%d\n”,maxLength);
// for(int i = index;i < maxLength+index;i++){
// printf(“%c”,str[i]);
// }

// 15、（＊＊＊＊＊）思考题： 约瑟夫环的数组实现
// 约瑟夫（Josephus）问题是由古罗马的史学家约瑟夫提出的，他参加并记录了公元66-70年犹太人反抗罗马的起义。约瑟夫作为一个将军，设法守住了裘达伯特城达47天之久，在城市沦陷之后，他和40名将士在附近的一个洞穴中避难。在哪里，将士们群情激奋并表示：要投降毋宁死。于是，约瑟夫建议每个人轮流杀死他旁边的人，而这个顺序是由抽签决定的。约瑟夫有预谋地抓到了最后一签并且做为洞穴中两个幸存者之一生存下来。
// 约瑟夫环问题的具体描述是：设有编号为1，2，……，n的n(n>0)个人围成一个圈，从第一个人开始报数，报到m时停止报数，报m的人出圈，再从他的下一个人起重新报数，报到m时停止报数，报m的出圈，……，如此下去，直到只剩下一人为止。当任意给定 n和 m后，设计算法求 n个人出圈的次序。
//5个人 报到3
//1 0 1 0 1
//1 2 3 1 2
//3 1 2 3
// 1 2
// 3 1
// 2
// 3

int n = 5,m = 4;//人数,报的数(3)
int a[5] = {0};//每个人的状态
int count = 0;//目前出圈的人数
int number = 1;//当前报的数
int i = 0;//下标
while (count < 5) {
if (a[i] == 0) {
if (number != m) {
number++;
i++;
if (i >= n) {
i = 0;
}
}else {
a[i] = 1;
number = 1;
printf(“%d\n”,i);
count++;
i++;
if (i >= n) {
i = 0;
}
}

}else {
i++;
if (i >= n){
i = 0;
}
}
}

// 16、（＊＊＊＊＊）拓展题：调查学习冒泡排序以外的排序算法，并用C语言实现
return 0;
}
答案

// int a[SIZE] = {0},i= 0;
// for(i = 0; i < SIZE; i++){
// a[i] = i+10;
// printf(“a[%d] = %d\n”, i, a[i]);
// }
// 1. （＊）先调试，调试成功后抄写下列程序：
//#include <stdio.h>
//#define SIZE 10
// int main(int argc, char *argv[])
// {
// int a[SIZE] = {0},i= 0;
// for(i = 0; i < SIZE; i++){
// a[i] = i+10;
// printf(“a[%d] = %d\n”, i, a[i]);
// }
// return 0;
// }
//
// 2. （＊）将第一题中的数组a反向输出。
// printf(“\n\n”);
// for (int i = 9; i >= 0; i–) {
// printf(“a[%d] = %d\n”,i,a[i]);
// }
// 3. （＊）对第一题中的数组进行求和操作，打印计算结果。
// int sum = 0;
// for (int i = 0; i < SIZE; i++) {
// sum += a[i];
// }
// printf(“sum = %d\n”,sum);
// 4. （＊＊）计算第一题数组连减，打印计算结果。
// int num = 0;
// for (int i = 0; i < SIZE ; i++) {
// num -= a[i];
// }
// printf(“num = %d\n”,num);
// 5. （＊＊）随机产生20个10~50的正整数存放到数组中，并求数组中的所有元素最大值、最小值、平均值及各元素之和。
// int number[20] = {0};
// int max = 0;
// int min = 100;
// int sum = 0;
// for (int i = 0; i < 20; i++) {
// number[i] = arc4random()%(50-10+1)+10;
// printf(“%d “,number[i]);
// if (max < number[i]) {
// max = number[i];
// }
// if (min > number[i]) {
// min = number[i];
// }
// sum += number[i];
// }
// printf(“max = %d\n”,max);
// printf(“min = %d\n”,min);
// printf(“avg = %.2f\nsum = %d\n”,1.0*sum/20,sum);
// 6. 编写一个程序，输入两个包含5个元素的数组，先将两个数组升序排序，然后将这两个数组合并成一个升序数组。
// int a[5] = {0};
// int b[5] = {0};
// printf(“请输入a数组的5个值:”);
// for (int i = 0; i < 5; i++) {
// scanf(“%d”,&a[i]);
// }
// printf(“\n”);
// printf(“请输入b数组的5个值:”);
// for (int i = 0; i < 5; i++) {
// scanf(“%d”,&b[i]);
// }
// printf(“\n”);
//
// //对数组a排序
// //对数组b排序
// for (int i = 0; i < 5 – 1; i++) {
// for (int j = 0; j < 5 – 1 – i; j++) {
// if (a[j] > a[j+1]) {
// int temp = a[j];
// a[j] = a[j+1];
// a[j+1] = temp;
// }
// if (b[j] > b[j+1]) {
// int temp = b[j];
// b[j] = b[j+1];
// b[j+1] = temp;
// }
// }
// }
// for (int i = 0; i < 5; i++) {
// printf(“%d “,a[i]);
// }
// printf(“\n”);
// for (int i = 0; i < 5; i++) {
// printf(“%d “,b[i]);
// }
// printf(“\n”);
//
// int c[10] = {0};
// for (int i = 0; i < 10; i++) {
// if (i < 5) {
// c[i] = a[i];
// }else {
// c[i] = b[i-5];
// }
// }
// //排序c数组
// for (int i = 0; i < 10 – 1; i++) {
// for (int j = 0; j < 10 – 1 – i; j++) {
// if (c[j] > c[j+1]) {
// int temp = c[j];
// c[j] = c[j+1];
// c[j+1] = temp;
// }
// }
// }
// for (int i = 0; i < 10; i++) {
// printf(“%d “,c[i]);
// }
// printf(“\n”);

// 7. （＊＊＊）给定某年某月某日，输出其为这一年的第几天。
// int year = 0,month = 0,day = 0;
// printf(“请输入 年 月 日:”);
// scanf(“%d%d%d”,&year,&month,&day);
// int daysInMonths[12] = {31,28,31,30,31,30,31,31,30,31,30,31};
// if (year % 400 == 0 || (year % 4==0 && year % 100 != 0)) {
// daysInMonths[1] = 29;
// }
// int totalDays = 0;
// for (int i = 0; i < month – 1; i++) {
// totalDays += daysInMonths[i];
// }
// totalDays += day;
// printf(“%d\n”,totalDays);

// 8. （＊＊）编写整型值数组排序程序(冒泡排序–升序)
// int a[] = {3,-9,32,77,63,-24,14,0,21,45};
// int count = sizeof(a)/sizeof(a[0]);
// for (int i = 0;i < count – 1; i++) {
// for (int j = 0; j < count – 1 – i; j++) {
// if (a[j] > a[j+1]) {
// int temp = a[j];
// a[j] = a[j+1];
// a[j+1] = temp;
// }
// }
// }
// for (int i = 0; i < count; i++) {
// printf(“%d “,a[i]);
// }

// 9、（＊＊＊）找出下列整型数组中最大和最小值及其所在位置i。
// int a[] = {5,-9,32,77,64,-24,14,0,21,45};
// int max = -100,min = 100;
// int count = sizeof(a)/sizeof(a[0]);
// for (int i = 0; i < count; i++) {
// if (max < a[i]) {
// max = a[i];
// }
// if (min > a[i]) {
// min = a[i];
// }
// }
// printf(“max = %d min = %d\n”,max,min);
// for (int i = 0; i < count; i++) {
// if (a[i] == max) {
// printf(“最大值的下标是%d\n”,i);
// }
// if (a[i] == min) {
// printf(“最小值的下标是%d\n”,i);
// }
// }
//
// 10、（＊）把str1, str2, str3合并到result数组中。
// char result[50] = {0};
// char str1[] = “Lanou “;
// char str2[] = “23_class “;
// char str3[] = ” is niu best!”;
// strcat(result, str1);
// strcat(result, str2);
// strcat(result, str3);
// printf(“%s”,result);
// 结果：“Lanou 23_class is niu best!”
//
// 11、（＊＊）找出下面程序的错误:
// int main(int argc, char *argv[])
// {
// char string[10], str1[10];
// int i;
// for(i = 0; i < 10; i++)
// {
// str1[i] = ‘a’;
// }
// strcpy(string, str1);//缺少’\0′
// }
//
// 12、（＊＊）下面这个程序执行后会有什么错误或者效果：
// int main(int argc, char *argv[])
// {
// unsigned char str[10], i;
// for(i = 0; i < 256; i++)
// str[i] = i;//数组不要越界
// }
//
// 13、（＊＊＊）模拟n个人参加选举的过程，并输出选举结果：假设候选人有四人，分别用A、B、C、D表示，当选某候选人时，直接输入其编号(编号由计算机随机产生)，
// 若输入的不是A、B、C、D则视为无效票，选举结束后按得票数从高到低输出候选人编号和所得票数。
// int n = 20;
// int tickets[4] = {0};
// char p[4] = {‘A’,’B’,’C’,’D’};
// for (int i = 0; i < n; i++) {
// int number = arc4random()%5 + 65;
// if (number != 69) {
// tickets[number-65]++;
// }
// }
// for (int i = 0; i < 4; i++) {
// printf(“%d “,tickets[i]);
// }
// printf(“\n”);
// for (int i = 0; i < 4-1; i++) {
// for (int j = 0; j < 4-1-i; j++) {
// if (tickets[j] < tickets[j+1]) {
// int temp = tickets[j];
// tickets[j] = tickets[j+1];
// tickets[j+1] = temp;
// char temp2 = p[j];
// p[j] = p[j+1];
// p[j+1] = temp2;
// }
// }
// }
// for (int i = 0; i < 4; i++) {
// printf(“%c:%d “,p[i],tickets[i]);
// }
// 14、（＊＊＊＊）思考题：编程在一个已知的字符串中找最长单词，假定字符串中只含字母和空格，空格用来分隔不同单词。
// 比如：”ni hao world”,最长单词是world。
// char str[] = “I am a girl beautiful”;
// int maxLength = 0;//最长长度
// int currentLength = 0;//当前单词的长度(每个单词长度)
// int i = 0;//下标
// int index = 0;//最长单词的起始位置
// while (str[i] != ‘\0’) {
// if (str[i] != ‘ ‘) {
// currentLength++;
// if (str[i+1]==’\0′) {
// if (maxLength < currentLength) {
// maxLength = currentLength;
// index = i+1 – maxLength;
// }
// }
// }else {
// if (maxLength < currentLength) {
// maxLength = currentLength;
// index = i – maxLength;
// }
// currentLength = 0;
// }
// i++;
// }
// printf(“%d\n”,maxLength);
// for(int i = index;i < maxLength+index;i++){
// printf(“%c”,str[i]);
// }

// 15、（＊＊＊＊＊）思考题： 约瑟夫环的数组实现
// 约瑟夫（Josephus）问题是由古罗马的史学家约瑟夫提出的，他参加并记录了公元66-70年犹太人反抗罗马的起义。约瑟夫作为一个将军，设法守住了裘达伯特城达47天之久，在城市沦陷之后，他和40名将士在附近的一个洞穴中避难。在哪里，将士们群情激奋并表示：要投降毋宁死。于是，约瑟夫建议每个人轮流杀死他旁边的人，而这个顺序是由抽签决定的。约瑟夫有预谋地抓到了最后一签并且做为洞穴中两个幸存者之一生存下来。
// 约瑟夫环问题的具体描述是：设有编号为1，2，……，n的n(n>0)个人围成一个圈，从第一个人开始报数，报到m时停止报数，报m的人出圈，再从他的下一个人起重新报数，报到m时停止报数，报m的出圈，……，如此下去，直到只剩下一人为止。当任意给定 n和 m后，设计算法求 n个人出圈的次序。
//5个人 报到3
//1 0 1 0 1
//1 2 3 1 2
//3 1 2 3
// 1 2
// 3 1
// 2
// 3

int n = 5,m = 4;//人数,报的数(3)
int a[5] = {0};//每个人的状态
int count = 0;//目前出圈的人数
int number = 1;//当前报的数
int i = 0;//下标
while (count < 5) {
if (a[i] == 0) {
if (number != m) {
number++;
i++;
if (i >= n) {
i = 0;
}
}else {
a[i] = 1;
number = 1;
printf(“%d\n”,i);
count++;
i++;
if (i >= n) {
i = 0;
}
}

}else {
i++;
if (i >= n){
i = 0;
}
}
}

// 16、（＊＊＊＊＊）拓展题：调查学习冒泡排序以外的排序算法，并用C语言实现
return 0;
}

选择排序法

int array[5] = {2,7,4,3,8,5};
int n = 5;
for (int i = 0; i <5 – 1 ; i++) {
int min = i;
for (int j = i + 1; j < 5; j++) {
if (array[min] > array[j]) {
min = j;
}
}

if (min != i) {
int temp = array[min];
array[min] = array[i];
array[i] = temp;
}
}
for (int i = 0; i < 5; i++) {
printf(“%d “,array[i]);
}