ios--c DAY_4

//
//  main.m
//  LessonFour
//
//  Created by lanou3g on 15/7/31.
//  Copyright (c) 2015年 lanou3g. All rights reserved.
//

#import <Foundation/Foundation.h>

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

    //数组是一种构造类型
    //是相同数据类型的一个集合
    
    //构造类型：结构体、枚举、数组、共用体.
    
    //一维数组:
    //类型说明符 数组名[常量表达式]={值1,值2...};
    //初始值之间用逗号隔开

    int numberArray[4]={0};
    for (int i=0; i<4; i++) {
        printf("%d\t",numberArray[i]);
    }
    printf("\n");
    
    float oc_score[6]={98,90,87,79,85,92};
    for (int i=0; i<6; i++) {
        printf("%.0f\t",oc_score[i]);
    }
    printf("\n");
    
    
    //1、
    int a[3]={1,2,3};
    //2、数组中没有赋初值的元素，自动设置为0
    int b[5]={1,2,3};
    //3、
    int c[5]={0};
    //4、根据初始化的设置,自动计算数组的个数
    int d[]={1,2,3,4,5};
    
    
    int e[3]={1,1,2,3};//不报错，这样是不行的，是错误的。元素个数要小于初值的个数.
    
    int f[]={0};//这是不规范的。既没有确定元素个数，也没有赋初值
    
    //数组开辟空间---元素个数*类型所占的字节数
    //开辟的空间是连续的
    
    //数组元素的访问:
    //1）、不能一次调用所有元素的值；
    //2）、基本数据类型存储一个值，数组中存储多个数据.
    //3）、使用下标实现数组元素的访问  数组名[下标]
    //注意：下标的范围从0-（数组元素个数-1），数组是有序的。
    //当下标超过数组元素的个数就成为数组越界行为。
    
    int array[4]={1,2,3,4};
    for (int i=0; i<4; i++) {
        printf("%d\t",array[i]);
    }
    //倒序输出
    for (int i=3; i>=0; i--) {
        printf("%d\t",array[i]);
    }
    printf("\n");
    
    for (int i=0; i<4; i++) {
        printf("%d的地址:%p\t",array[i],&array[i]);
    }
    //数组越界，编译器不会检测出来
     //越界元素的地址不属于这个数组，而是跑到了外面
    printf("\n越界元素的地址:%p\n",&array[4]);
    printf("打印越界元素:%d\n\n",array[4]);
     
     //array[4]:*(array+4) 其中array是数组基地址
     
    //越界：越界其实就是读取的位置超出了你定义的变量的内存空间位置
//    一般编译的时候不会报错，但实际运行的时候可能会产生一个致命的错误
     
//     有一条走廊，你划了一个起点和终点，表明这段你占有了。如果你走出了这个范围，就表明你跑到外面去了，如果那地方没有人占有，说明你运气不错； 如果已是别人的地方了，这说明你进入了别人的地方，别人可要收“过路费”的哟（付出代价，程序崩溃）。
//   
     //再比如
     int array3[5]={11,22,33,44,55};
     printf("%d\n",array3[5]);
     //数组索引5是过去数组的结尾（包含5个元素
    
    //修改数组元素
    int arr1[]={1,2,3,4,5};
    //遍历所有元素
    for (int i=0; i<5; i++) {
        printf("%d\t",arr1[i]);
    }
//    printf("\n--------------------------\n");
//    arr1[1]=8;
//    for (int i=0; i<5; i++) {
//        printf("%d\t",arr1[i]);
//    }
    printf("\n");
    
    printf("---------------------------\n");
    for (int i=0; i<5; i++) {
        arr1[i]+=5;
        printf("%d\t",arr1[i]);
    }
    printf("\n");
     //总结，在进入一个数学的逻辑思维之后，一定要学会能随时跳出来，不然，只会越钻越深，进入死胡同，这样的程序思维是不可取的。
     
    
    
    int arr2[5]={0};
    for (int i=0; i<5; i++) {
        arr2[i]=arc4random()%(20-10+1)+10;
    }
    for (int i=0; i<5; i++) {
        printf("%d\t",arr2[i]);
    }
    printf("\n");
    
    
    //得到数组长度
    int array1[]={1,2,3,45,3};
    printf("%d\n",sizeof(array1)/sizeof(int));
    
    
    //用循环的方式赋值，10个元素的值是【30，42】之间的随机数。
    
    int array2[10]={0};
    for (int i=0; i<10; i++) {
        array2[i]=arc4random()%(42-30+1)+30;
        printf("%d\t",array2[i]);
    }
    printf("\n");
    
    //注意：数组做一个整体是不能参与运算的。
    
    //定义一个数组，具有20个整型元素，每个元素的取值范围是2-13之间。求元素的和。
    
    int array4[20]={0};
    int sumOfarray4=0;
    for (int i=0; i<20; i++) {
        array4[i]=arc4random()%(13-2+1)+2;
        sumOfarray4+=array4[i];
    }
    for (int i=0; i<20; i++) {
        
        printf("%d\t",array4[i]);
    }
    printf("\n和:%d\n",sumOfarray4);
    
    
    //复制一个数组，要有两个数组，把其中一个的值，复制到另一个的数组中。
    
    //生成2个数组，每个数组有10个元素，范围是20-30，数组对应的元素相加，存放到第三个数组中。
    
    int arrayA[10]={0},arrayB[10]={0},arrayC[10]={0};
    for (int i=0,j=0; i<10,j<10; i++,j++) {
        arrayA[i]=arc4random()%(30-20+1)+20;
        arrayB[j]=arrayA[i];
        arrayC[i]=arrayA[i]+arrayB[j];
    }
    printf(" ");
    for (int i=0; i<10; i++) {
        printf("%d\t",arrayA[i]);
    }
    printf("\n+");
    for (int i=0; i<10; i++) {
        printf("%d\t",arrayB[i]);
    }
    printf("\n---------------------------------------\n=");
    for (int i=0; i<10; i++) {
        printf("%d\t",arrayC[i]);
    }
    printf("\n\n");
    
     
    
    //冒泡排序
    int arraySort0[5]={12,34,3,24,44};
    int tempSort0=0;
    for (int i=0; i<5; i++) {
        printf("%d\t",arraySort0[i]);
    }
    printf("\n----------------------------------\n");
    for (int i=0; i<5; i++) {
        for (int j=0; j<5-i-1; j++) {
            if (arraySort0[j]>arraySort0[j+1]) {
                tempSort0=arraySort0[j];
                arraySort0[j]=arraySort0[j+1];
                arraySort0[j+1]=tempSort0;
            }
        }
    }
    for (int i=0; i<5; i++) {
        printf("%d\t",arraySort0[i]);
    }
    printf("\n");
    
    
    //随机产生10个[20,40]的数，排序。
    
    int arraySort[10]={0};
    for (int i=0; i<10; i++) {
        arraySort[i]=arc4random()%(40-20+1)+20;
        printf("%d\t",arraySort[i]);
    }
    printf("\n-----------------------------------\n");
    int tempSort=0;
    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;
            }
        }
    }
    for (int i=0; i<10; i++) {
        printf("%d\t",arraySort[i]);
    }
    printf("\n");
   
    //二维数组的冒泡排序
    //最主要的是找准要在哪去做排序这个过程
    int arraySortDouble[3][4]={12,3,54,23,12,34,43,99,12,23,32,1};
    for (int i=0; i<3; i++) {
        for (int j=0; j<4; j++) {
            printf("%d\t",arraySortDouble[i][j]);
        }
        printf("\n");
    }
    int tempSortDouble=0;
    for (int i=0; i<3; i++){
        for (int j=0; j<4;
             j++) {
            for (int m=0; m<4-j-1; m++) {
                if (arraySortDouble[i][m]>arraySortDouble[i][m+1]) {
                    tempSortDouble=arraySortDouble[i][m];
                    arraySortDouble[i][m]=arraySortDouble[i][m+1];
                    arraySortDouble[i][m+1]=tempSortDouble;
                }
            }
        }
    }
    
    printf("\n-----------------------\n");
    for (int i=0; i<3; i++) {
        for (int j=0; j<4; j++) {
            printf("%d\t",arraySortDouble[i][j]);
        }
        printf("\n");
    }
    printf("\n");
    
    //一维数组的冒泡排序的优化算法
    int arraySortSingle[5]={1,2,3,4,5};
    int tempSortSingle=0;
    BOOL flagSort=NO;//默认是都没有交换过
    for (int i=0; i<5; i++) {
        for (int j=0; j<5-i-1; j++) {
            if (arraySortSingle[j]>arraySortSingle[j+1]) {
                tempSortSingle=arraySortSingle[j];
                arraySortSingle[j]=arraySortSingle[j+1];
                arraySortSingle[j+1]=tempSortSingle;
                flagSort=YES;//交换过
            }
        }
        if (flagSort==NO) {
            printf("第%d趟后就不用交换了.\n",i);
            break;
        }
    }
    for (int i=0; i<5; i++) {
        printf("%d\t",arraySortSingle[i]);
    }
    printf("\n");
    
    
    //字符数组
    //定义字符数组
    //方式1、
    char a1[4]={'a','b','c'};//默认设置'\0',空操作符，输出的时候，是不显示的。
    for (int i=0; i<4; i++) {
        printf("%c\t",a1[i]);
    }
    printf("\n--------------\n");
    char b1[]={'a','b','c'};
    char c1[10]={0};//全部是'\0'对应的%d输出为0
    for (int i=0; i<10; i++) {
        printf("%c\t",c1[i]);
    }
    printf("\n----------------------------------\n");
    
    c1[2]='A';
    c1[5]='\0';
    c1[6]='m';
    c1[9]='D';
    for (int i=0; i<10; i++) {
        printf("%c\t",c1[i]);
    }
    printf("\n");
    
    //方式2、两种的区别
    char str[]="hello";//字符串自身后面就有一个'\0'，分配6个内存空间,但是字符串长度为5---有效字符的长度
    char str1[]={'h','e','l','l','o'};//只有5个内存空间
    //打印一下他们各自的地址，看一下
    printf("字符串所占的地址:");
    for (int i=0; i<6; i++) {
        printf("%p\t",&str[i]);
    }
    printf("\n----------------------\n");
    printf("字符数组所占的地址:");
    for (int i=0; i<6; i++) {//字符占1个字节，查看输出结果会发现str1[5]和str1[4]
        printf("%p\t",&str1[i]);//的地址是不连续的，所以str1[5]属于数组越界
    }
    printf("\n-------------------------\n\n");
    
    //存储字符串的字符数组元素个数=有效字符个数+1;
    
    //字符数组不一定是字符串
    //字符串是一个字符数组
    
    //存储字符串的数组，可以输出单个的字符，也可以用%s输出完整的字符串。输出的时候遇到'\0'结束输出。
    printf("字符串本身：%s",str);
    printf("\n-----------------------\n");
    printf("单个输出字符串:\t");
    for (int i=0; i<6; i++) {
        printf("%c\t",str[i]);//最后一个'\0'转换成%d时为0,对应的ASCII码
    }
    printf("\n------------------------------\n");
    printf("转换成ASCII码:\t");
    for (int i=0; i<6; i++) {
        printf("%d\t",str[i]);
    }
    printf("\n");
#pragma mark 字符串操作函数
    //1、字符串长度  --strlen（字符串）; ---返回值unsigned long  ----%lu输出
    //这个长度是有效字符的长度，不包括末尾的'\0'
    char name[]="yibella";
    printf("%s的长度:%lu\n",name,strlen(name));
    
    //2、字符串拷贝  --strcpy(字符串1，字符串2);
    
    char name1[]="gold";
    char name2[5]={0};//如果这里，没有定义name2的长度，输出的时候，name1的第一个字符不输出
    strcpy(name2, name1);
    //字符串2可以是常量。
    //字符数组1的存储空间>=字符数组2的存储空间
    //注意'\0'的空间也要计算进去
    //** 给一个字符数组赋值，只能用strcpy函数，不能直接用另一个字符数组去赋值给这个字符数组。比如:name2=name1。这是完全错误的。
    printf("本身:%s,影子:%s\n",name1,name2);
    
    //3、字符串拼接 --strcat(字符串1，字符串2);
    //把字符串2的值直接拼接到字符串1的末尾
    //字符串1的内存空间必须能够容下自身和字符串2
    //字符串1的'\0'取消了，只在新的字符串后面有一个'\0'
    
    char welcome1[50]="Welcome";
    char welcome2[]=" to China.";//如果这里不加空格的话，拼接之后，to的t就连着Welcome的w。因为拼接的过程中，welcome1后面的'\0'就自动消失了。
    strcat(welcome1, welcome2);
    printf("%s\n",welcome1);
    
    
    //4、字符串比较   --strcmp(字符串1，字符串2)
    //字符串1的字符-字符串2 的字符
    //结果>0 字符串1大
    //   <0 字符串1小
    //   =0 相等
    
     char compare1[]="yibella";
    char compare2[]="bellayi";
    int resultCompare=strcmp(compare1, compare2);
    if (resultCompare>0) {
        printf("%s比%s大.\n",compare1,compare2);
    }else if (resultCompare<0){
        printf("%s比%s小.\n",compare1,compare2);
    }else{
        printf("%s和%s一样大.\n",compare1,compare2);
    }
     
    //查找字符串中的空格数  "i will right here waitting for you "
    char findString[]="i will right here waitting for you ";
    int countFind=0;
    for (int i=0; i<strlen(findString); i++) {
        if (findString[i]==' ') {
            countFind++;
        }
    }
    printf("for找到的共有%d个空格\n",countFind);
    
    int i=0;
    countFind=0;
    while (findString[i]!='\0') { //因为字符串是以'\0'为结束的标识符
        if (findString[i]==' ') {
            countFind++;
        }        i++;
    }
     printf("while找到的共有%d个空格\n",countFind);
   
    
    //定义一个字符串，倒序输出这个字符串
    //1、
    printf("利用数组的倒序:");
    char printString[]="mnthqwer";
    for (int i=strlen(printString); i>=0; i--) {
        printf("%c",printString[i]);
    }
    printf("\n--------------\n");
    //2、
    //利用第三方来交换后获得倒序字符串
    printf("老大老实的计算:");
    char printOther[10]={0};
    int lengthOfprintString=0;
    lengthOfprintString=strlen(printString);
    for (int i=0; i<lengthOfprintString; i++) {
        printOther[i]=printString[lengthOfprintString-1-i];
    }
    for (int i=0; i<lengthOfprintString; i++) {
        printf("%c",printOther[i]);
    }
    printf("\n");
    
    return 0;
}