iOS开发学习之C语言---C04 一维数组、字符数组

//

//  main.m

//  CLesson04

//

//  Created by 康 亮亮 on 15/10/10.

//  Copyright (c) 2015年 Darling.com. All rights reserved.

//  一维数组、数组排序、字符数组

#import <Foundation/Foundation.h>

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

#pragma mark 一维数组

        定义一个数组

    //    long a = 12;// 类型声明 变量名 赋初值

   //

    //    // int :声明数组的类型，数组类型一旦确定，那么数组的元素类型也确定下来

    //    // array : 数组名，给数组取的名字

    //    // [5] :确定数组的长度，数字是几，就放几个元素（元素的类型必须和数组的类型一致）

    //    // {} :表示给数组赋值，数组元素之间要使用逗号分隔

    //    int array[5] = {12, 23, 34, 45, 56};

    //    // 数组的内存占用

    //    printf("整形变量占用的字节数是：%lu\n",sizeof(a)); //无符号长整形使用%lu输出

    //    // 使用sizeof()函数求出数组占用的字节数

    //    printf("整形数组变量占用的字节数是：%d\n",sizeof(array)); // 5*4

    //    //我们在定义一个数组时，可以省略数组元素的个数，由编译器自动推断。注意1：“[]”不能省

    //    int array1[] = {12, 23, 34, 45, 56};

    //    //我们在定义一个数组时，可以不给每个元素都赋值，没有赋值的元素，默认为0.

    //    int array2[5] = {12, 23, 34};

    //    //定义一个数组，给定了数组长度，首元素为0，其他元素不赋值，默认也是0.这样五个元素均为0；

    //    int array3[5] = {0};// 注意：数组初始化时0尽量不要省去

    //    // 定义一个整形数组，有5个元素，分别是12，21，32，23.

    //    int array4[5] = {12, 21, 32, 23};

   //

    //    //数组元素的访问方式：数组名+下标

    //    //访问arrary中的32这个元素，数组名：array，下标，从0开始计数，32在第3个位置上，所以32的下标就是2.

    //    // []:在定义数组时，方括号中的数字表示声明数组的元素个数；而在访问数组元素时，方括号表示要访问的元素的下标。

    //    int temp = array4[2];

    //    printf("temp = %d, array4[2] = %d", temp, array4[2]);

    //    数组下标越界：数组下标超过了数组长度，访问了不属于数组的内存空间。

    //    注意2：C语言中，没有“数组下标越界保护”机制，所以在写代码时，要注意避免下标越界。

    //    int temp = array4[5];

    //    printf("temp = %d, array4[5] = %d", temp, array4[5]);//数组下标越界（C中没有越界保护，OC中有越界保护）

    //    // 修改array数组的第2个元素，改为99

    //    array4[1] = 99;

    //    printf("array4[1] = %d", array4[1]);

   //

    //    // 定义一个新数组，array5，将array4的元素，原样赋给array5；

    //    int array5[5] = {0};

    //    // array5 = array 4;这是错的。数组中，不能整体访问数组元素，而要逐一的遍历数组元素！

        array5[0] = array4[0];

        array5[1] = array4[1];

        array5[2] = array4[2];

        array5[3] = array4[3];

        array5[4] = array4[4];

   //

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

    //        array5[i] = array4[i];// 说明数组下标可以是常量，也可以是变量

   //

    //    }

    //    // 遍历数组时，一般使用for循环

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

    //        printf("arrary5[%d] = %d\n", i, array5[i]);

    //    }

    // 1、定义一个具有20个元素的整型数组,每个元素的取值范围是【30，70】,求数组元素的和。

    //    // 直观写法，便于理解

    //    // 1、定义一个整形数组，长度20，初始化

    //    int array[20] = {0};

   //

    //    // 2、开启一个for循环，使用循环给数组元素赋值

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

    //        //2.1生成满足范围的20个随机数

    //        int temp = arc4random() % (70 - 40 + 1) + 30;

    //        //2.2 将生成的随机数赋给对应的元素

    //        array[i] = temp;

    //        printf("array[%d] = %d\n", i, array[i]);

    //    }

   //

    //    // 3、求数组元素的和

    //    // 3.1 定义一个保存和的变量

    //    int sum = 0;

    //    // 3.2使用for循环换便利数组元素，同时将元素累加起来

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

    //        // 3.3累加

    //        sum = sum + array[i];

    //    }

   //

    //    printf("\n20个数组元素的和sum = %d",sum);

    // 精简方法

    //    // 1、定义一个整形数组，长度20，初始化

    //    int array[20] = {0};

   //

        //经典面试题：(数组元素个数的计算)

        printf("sizeof(arr) / sizeof(int)= %ld\n", sizeof(arr) / sizeof(int));

   //

    //    // 2、求和变量

    //    int sum = 0;

    //    printf("20个随机数为：\n");

    //    // 3、开启一个for循环，使用循环给数组元素赋值

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

    //        //3.1生成满足范围的20个随机数

    //        int temp = arc4random() % (70 - 40 + 1) + 30;

    //        //3.2 将生成的随机数赋给对应的元素

    //        array[i] = temp;

    //        sum = sum + array[i];

    //        printf("array[%d] = %d\n", i, array[i]);

    //    }

    //    printf("\n20个数组元素的和sum = %d",sum);

    // 2、复制一个数组,即两个数组容量一样,把其中一个数组中的元素复制到另外一个数组中。

    //    int arr1[5] = {12, 23, 34, 45, 56};

    //    int arr2[5] = {0};

   //

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

    //        arr2[i] = arr1[i];

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

   //

    //    }

    // 3、生成2个数组,每个数组都有10个元素,元素取值范围20-40之间,数组对应元素相加,放到另外一个数组中。

    //    // 1.定义三个数组，长度为10

    //    int array1[10] = {0};

    //    int array2[10] = {0};

    //    int array3[10] = {0};

    //    // 2.使用一个for循环，给第一，第二个数组分别赋值；再将前两个数组对应的元素，交给第三个数组

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

    //        // 2.1给第一个、第二个数组赋值

    //        array1[i] = arc4random() % (20 + 1) + 20;

    //        array2[i] = arc4random() % (20 + 1) + 20;

   //

    //        // 2.2将前两个数组对应的元素相加，赋给第三个数组对应的元素

    //        array3[i] = array1[i] + array2[i];

    //        printf("array1[%d] = %d, array2[%d] = %d, array3[%d] = %d\n", i, array1[i],i, array2[i],i, array3[i]);

   //

    //    }

#pragma mark 冒泡排序

    //    冒泡排序规律：公式1 趟数=元素个数-1；公式2每趟比较的次数=元素个数-当前的趟数

    //    两层for循环，外层循环比较趟数、内层控制比较次数

    // 趟数

   int array[5] = {23,45, 43, 56, 13};

    //外层循环，控制排序趟数，趟数 = 数组元素个数 - 1

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

        //内层循环，控制比较次数,每趟比较的次数=元素个数-当前的趟数(i + 1)

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

           // 判断，并且交换

            if (array[j] > array[j+1]) {  // 因为每趟比较，都要从下标为零开始，j在每次从外层循环进入内层时，下标都要加一，j在每次内层循环时，也会加一，所以，在这里使用j做下标是没有问题的。

               // 满足交换条件，开始交换位置

               // 定义一个临时变量

               int temp = array[j];

                array[j] = array[j+1];

                array[j+1] = temp;

            }

        }

    }

    printf("冒泡排序后：");

    //  使用for循环遍历打印数组

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

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

    }

    //    int arr[10] = {0};

   //

   //

    //    printf("10个随机数是：");

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

    //        int num = arc4random() % (40 - 20 + 1) + 20;

    //        arr[i] = num;

    //        printf("%d ", arr[i]);

    //    }

   //

    //    int temp;

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

   //

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

   //

    //            if (arr[j] > arr[j+1]) {

    //                temp = arr[j];

    //                arr[j] = arr[j+1];

    //                arr[j+1] = temp;

   //

    //            }

    //        }

    //    }

   //

    //    printf("\n排序后的10个数为：\n");

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

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

    //    }

#pragma mark 字符数组

    //保存字符的数组，就是字符数组

    //    //定义一个字符数组第一种方式：声明类型、数组名、数组长度、赋初值

    //    char char_Array[5] = {'h', 'e', 'l', 'l', 'o'};

    //    printf("%lu\n", sizeof(char_Array));  //每个字符占一个字节，数组长度是5，所以数组占用5*1个字节的内存。

    //    char char_Array1[] = {'w', 'o', 'r', 'l', 'd'};

    //    printf("%lu\n", sizeof(char_Array1));

    //    //定义字符数组的第二种方式：这种形式的赋值，默认在字符末尾插入了一个'\0','\0'是字符串结束的标志，我们在用%s作为字符数组/字符串的输出占位符时，程序会从数组的零号元素开始打印，一直打印到遇到'\0'为止

   char string[] = "hello";

    printf("%lu\n",sizeof(string));

    printf("%s\n", string);// 打印字符串使用的占位符是%s，在遇到'\0'后，会自动停止输出。

#pragma mark 字符串和字符数组的区别

#pragma mark 字符串操作函数

    // strlen():返回字符串的有效字符个数（不包括\0）

    printf("string字符串的长度是%lu\n",strlen(string));

    // strcpy():字符串拷贝函数:把第2个参数的值拷贝给第一个参数

   char string1[10];

    strcpy(string1, string);

    printf("string1 = %s\n", string1);

    // strcat():字符串拼接

   char string3[20] ="hello";

   char string4[] = "world";

    strcat(string3, string4);  // 把string4的值，拼接到string3后边，string3必须有充足的空间盛放string4

    printf("string3 = %s\n", string3);

    // strcmp():字符串比较

    int b = strcmp(string3, string4);//第一个参数大于第二个参数，返回一个正整数；第一个参数小于第二个参数，返回一个负数；两个参数相等，返回0.

    //helloworld

    //world

    printf("b = %d\n",b);

   return 0;

}