C 入门 第四节

/*
    1. 数组属于构造类型
    2. 具有相同数据类型成员数组的一组数据
    3. 存储不同类型数据的数据有对应的名称,整形数组;数组中成员变过来都整型的;浮点型数组:数组中成员变量都浮点型的
    4. 数组是由多个成员组成,每个成员被称为数组元素
 
    定义数组
    类型修饰符 数组名[常量表达式] = [值1, 值2, 值3];
    1. 类型修饰符: 指定数组中元素的类型
    2. []中设定数组元素的个数,即数组的存储空间.只能是常量表达式,不能是变量表达式.
    3. 初始值之间用,隔开
    4. 定义一个整型数组,存放( ⊙ o ⊙ )3个数组元素 2, 3, 4
    
    int a[3] = {1, 3, 4,};
    float a[5] = {1, 2, 3, 4, 5};
 
    定义数组的方式 1:没有赋值初始的元素,自动设置初始值为0;
    int b[5] = {3, 4, 5};
    
    定义数组方式 2:
    int c[3] = {0};
        
    定义数组方式 3:根据初始化设置,判断数组元素个数
    int d[] = {3, 4, 5, 6};
 
    错误的 定义数组方式 1 :指定的数组元素个数<设定初始值的数量
    int e[2] = {3, 4, 5,6};
 
    错误的 定义数组方式 2: 既没有指定元素个数, 也没有赋值初始值
    int f[] = {0};
 
    定义数组后, 数组的存储空间是连续的
    数组的存储空间 = 数组元素的个数*元素占的字节
    
    printf("%lu ",sizeof(e));
 
 访问数组元素
    1. 不能一次整体调用整个数组全部元素的值,基本数据类型变量中值存储一个数据.数据中存储多个数据,不能通过数组变过来调用所有的元素.
    2. 访问数组元素 使用下标实现 数组名[下标]
    3. 下标: 数组元素在数组中序号,数组中的元素是有序的, 每个元素都有序号,序号从0开始递增, 最后一个元素的序号是 n-1, n表示数组元素的个数
    4. 下标的范围: 0~n-1
    5. 下标可以用整型常量或变量表示
 
 遍历数组
    1. 按照顺序,从数组的第一个元素开始,访问数组的最后一个元素结束
    2. 使用for循环实现数组遍历
    3.循环和数组关系密切
 */
 /*
    int age[5] = {18,15,23,28,21};
    printf("%d ",age[0]);
    
    for (int i = 0; i < 5; i ++)
    {
        printf("%d ",age[i]);
    }
 
// 修改数组元素:根据数组下标确定需要修改的数组元素
    int aa[] = {1,2,3,4,6};
//遍历数组
    for (int i = 0; i <5; i ++)
    {
        printf("%d ",aa[i]);
    }
//修改数组元素
    aa[1] = 22;
    aa[3] = 44;
    for (int j = 0; j < 5; j ++)
    {
        printf("%d ",aa[j]);
    }

//   通过循环方式给数组元素赋值
//    1. 定义一个数组, 必须设置数组元素数量, 数组元素初值为0
//    2. 透过循环给数组元素赋值
    
    int num[5] = {0};
//  在 0 ~ 10 之间取随机数,分别赋给每个元素
    for (int i = 0; i < 5; i ++)
    {
        num[i] = arc4random()%(10 - 0 + 1) + 0;
        printf("%d ",num[i]);
    }

// 定义一个具有10个元素的整型数组,每个元素的值在30 ~ 80之间取随机数.
    
    int num[10] = {0};
    for (int i = 0; i < 10; i ++)
    {
        num[i] = arc4random()%(80 - 30 + 1) + 30;
        printf("%d ",num[i]);
    }

//越界
//    1. 使用数组下标是,超出下标范围.
//    2. 数组越界很危险,一旦越界, 即访问了不属于数组的存储空间
//    3. 编译器不会检测数组下标是否越界,因此操作数组是必须保证没有越界
//
    int Crazy[4] = {3,4,5,6};
    printf("%d ",Crazy[4]);
    
    注意事项:
    定义数组  类型 数组名[元素个数]
    数组元素      数组名

    int c = 0;
    int a[5] = {1,2,3,4,5};
    int b[5] = {0};
    for (int i = 0; i < 5; i++)
    {
        c = a[i];
        b[i] = c;
        printf("%d ",b[i]);
    }
    printf(" ");
*/
    
#pragma mark  ------数组排序--------
 /*
    1. 常见的排序方法:冒泡排序,选择排序.插入排序等
    2. 排序的规律有俩种:升序, 降序
    3. 本节课: 冒泡排序
    4. 冒泡排序的思路:每次将相邻的俩个数进行比较,按照升序或降序进行交换,直到所有数字的顺序正确为止

    int a[5] = {5, 4, 3, 2, 1};
    for (int i = 0; i < 5; i ++)  //外循环,控制循环排序趟数;5
    {
        for (int j= 0; j < 5 - 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 < 5; i++)
    {
        printf("%d ",a[i]);
    }

//        随机产⽣生10个[20,40]数,并对10个数从⼩小到⼤大排序
    int a[10] = {0};
    for (int i = 0; i < 10; i ++)
    {
        a[i] = arc4random()%(40 - 20 + 1) + 20;
        //    printf("%d ",a[i]);
    }
    printf(" ");
    for (int j = 0; j < 10 - 1; j ++)
    {
        for (int z = 0; z < 10- j - 1; z ++)
        {
            int temp;
            if (a[z] > a[z + 1])
            {
                temp = a[z];
                a[z] = a[z + 1];
                a[z + 1] = temp;
            }
        }
    }
    for (int i = 0;i < 10; i ++)
    {
        printf("%d ",a[i]);
    }
*/  
#pragma mark  --------字符数组--------
//    1. 数组元素存储的是字符.
//    定义字符数组
/*
    char a[5] = {'h','e','l','l','o'};
    char b[] = {'h','e','l','l','o'};
    char c[10] = {'h','e','l','l','o'};
    a[3] = 't';   //修改
    printf("%c ",a[3]);   //访问

// 字符串
    定义字符数组存储字符串
    char a[] = "hello";
    char b[] = {'h','e','l','l','o',''}; //有 是字符串  没有是数组
      
    1 . 字符串常量 "hello"
    2 . 使用字符数组存储字符串
    3 . 使用%s, 输出字符串
    
    定义字符数组存储字符串
    1 . char a2[] = "hello";
    系统如何识别字符串: ''  数据存储在内存中,系统如何识别那先字符属于一个完整的字符串
    ''是字符串结束标志,在字符串的最后一位,由系统默认添加,不可以显示
    "hello"存储时,实际上是: 'h','e','l','l','o',''
    有效字符: 在字符串中,''之前的字符
    字符数组a2中存储字符串: 数组元素为 'h','e','l','l','o',''
    存储字符串的字符数组元素个数: 有效字符个数  + 1
    输出字符串: printf("%s",a2)
   
    字符串和字符数组的关系
    1 .字符串是一个字符数组
    char p[] = "hello" //字符串
    char q[] = {'h','e','l','l','o'} //数组
    p  q  都是数组
    俩个数组存储的内容都是  字符串hello
    都可以访问,修改数组元素,遍历
    for (int i; i < sizeof(p)/sizeof(char); i ++)
    {
        printf("%c ",p[i]);
    }
    
    2 . 字符数组不一定是字符串但是字符串一定是字符数组.
    3 . 存储字符串的数组,可以输出单个字符,也可以使用%输出完整字符串,使用%s输出时,遇到''是结束
    char a3[] = {'h','e','l','l','o',''};
    printf("%s ",a3);
    
    4 . 字符数组储存字符的数组, 只能输出单个字符
    char a4[] = {'h','e','l','l','o',''};
    for (int i; i < sizeof(a4) / sizeof(char); i ++)
    {
        printf("=====%c ",a4[i]);
    }
    printf(" ");
    printf("+++++++%s ",a4); //输出结果可能出问题,因为不知道什么时候才能读到'0'
*/
#pragma mark ------字符串操作函数---------
/*
1 . strlen 测量字符串常量.
    测量的是字符串的时间长度,不包含'/0'

    char name[] = "wangshuai";
    printf("%s的长度;%lu ",name,strlen(name));
    
//2 . strcpy 字符串拷贝
    字符串2可以是常量,字符数组名
    字符数组1的存储空间 >= 字符数组2  注意''
    牢记:吧一个字符数组的值给另一个字符赋值,只能用strcpy函数,不能直接堆一个字符数组赋值
    char a12[5] = {0};
    char b12[] = "lanou";
    strcpy(a12, b12);
    printf("%s ",a12);
 
*/
/*
    char a22[30] = "lanou";
    char b22[] = "teacher";
3 .strcat(a22, b22);
    //将字符串2拼接到字符串1后,结果保留在字符串1中
    //字符数组2可以是常量
    //字符数组1的空间必须足够大
    //拼接之后,字符串1后面的''取消,只在新的字符串后面保留''
    printf("%s ",a22);
4 . strcmp 字符串比较
    char a[] = "apple";
    char b[] = "goole";
    //将俩个字符串自左向右逐个字符相比(按ASDII吗值大小比较),直到出现不同的字符或者是遇到''为止
    //字符串1的字符 - 字符串2的字符
    //字符串1 = 字符串2,则函数结果为0
    //字符串1 > 字符串2,则函数结果为正整数
    //字符串1 < 字符串2,则函数结果为负整数
    printf("%d ",strcmp(a, b));
    printf("%d ",strcmp("apple", "apple"));
    //查找字符串中的空格:例如:"I LOVE iOS, i want iphone6sp"
    char str[] = "I LOVE iOS, i want iphone6sp";
    int nn = 0;
    int count = 0;
    while (str[nn])
    {
        if (str[nn] != '0')
        {       
        count ++;
        }  
    nn ++;
    }
    printf("空格数是:%d ",count);
*/