嵌入式学习第七天

C语言流程控制（4）

1.冒泡法排序；

#include <stdio.h>

int main(void)
{
	int a[5] = {32, 14, 73, 61, 43};
	int len = sizeof(a) / sizeof(a[0]);
	int i = 0;
	int j = 0;
	int tmp = 0;

	for (j = 0; j < len-1; j++)
	{
		for (i = 0; i < len-1-j; i++)
		{
			if (a[i] > a[i+1])
			{
				tmp = a[i];
				a[i] = a[i+1];
				a[i+1] = tmp;
			}
		}
	}

	for (i = 0; i < len; i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");

	return 0;
}

2.选择法排序；

#include <stdio.h>

int main(void)
{
	int a[5] = {12, 34, 73, 45, 33};
	int j = 0;
	int i = 0;
	int tmp = 0;
	int min = 0;
	int len = sizeof(a) / sizeof(a[0]);

	for (j = 0; j < len-1; j++)
	{
		min = j;
		for (i = j + 1; i < len; i++)
		{
			if (a[i] < a[min])
			{
				min = i;
			}
		}
		
		if (j != min)
		{
			tmp = a[j];
			a[j] = a[min];
			a[min] = tmp;
		}
	}
	
	for (j = 0; j < len; j++)
	{
		printf("%d ", a[j]);
	}
	printf("\n");

	return 0;
}

3.二维数组:

（1）二维整形数组:
        1.定义: 数组类型 数组名[行数][列数];
           行数和列数：整形常量或整形常量表达式,不能为变量或变量表达式
            int a[2][3];
            1    2    3
            4    5    6

（2）元素访问:
            数组名[行下标][列下表]
            a[0][0]
            a[0][1]
            a[0][2]
            a[1][0]
            a[1][1]
            a[1][2]
            下标:可以是常量或者变量或者表达式

（3）元素初始化:
            1.全部初始化:
                int a[2][3] = {1, 2, 3, 4, 5, 6};
                int a[2][3] = {{1, 2, 3}, {4, 5, 6}};
            2.局部初始化:
                int a[2][3] = {1, 2, 3, 4};
                int a[2][3] = {{1, 2}, {3}};
                int a[2][3] = {0};
                int a[2][3] = {{0}};
            3.默认初始化:
                行能省略，列不能省略
                int a[][3] = {1, 2, 3, 4, 5, 6};
                int a[][3] = {{1, 2, 3}, {4, 5, 6}};
                int a[][3] = {1, 2, 3, 4};
                int a[][3] = {1, 2, 3};
                int a[][3] = {{1, 2}, {3}};
                int a[][3] = {0};

（4）二维数组的存储:
            数组所占空间大小 = 数据类型所占空间大小 * 行数 * 列数
            1.连续性
                数组存放空间连续
            2.有序性
                逐行从左向右存储
            二维数组的元素个数：sizeof(a) / sizeof(a[0][0]);
        结论:二维数组可以看成是由一维数组构成的一维数组

多维数组: N维数组可以理解成是由N-1维数组构成的一维数组

4.字符型数组:

（1）使用场景:
        C语言没有字符串类型,也无法定义字符串变量,只能通过字符型数组,每个元素存放一个字符，最终存放字符串

（2）字符型数组的定义：
         数据类型 数组名[元素个数];
         "hello world"    char str[12];

 注意:
            1.元素个数必须为常量或常量表达式,不能为变量或变量表达式 
            2.元素个数必须能够容纳下所有字符(包括\0)

字符型数组和字符串区别:
            1.字符型数组可以存放字符,不一定包含\0
            2.字符串最末尾一定要有\0

（3）字符型数组的初始化:
        1.全部初始化:
        char str[6] = {'h', 'e', 'l', 'l', 'o', '\0'};
        char str[6] = {"hello"};
        char str[6] = "hello";

        2.局部初始化:
        char str[6] = {'h', 'e', 'l', '\0'};            //没有给定初值的元素,值为0值('\0')
        char str[6] = {"hel"};
        char str[6] = "hel";
        char str[6] = {0};                              

        3.默认初始化:
        char str[] = {'h', 'e', 'l', 'l', 'o', '\0'};
        char str[] = {"hello"};
        char str[] = "hello";
        char str[] = {'h', 'e', 'l', 'l', 'o'};

（4）数组的存储:
        字符型数组所占字节 == 元素个数 
        1.连续性
        2.有序性

（5）字符串的输入和输出:
        scanf("%s", str);
        gets(str);

        printf("str = %s\n", str);
        puts(str);

（6）字符串常见的操作函数:
        1.strlen:获得字符串的长度(字符串开头到离开头最近的\0之 间的字符个数，不包含\0字符)

           strlen（str）；
        注意:
                1.strlen获得字符串的长度
                2.sizeof获得字符串或数组在内存中所占字节数

作业:

1.从终端接收一个字符串,不使用strlen,打印出字符串的长度 

2.从终端接收一个字符串,根据字符串每个元素的ASCII码完成对字符串的排序