c语言 数组（一维、字符）

//  main.m

//  1-16课堂笔记

//讲师：小辉

//笔者：王学文

//  Created by lanouhn on 15/1/16.

//  Copyright (c) 2015年 lanouhn. All rights reserved.

//数组（一维、字符）

#import <Foundation/Foundation.h>

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

    //数组：用于存储 相同数据类型 的有序队列

    //数组定义的格式

    //数据类型 变量名[元素个数] = {数值1，数值2，数值3，…}

    //整型数组

//    int array[5] = {1, 2, 3, 4, 5};

//    

//    //浮点型数组

//    float array1[5] = {1.0, 2.0, 3.0, 4.0, 5.0};

//    

//    //数组越界，很危险

//    int a[2] = {1, 2, 3};

//    

//    //数组定义的方式

//    int b[4] = {1, 2, 3};//1, 2, 3, 0

//    

//    int c[4] = {1};//1, 0, 0, 0

//    

//    int d[4] = {0};//全为0

//    

//    //数组元素个数省略，但是必须赋初值，否则没办法决定元素的个数

//    int e[] = {1, 2, 3, 4};//有四个元素

//    

//    int g[] = {0};//有一个元素

//    

//    int h[] = {};//0个元素，无意义

//    

    //sizeof(); 计算 数据类型 或者 变量 所占的字节数

   /*

    //计算数据类型所占字节数

    unsigned long length = sizeof(short);

    printf("short:%lu\n", length);

    // 计算变量所占的字节数

    int i = 0;

    printf("int:%lu\n", sizeof(i));

    printf("short:%lu\n", sizeof(short));//取值范围：-2^15到2^15-1

    printf("int:%lu\n", sizeof(int));//取值范围：-2^31到2^31-1

    printf("char:%lu\n", sizeof(char)); //取值范围：-2^7到2^7-1

    printf("long:%lu\n", sizeof(long));//取值范围：-2^63到2^63-1

    printf("float:%lu\n", sizeof(float));//取值范围：-2^31到2^31-1

    printf("double:%lu\n", sizeof(double));//取值范围：-2^63到2^63-1

    //数组所占的字节数 = 数据类型所占的字节数 + 数组元素个数

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

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

    //数组的使用

    int k = 2, j = 3;

    //k + j ;

    //数组不能够直接参与运算，数组中得元素可以参与运算

    int arr1[2] = {1, 2};

    int arr2[2] = {4, 5};

    //arr1 + arr2

    //获取数组中的元素

    //格式：数组名[元素下标]

    //(*)元素下标从零开始

    //原酸下标的范围{0, 数组元素个数-1}

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

    printf("%d\n", a[0]);//数组的第一个元素

    //数组越界

    //a[5]

    //定义数组 和 取数组元素 的区别

    //1. 定义数组必须有数据类型

    //2.定义数组时，元素个数可以省略；取数组元素时，元素下标不能够省略

    //遍历数组中每个元素，并打印

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

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

    }

    //对数组中得摸个元素赋值

    a[2] = 6;

    //定义一个具有20个元素 的 整型数组，每个元素的 取值范围是30-70之间

    int a[20] = {0};

    int sum = 0;

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

        int temp = arc4random() % 41 + 30;

        //int n = 0;

        //if (n < 20) {

          //  a[n] = temp;

            //n++;

        //}

        a[i] = temp;

        sum =sum + temp;

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

    }

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

    //复制一个数组，即两个数组容量一样，把其中一个数组的元素复制到另一个数组中

    int b[20] = {0};

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

        b[i] = a[i];

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

    }

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

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

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

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

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

//        a[i] = arc4random() % 21 + 20;

//        b[i] = arc4random() % 21 + 20;

//        c[i] = a[i] + b[i];

//        printf("a[%d] = %d b[%d] = %d c[%d] = %d\n", i, a[i], i, b[i], i, c[i]);

//    }

    //冒泡排序

    int a[5] = {10, 2, 6, 8, 4};

    //外层循环控制比较的趟数（数组元素个数-1）

    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;

            }

        }

    }

    //打印数组元素

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

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

    }

    //随机产生10个[20,40]的数，并对10个数从小到大排序

    int a[10] = {0};

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

        int temp = arc4random() % 21 + 20;

        a[i] = temp;

        printf("a[%d] = %d ", i, a[i]);

        }

    printf("\n");

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

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

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

                int temp = a[j];

                a[j] = a[j + 1];

                a[j + 1] = temp;

            }

        }

    }

    printf("排序后\n");

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

        printf("a[%d] = %d ", i, a[i]);

    }

    printf("\n");

    //字符数组

    //写法一

    char string[6] = {‘i‘, ‘p‘ ,‘h‘ ,‘o‘ ,‘n‘ ,‘e‘};

    //写法二

    char string1[6] = "iphone";

    //住：两种写法是完全等价的

    //定义时没有赋值

    int a[5] = {1}; //整型默认是 0

    char s[5] = {‘i‘}; //字符型默认是‘\0’

    //字符数组的使用

    string[2] = ‘s‘;

    //遍历数组的每个元素，并打印

    char string[8] = {‘i‘, ‘p‘ ,‘h‘ ,‘o‘ ,‘n‘ ,‘e‘, ‘5‘, ‘s‘};

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

        printf("string[%d] = %c\n", i, string[i]);

    }

    //%s打印字符数组(一般在数组末尾加上‘\0’)

    //string有6个元素，需要手动在数组最后加‘\0’

    //string1有7个元素，系统会自动在数组最后加上‘\0’

    //如果用%s打印string,由于没有‘\0‘,会造成数组越界

    char string[] = {‘i‘, ‘p‘ ,‘h‘ ,‘o‘ ,‘n‘ ,‘e‘};

    char string1[] = "1phone";

    char string3[6] = {‘i‘, ‘p‘ ,‘h‘ ,‘o‘ ,‘n‘ ,‘e‘};//有6个元素

    char string4[6] = "4phone";//有6个元素

    printf("string: %s\nstring1: %s\nstring3: %s\nstring4: %s\n", string, string1, string3, string4);

    //%s遇到‘\0’就停止

    string[2] = ‘\0‘;

    printf("string: %s\n", string);

    //strlen(const char *)

    //计算字符的长度函数

    //遇到‘\0‘就结束，并且‘\0‘不计入长度

    char string[10] = "I Love U";

    string[2] = ‘\0‘;

    unsigned long length = strlen(string);

    printf("length = %lu\n", length);

    //strcpy(字符串1, 字符串2)

    //字符串的拷贝

    //把字符串2中每一个元素依次拷贝到字符串1中，直到字符串2遇到‘\0‘结束

    //（*）字符串1要足够大，以防止越界

    char str1[10] = "I Love";

    char str2[10] = "you";

    strcpy(str1, str2);

    printf("str1:%s\n", str1);

    printf("str2:%s\n", str2);

    */

    //strcat(字符串1, 字符串2)

    //字符串拼接函数

    //从字符串1的第一个‘\0‘开始把字符串2的每个元素拼接到字符串1，直到字符串2遇到‘\0‘结束

    //注：字符串1的空间必须足够大，以防止越界

//    char str1[10] = "I Love";

//    str1[2] = ‘\0‘;

//    char str2[10] = "you";

//    strcat(str1, str2);

//    printf("str1:%s\n", str1);

//    printf("str2:%s\n", str2);

//    

    //strcmp(字符串1, 字符串2)

    //字符串比较函数

    //用字符串1中得每个元素 和 对应位置字符串2的元素 的ASCII值相减，如果为0，就继续比较；如果不为0，就停止比较，返回差值；当对应元素都是‘\0‘时，比较停止，返回结果0

//    char str1[10] = "ABC";

//    char str2[10] = "ABC";

//    int result = strcmp(str1, str2);

//    printf("result = %d\n", result);

//    

    return 0;

}