对LessonFour的再一遍

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {

#pragma linearArray

//数组

//定义：类型说明符 数组名[常量表达式]={值1，值2....};

//初始值之间一定是用逗号隔开的

//数组的遍历:通过下标访问，下标从0开始，一直到常量表达式的值减1

//整型一维数组

//定义1、

int linearArray0[4]={1,2,3,4};

//定义2、

int linearArray1[4]={1,2};//没有赋值的位，系统默认为0

//定义3、

int linearArray2[]={1,2,3};//系统会自动计算这个数组的长度

//定义4、

int linearArray3[3]={0};//全部是0

//定义5、

int linearArray4[]={0};//这样定义并没有错，但是不建议这么定义，因为这样定义的话，最终这个数组的长度是不唯一的。

#pragma 数组的遍历

//数组的遍历

printf("数组linearArray0中的数:");

for (int i=0; i<4; i++) {

printf("%d\t",linearArray0[i]);

}

printf("\n---------------------------------------\n");

printf("数组linearArray1中的数:");

for (int i=0; i<4; i++) {

printf("%d\t",linearArray1[i]);

}

printf("\n---------------------------------------\n");

printf("数组linearArray2中的数:");

for (int i=0; i<3; i++) {

printf("%d\t",linearArray2[i]);

}

printf("\n----------------------------------------\n");

printf("数组linearArray3中的数:");

for (int i=0; i<3; i++) {

printf("%d\t",linearArray3[i]);

}

printf("\n-----------------------------------------\n");

printf("数组linearArray4中的数:");

for (int i=0; i<6; i++) {//就这个输出的时候是会出问题的。

printf("%d\t",linearArray4[i]);

}

printf("\n-----------------------------------------\n");

//数组的应用1

//录入你们班学生的c语言成绩并保存。

#define n 4

int c_score
={0};

int temp_score=0;

printf("请输入你们班同学的c语言成绩:\n");

for (int i=0; i<n; i++) {

scanf("%d",&c_score[i]);

}

for (int i=0; i<n; i++) {

for (int j=0; j<n-i-1; j++) {

if (c_score[j]>c_score[j+1]) {

temp_score=c_score[j];

c_score[j]=c_score[j+1];

c_score[j+1]=temp_score;

}

}

}

printf("成绩从低到高:");

for (int i=0; i<n; i++) {

printf("%d\t",c_score[i]);

}

printf("\n");

//数组开辟空间---元素个数*类型所占的字节数

//开辟的空间是连续的

//数组元素的访问：

//1）、不能一次调用所有的元素的值；

//2）、基本数据类型存储一个值，数组中存储多个数据

//3）、使用费下标实现数组元素的访问 数组名【下标】

//注意：下标的范围从0-（数组元素的个数-1），数组是有序的

//当下标超过数组元素的个数就成为数组越界行为。

int linearOverLimit[4]={1,4,3,2};

printf("观察越界元素的位置:\n");

for (int i=0; i<5; i++) {

printf("%d:%p\t",i,&linearOverLimit[i]);

}

printf("\n---------------------------------------------\n");

printf("观察越界元素的值:\n");

for (int i=0; i<5; i++) {

printf("%d\t",linearOverLimit[i]);

}

printf("\n-------------------------------------------------\n");

//数组越界，编译器不会检测出来的

//越界元素的地址不属于这个数组，而是跑到了外面

//越界：越界其实就是读取的位置超出了你定义的变量的内存空间位置

//一般编译的时候不会报错，但实际运行的时候可能会产生一个致命的错误

//有一条走廊，你划了一个人起点和终点，表明这段空间你占有了。如果你走出了这个范围，就表明你跑到外面去了，如果那地方没有人占有，说明你运气好，如果已经被别人占有了，这说明，你进入了别人的地盘，别人可是不会轻易饶过你的。

//总结：在进入一个圈子里思考问题时，一定要随时能够跳出那层思维圈，不然，你只会原地踏步。

//得到数组的长度 --用sizeof(数组名)/sizeof（数组的数据类型） --返回值是int

int lengthOfLinearArray=0;

lengthOfLinearArray=sizeof(linearOverLimit)/sizeof(int);

printf("linearOverLimit的长度:%d\n",lengthOfLinearArray);

//注意:数组作为一个整体时是不能参与运算的。

//定义一个数组，具有20个整型元素，每个元素的取值范围是2-13之间，求元素的和。

printf("----------------------------------------------\n");

int linearArrayOfInt[20]={0};

int sumOfArray=0;

for (int i=0; i<20; i++) {

linearArrayOfInt[i]=arc4random()%(13-2-1)+2;

sumOfArray+=linearArrayOfInt[i];

}

for (int i=0; i<20; i++) {

if (i%10==0) {

printf("\n");

}

printf("%d\t",linearArrayOfInt[i]);

}

printf("\n这些随机数的和:%d\n",sumOfArray);

//复制一个数组，要有两个数组，把其中一个的值，复制到另一个数组中。

//生成2个数组，每个数组具有10个元素，范围是20-30，数组对应的元素相加，存放到第三个数组中。

int linearArrayOfCopy1[10]={0};

int linearArrayOfCopy2[10]={0};

int linearArrayOfThird[10]={0};

printf(" ");

for (int i=0; i<10; i++) {

linearArrayOfCopy1[i]=arc4random()%(30-20+1)+20;

linearArrayOfCopy2[i]=linearArrayOfCopy1[i];

printf("%d\t",linearArrayOfCopy1[i]);

}

printf("\n-----------------------------------------\n");

printf("+");

for (int i=0; i<10; i++) {

printf("%d\t",linearArrayOfCopy2[i]);

}

printf("\n------------------------------------------\n");

printf("=");

for (int i=0; i<10; i++) {

linearArrayOfThird[i]=linearArrayOfCopy1[i]+linearArrayOfCopy2[i];

printf("%d\t",linearArrayOfThird[i]);

}

printf("\n");

//冒泡排序

printf("练习冒泡排序:\n");

//随机产生10个20-40之间的数，排序。

int arraySort[10]={0};

int tempSort=0;

printf("排序前:\t");

for (int i=0; i<10; i++) {

arraySort[i]=arc4random()%(40-20+1)+20;

printf("%d\t",arraySort[i]);

}

for (int i=0; i<10; i++) {

for (int j=0; j<10-i-1; j++) {

if (arraySort[j]>arraySort[j+1]) {

tempSort=arraySort[j];

arraySort[j]=arraySort[j+1];

arraySort[j+1]=tempSort;

}

}

}

printf("\n-------------------------------------\n");

printf("排序后:\t");

for (int i=0; i<10; i++) {

printf("%d\t",arraySort[i]);

}

printf("\n");

//一维数组的冒泡排序的优化

#define N 4

int arrayOfSortBetter1
={0,1,2,3};

int tempOfSortBetter=0;

BOOL flagFor=NO;//表示某一趟没有交换过，也就是到了该趟，就已经排好序了.

printf("（用的for写的）冒泡排序的优化:\n");

printf("排序前:\t");

for (int i=0; i<N; i++) {

arrayOfSortBetter1[i]=arc4random()%(40-20-1)+20;

printf("%d\t",arrayOfSortBetter1[i]);

}

printf("\n-------------------------------------\n");

for (int i=0; i<N; i++) {

flagFor=NO;//当每一趟比较完后又把flag记为NO,表示当前还没有进行交换。

//要记住这里必须对falg赋值，不然当上一次交换过，对flag赋值为YES,就一直是YES,没有任何的改变，当这层循环过后，对flag的判断就一直是假的。所以，这里的赋值很重要。

for (int j=0; j<N-i-1; j++) {

if (arrayOfSortBetter1[j]>arrayOfSortBetter1[j+1]) {

tempOfSortBetter=arrayOfSortBetter1[j];

arrayOfSortBetter1[j]=arrayOfSortBetter1[j+1];

arrayOfSortBetter1[j+1]=tempOfSortBetter;

flagFor=YES;

}

}

if (flagFor==NO) {

//这个趟数是从0开始数的

printf("到了第%d趟，就已经排好序了.\n",i-1);

break;

}

}

printf("排序后:\t");

for (int i=0; i<N; i++) {

printf("%d\t",arrayOfSortBetter1[i]);

}

printf("\n");

//二维数组的冒泡排序

#define A 5 //行数

#define B 4 //列数

//定义一个二维数组

int a[A][B]={0};

//定义一个中间变量，交换时使用

int tempDoubleRow=0;

printf("对二维数组的行排序:\n");

printf("排序前:\n");

for (int i=0; i<A; i++) {

for (int j=0; j<B; j++) {

//随机数

a[i][j]=arc4random()%(30-10+1)+10;

printf("\t%d\t",a[i][j]);

}

printf("\n");

}

for (int i=0; i<A; i++) {

for (int j=0; j<B; j++) {

for (int k=0; k<B-j-1; k++) {

if (a[i][k]>a[i][k+1]) {

//交换过程

tempDoubleRow=a[i][k];

a[i][k]=a[i][k+1];

a[i][k+1]=tempDoubleRow;

}

}

}

}

printf("排序后:\n-----------------------------------\n");

for (int i=0; i<A; i++) {

for (int j=0; j<B; j++) {

printf("\t%d\t",a[i][j]);

}

printf("\n");

}

printf("\n");

#define ROWS 3 //行数

#define COLUMNS 5 //列数

printf("对二维数组内部排序:\n");

//定义一个二维数组

int numberArray[ROWS][COLUMNS]={0};

//定义一个中间变量，交换时使用

int tempDoubleAll=0;

printf("排序前:\n");

for (int i=0; i<ROWS; i++) {

for (int j=0; j<COLUMNS; j++) {

//随机数

numberArray[i][j]=arc4random()%(20-10+1)+10;

printf("%d\t",numberArray[i][j]);

}

printf("\n");

}

printf("\n------------------------------\n");

//把二维数组转换为一维数组

printf("转换为一维数组并显示:\n=========================\n");

//定义一个一维数组，用来存放上面的二维数组中的数据

int numberArrayLinear[ROWS*COLUMNS]={0};

for (int i=0; i<ROWS;i++) {

for (int j=0; j<COLUMNS; j++) {

//当时自己怎么都没有找到错误的地方，后来给中情看了一下，她发现在把二维数组的值转换给一维数组的时候，出现了数据覆盖问题，就是因为自己在写下标的时候，自己没有太注意，所以，程序员一定要细心。

//numberArrayLinear[i*j+j]=numberArray[i][j];

numberArrayLinear[i*COLUMNS+j]=numberArray[i][j];

printf("%d\t",numberArrayLinear[i*j+j]);

}

}

printf("\n------------------------------\n");

//对一维数组进行冒泡排序

for (int i=0; i<ROWS*COLUMNS; i++) {

for (int j=0; j<ROWS*COLUMNS-i-1; j++) {

if (numberArrayLinear[j]>numberArrayLinear[j+1]) {

tempDoubleAll=numberArrayLinear[j];

numberArrayLinear[j]=numberArrayLinear[j+1];

numberArrayLinear[j+1]=tempDoubleAll;

}

}

}

//打印出排完序的一维数组

printf("一维的排好序后:\n=============================\n");

for (int i=0; i<ROWS*COLUMNS; i++) {

printf("%d\t",numberArrayLinear[i]);

}

//再把排完序的一维数组转换成二维数组，并打印该二维数组

printf("\n排完序:\n------------------------------------\n");

for (int i=0; i<ROWS; i++) {

for (int j=0; j<COLUMNS; j++) {

//这里也出现跟之前一样的问题了。后来改过来的。

numberArray[i][j]=numberArrayLinear[i*COLUMNS+j];

printf("%d\t",numberArray[i][j]);

}

printf("\n");

}

printf("\n");

//字符数组

//定义字符数组

//方式1、

char charArray[7]={'B','e','i','j','i','n','g'};

//方式2、

char charArray1[]="Beijing";

//特殊的字符数组:字符串

//存储字符串元素个数=有效字符个数+1，为什么加1，是因为字符串末尾有'\0'，所以内存空间比一般的字符数组多1

//字符数组的元素个数有多少个就是多少个

//就取地址来看，可以看出字符串和一般字符数组的区别

printf("一般字符数组:\t");

for (int i=0; i<7; i++) {

printf("%c",charArray[i]);

}

printf("\n------------------------------------\n");

for (int i=0; i<7; i++) {

printf("%c的地址:%p\t",charArray[i],&charArray[i]);

}

printf("======================================\n");

printf("字符串:\t");

for (int i=0; i<8; i++) {

printf("%c",charArray1[i]);

}

printf("\n------------------------------------\n");

printf("对应的ASCII码:\t");

for (int i=0; i<8; i++) {

printf("%d\t",charArray1[i]);

}

printf("\n-------------------------------------\n");

//因为strlen是求出字符串中有效字符的长度，不包括末尾的'\0'

printf("用strlen输出对应的ASCII码的区别:\n");

for (int i=0; i<strlen(charArray1); i++) {

printf("%d\t",charArray1[i]);

}

printf("\n-------------------------------------\n");

for (int i=0; i<8; i++) {

printf("%c的地址:%p\t",charArray1[i],&charArray1[i]);

}

//用strlen的话，这个输出地址就不包括'\0'

//strlen求出来的长度比实际内存所占长度要少1

printf("\n------------------------------------\n");

printf("以及用strlen控制长度输出的地址区别:\n");

for (int i=0; i<strlen(charArray1); i++) {

printf("%c的地址:%p\t",charArray1[i],&charArray1[i]);

}

printf("\n=====================================\n");

//字符串是一个字符数组

//存储字符串的数组，可以输出单个的字符，也可以用%s输出完整的字符串。输出的时候遇到'\0'结束输出。

printf("单个打印字符串:\t");

for (int i=0; i<strlen(charArray1); i++) {

printf("%c\t",charArray1[i]);

}

printf("\n=====================================\n");

printf("直接全部输出字符串:\t%s\n",charArray1);

//1、字符串长度 --strlen(字符串); --返回值unsigned long --%lu输出

//这个长度是有效字符的长度，不包括末尾的'\0'

char logotype[]="hei";

printf("%s的长度:%lu\n",logotype,strlen(logotype));

//2、字符串拷贝 --strcpy(字符串1，字符串2);

//把字符串2拷贝给字符串1

//字符串2可以是常量。

//字符数组1的存储空间>=字符数组2的存储空间

//注意'\0'的空间也要计算进去

//**给一个字符串赋值，只能用strcpy函数，不能直接用另外一个字符串去赋值给这个字符串.

printf("=========================================\n");

char xing[10]="zhou";

char ming[10]="yi";

char errorName[]="mingtian";//第一次定义的时候，给出了长度

// errorName[8]="shangxin";//第二次赋值时，必须给出长度,也是错误的。字符数组赋值，要么初始化赋值，要么用strcpy()赋值。

// char errorName1[8]; //这样赋值也是错的。

// errorName1[8]="dd";

// printf("第二次赋值后的errorName:%s\n",errorName);

//errorName[]="shangxin";这样的定义是错误的，一定要谨记。

//当第一次定义的时候，系统已经为errorName分配好了内存，所以在第二次赋值的时候，一定要补上长度以及赋的值的长度一定要小于他本身占有的内存空间

printf("%s拷贝前:%s\n",xing,xing);

printf("拷贝后:%s\n",strcpy(xing,ming));

printf("------------------------------------------\n");

printf("字符串2为常量，赋给字符串1:%s\n",strcpy(xing,"what are you doing,"));

//3、字符串拼接 --strcat(字符串1，字符串2);

//把字符串2的值直接拼接大字符串1的末尾

//字符串1的内存空间必须能够容下自身和字符串2

//字符串1的'\0'取消了，只在新的字符串后面有一个'\0'

printf("-------------------------------------------\n");

printf("拼接:%s?\n",strcat(xing,ming));

//4、字符串比较 --strcmp(字符串1，字符串2) --返回值是int

//字符串1的字符-字符串2的字符

//结果>0 字符串1大

// <0 字符串1小

// =0 相等

printf("-------------------------------------------\n");

char xing1[10]="bell";

char ming1[10]="beln";

printf("%s比%s的长度:%d\n",xing1,ming1,

strcmp(xing1, ming1));

//查找字符串中的空格数

printf("-------------------------------------------\n");

char sentence[]="you know,she will abandon him.";

int countKongge=0;

for (int i=0; i<strlen(sentence); i++) {

if (sentence[i]==' ') {

countKongge++;

}

}

printf("%s一共有%d个空格.\n",sentence,countKongge);

//定义一个字符串，倒序输出这个字符串

//方法1

printf("------------------------------------------\n");

char daoxu[]="zhouyi";

for (int i=6; i>=0; i--) {

printf("%c",daoxu[i]);

}

printf("\n----------------------------------------\n");

//方法2

char daoxu1[6]={0};

int j=6;//注意变量的作用域，有时候，往往就是这个会导致出错，但总是找不出，所以，逻辑一定要很清晰才是。之前出错是因为把int j=6;写在了下面的循环里面了，以至于每次的j都等于6，就算j--了，但是还是会回到j=6这样的初值当中。

for (int i=0; i<6; i++) {

daoxu1[j]=daoxu[i];

j--;

}

for (int i=0; i<6; i++) {

printf("%c",daoxu1[i]);

}

printf("\n");

return 0;

}