C语言从入门到精通保姆级教程（八）

CDSY,CDSY.XYZ

计数排序（Counting Sort）

• 计数排序是一个非基于比较的排序算法，该算法于1954年由 Harold H. Seward 提出。它的优势在于在对一定范围内的整数排序时，快于任何比较排序算法。
• 排序思路:

• 1.找出待排序数组最大值
• 2.定义一个索引最大值为待排序数组最大值的数组
• 3.遍历待排序数组, 将待排序数组遍历到的值作新数组索引
• 4.在新数组对应索引存储值原有基础上+1
  

• 简单代码实现:

int main()
{
    // 待排序数组
    int nums[5] = {3, 1, 2, 0, 3};
    // 用于排序数组
    int newNums[4] = {0};
    // 计算待排序数组长度
    int len = sizeof(nums) / sizeof(nums[0]);
    // 遍历待排序数组
    for(int i = 0; i < len; i++){
        // 取出待排序数组当前值
        int index = nums[i];
        // 将待排序数组当前值作为排序数组索引
        // 将用于排序数组对应索引原有值+1
        newNums[index] = newNums[index] +1;
    }
    
    // 计算待排序数组长度
    int len2 = sizeof(newNums) / sizeof(newNums[0]);
    // 输出排序数组索引, 就是排序之后结果
    for(int i = 0; i < len2; i++){
        for(int j = 0; j < newNums[i]; j++){
            printf("%i\n", i);
        }
    }
    /*
    // 计算待排序数组长度
    int len2 = sizeof(newNums) / sizeof(newNums[0]);
    // 还原排序结果到待排序数组
    for(int i = 0; i < len2; i++){
        int index = 0;
        for(int i = 0; i < len; i++){
            for(int j = 0; j < newNums[i]; j++){
                nums[index++] = i;
            }
        }
    }
    */
    return 0;
}

---

选择排序

选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小元素,然后放到排序序列末尾。以此类推,直到所有元素均排序完毕。

• 排序思路:
• 假设按照升序排序
• 1.用第0个元素和后面所有元素依次比较
• 2.判断第0个元素是否大于当前被比较元素, 一旦小于就交换位置
• 3.第0个元素和后续所有元素比较完成后, 第0个元素就是最小值
• 4.排除第0个元素, 用第1个元素重复1~3操作, 比较完成后第1个元素就是倒数第二小的值
• 以此类推, 直到当前元素没有可比较的元素, 排序完成
• 代码实现:

// 选择排序
void selectSort(int numbers[], int length) {        // 外循环为什么要-1?
    // 最后一位不用比较, 也没有下一位和它比较, 否则会出现错误访问
    for (int i = 0; i < length; i++) {
        for (int j = i; j < length - 1; j++) {            // 1.用当前元素和后续所有元素比较
            if (numbers[i] < numbers[j + 1]) {                //  2.一旦发现小于就交换位置
                swapEle(numbers, i, j + 1);
            }
        }
    }
}

// 交换两个元素的值, i/j需要交换的索引
void swapEle(int array[], int i, int j) {
    int temp = array[i];
    array[i] = array[j];
    array[j] = temp;
}

---

冒泡排序

• 冒泡排序(Bubble Sort)是一种简单的排序算法。它重复 地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
  
• 排序思路:

• 假设按照升序排序
• 1.从第0个元素开始, 每次都用相邻两个元素进行比较
• 2.一旦发现后面一个元素小于前面一个元素就交换位置
• 3.经过一轮比较之后最后一个元素就是最大值
• 4.排除最后一个元素, 以此类推, 每次比较完成之后最大值都会出现再被比较所有元素的最后
• 直到当前元素没有可比较的元素, 排序完成

• 代码实现:

// 冒泡排序
void bubbleSort(int numbers[], int length) {
    for (int i = 0; i < length; i++) {
        // -1防止`角标越界`: 访问到了不属于自己的索引
        for (int j = 0; j < length - i - 1; j++) {
           //  1.用当前元素和相邻元素比较
            if (numbers[j] < numbers[j + 1]) {
                //  2.一旦发现小于就交换位置
                swapEle(numbers, j, j + 1);
            }
        }
    }
}
// 交换两个元素的值, i/j需要交换的索引
void swapEle(int array[], int i, int j) {
    int temp = array[i];
    array[i] = array[j];
    array[j] = temp;
}

---

插入排序

• 插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
  
• 排序思路:

• 假设按照升序排序
• 1.从索引为1的元素开始向前比较, 一旦前面一个元素大于自己就让前面的元素先后移动
• 2.直到没有可比较元素或者前面的元素小于自己的时候, 就将自己插入到当前空出来的位置

• 代码实现:

int main()
{
    // 待排序数组
    int nums[5] = {3, 1, 2, 0, 3};
    // 0.计算待排序数组长度
    int len = sizeof(nums) / sizeof(nums[0]);

    //  1.从第一个元素开始依次取出所有用于比较元素
    for (int i = 1; i < len; i++)
    {
        // 2.取出用于比较元素
        int temp = nums[i];
        int j = i;
        while(j > 0){
            // 3.判断元素是否小于前一个元素
            if(temp < nums[j - 1]){
                // 4.让前一个元素向后移动一位
                nums[j] = nums[j - 1];
            }else{
                break;
            }
            j--;
        }
        // 5.将元素插入到空出来的位置
        nums[j] = temp;
    }
}

int main()
{
    // 待排序数组
    int nums[5] = {3, 1, 2, 0, 3};
    // 0.计算待排序数组长度
    int len = sizeof(nums) / sizeof(nums[0]);

    //  1.从第一个元素开始依次取出所有用于比较元素
    for (int i = 1; i < len; i++)
    {
        // 2.遍历取出前面元素进行比较
        for(int j = i; j > 0; j--)
        {
            // 3.如果前面一个元素大于当前元素,就交换位置
            if(nums[j-1] > nums[j]){
                int temp = nums[j];
                nums[j] = nums[j - 1];
                nums[j - 1] = temp;
            }else{
                break;
            }
        }
    }
}

---

希尔排序

• 1959年Shell发明，第一个突破O(n2)的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
  
• 排序思路:

• 1.希尔排序可以理解为插入排序的升级版, 先将待排序数组按照指定步长划分为几个小数组
• 2.利用插入排序对小数组进行排序, 然后将几个排序的小数组重新合并为原始数组
• 3.重复上述操作, 直到步长为1时,再利用插入排序排序即可

• 代码实现:

int main(){    // 待排序数组
    int nums[5] = {3, 1, 2, 0, 3};    // 0.计算待排序数组长度
    int len = sizeof(nums) / sizeof(nums[0]);// 2.计算步长
    int gap = len / 2;
    do{        //  1.从第一个元素开始依次取出所有用于比较元素
        for (int i = gap; i < len; i++)
        {            // 2.遍历取出前面元素进行比较
            int j = i;
            while((j - gap) >= 0)
            {
                printf("%i > %i\n", nums[j - gap], nums[j]);                // 3.如果前面一个元素大于当前元素,就交换位置
                if(nums[j - gap] > nums[j]){
                    int temp = nums[j];
                    nums[j] = nums[j - gap];
                    nums[j - gap] = temp;
                }else{
                    break;
                }
                j--;
            }
        }        // 每个小数组排序完成, 重新计算步长
        gap = gap / 2;
    }
while(gap >= 1);
}

江哥提示: 对于初学者而言, 排序算法一次不易于学习太多, 咋们先来5个玩一玩, 后续继续讲解其它5个 公众号代码情缘欢迎关注

---

折半查找

• 基本思路
• 在有序表中,取中间元素作为比较对象,若给定值与中间元素的要查找的数相等,则查找成功;若给定值小于中间元素的要查找的数,则在中间元素的左半区继续查找;
• 若给定值大于中间元素的要查找的数,则在中间元素的右半区继续查找。不断重复上述查找过 程,直到查找成功,或所查找的区域无数据元素,查找失败

---

• 实现步骤
• 在有序表中,取中间元素作为比较对象,若给定值与中间元素的要查找的数相等,则查找成功;
• 若给定值小于中间元素的要查找的数,则在中间元素的左半区继续查找;
• 若给定值大于中间元素的要查找的数,则在中间元素的右半区继续查找。
• 不断重复上述查找过 程,直到查找成功,或所查找的区域无数据元素,查找失败。
  
• 代码实现

int findKey(int values[], int length, int key) {
    // 定义一个变量记录最小索引
    int min = 0;
    // 定义一个变量记录最大索引
    int max = length - 1;
    // 定义一个变量记录中间索引
    int mid = (min + max) * 0.5;
    
    while (min <= max) {
        // 如果mid对应的值 大于 key, 那么max要变小
        if (values[mid] > key) {
            max = mid - 1;
            // 如果mid对应的值 小于 key, 那么min要变
        }else if (values[mid] < key) {
            min = mid + 1;
        }else {
            return mid;
        }
        // 修改完min/max之后, 重新计算mid的值
        mid = (min + max) * 0.5;
    }
    return -1;
}

---

进制转换(查表法)

• 实现思路:

• 将二进制、八进制、十进制、十六进制所有可能的字符都存入数组
• 利用按位与运算符和右移依次取出当前进制对应位置的值
• 利用取出的值到数组中查询当前位输出的结果
• 将查询的结果存入一个新的数组, 当所有位都查询存储完毕, 新数组中的值就是对应进制的值

• 代码实现

#include <stdio.h>
void toBinary(int num)
{
    total(num, 1, 1);
}
void toOct(int num)
{
    total(num, 7, 3);
}
void toHex(int num)
{
    total(num, 15, 4);
}

void total(int num , int base, int offset)
{
    //    1.定义表用于查询结果
    char cs[] = {
        '0', '1', '2', '3', '4', '5',
        '6', '7', '8', '9', 'a', 'b',
        'c', 'd', 'e', 'f'
    };
    //    2.定义保存结果的数组
    char rs[32];
    //    计算最大的角标位置
    int length = sizeof(rs)/sizeof(char);
    int pos = length;//8

    while (num != 0) {
        int index = num & base;
        rs[--pos] = cs[index];
        num = num >> offset;
    }

    for (int i = pos; i < length; i++) {
        printf("%c", rs[i]);
    }
    printf("\n");
}
int main()
{
    toBinary(9);
    return 0;
}

二维数组

• 所谓二维数组就是一个一维数组的每个元素又被声明为一 维数组,从而构成二维数组. 可以说二维数组是特殊的一维数组。
• 示例:

• int a[2][3] = { {80,75,92}, {61,65,71}};
• 可以看作由一维数组a[0]和一维数组a[1]组成，这两个一维数组都包含了3个int类型的元素
  

二维数组的定义

• 格式:

• 数据类型 数组名[一维数组的个数][一维数组的元素个数]
• 其中"一维数组的个数"表示当前二维数组中包含多少个一维数组
• 其中"一维数组的元素个数"表示当前前二维数组中每个一维数组元素的个数

---

二维数组的初始化

• 二维数的初始化可分为两种:

• 定义的同时初始化
• 先定义后初始化

• 定义的同时初始化

int a[2][3]={ {80,75,92}, {61,65,71}};

• 先定义后初始化

int a[2][3];
a[0][0] = 80;
a[0][1] = 75;
a[0][2] = 92;
a[1][0] = 61;
a[1][1] = 65;
a[1][2] = 71;

• 按行分段赋值

int a[2][3]={ {80,75,92}, {61,65,71}};

• 按行连续赋值

int a[2][3]={ 80,75,92,61,65,71};

• 其它写法

• 完全初始化,可以省略第一维的长度

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

• 部分初始化,可以省略第一维的长度

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

• 注意: 有些人可能想不明白，为什么可以省略行数，但不可以省略列数。也有人可能会问，可不可以只指定行数，但是省略列数？其实这个问题很简单，如果我们这样写：int a[2][] = {1, 2, 3, 4, 5, 6}; // 错误写法 大家都知道，二维数组会先存放第1行的元素，由于不确定列数，也就是不确定第1行要存放多少个元素，所以这里会产生很多种情况，可能1、2是属于第1行的，也可能1、2、3、4是第一行的，甚至1、2、3、4、5、6全部都是属于第1行的

• 指定元素的初始化

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

二维数组的应用场景

二维数组的遍历和存储

二维数组的遍历

• 二维数组a[3][4],可分解为三个一维数组,其数组名分别为:

• 这三个一维数组都有4个元素,例如:一维数组a[0]的 元素为a[0][0],a[0][1],a[0][2],a[0][3]。
• 所以遍历二维数组无非就是先取出二维数组中得一维数组, 然后再从一维数组中取出每个元素的值

• 示例

    char cs[2][3] = {
        {'a', 'b', 'c'},
        {'d', 'e', 'f'}
    };
    printf("%c", cs[0][0]);// 第一个[0]取出一维数组, 第二个[0]取出一维数组中对应的元素

    char cs[2][3] = {
        {'a', 'b', 'c'},
        {'d', 'e', 'f'}
    };
    for (int i = 0; i < 2; i++) { // 外循环取出一维数组
        // i
        for (int j = 0; j < 3; j++) {// 内循环取出一维数组的每个元素
            printf("%c", cs[i][j]);
        }
        printf("\n");
    }

注意: 必须强调的是,a[0],a[1],a[2]不能当作下标变量使用,它们是数组名,不是一个单纯的下标变量

---

二维数组的存储

• 和以为数组一样

• 给数组分配存储空间从内存地址大开始分配
• 给数组元素分配空间, 从所占用内存地址小的开始分配
• 往每个元素中存储数据从高地址开始存储

#include <stdio.h>
int main()
{
    char cs[2][3] = {
        {'a', 'b', 'c'},
        {'d', 'e', 'f'}
    };
    // cs == &cs == &cs[0] == &cs[0][0]
    printf("cs = %p\n", cs);                // 0060FEAA
    printf("&cs = %p\n", &cs);              // 0060FEAA
    printf("&cs[0] = %p\n", &cs[0]);        // 0060FEAA
    printf("&cs[0][0] = %p\n", &cs[0][0]);  // 0060FEAA
    return 0;
}

二维数组与函数

• 值传递

#include <stdio.h>

// 和一位数组一样, 只看形参是基本类型还是数组类型
// 如果是基本类型在函数中修改形参不会影响实参
void change(char ch){
    ch = 'n';
}
int main()
{
    char cs[2][3] = {
        {'a', 'b', 'c'},
        {'d', 'e', 'f'}
    };
    printf("cs[0][0] = %c\n", cs[0][0]); // a
    change(cs[0][0]);
    printf("cs[0][0] = %c\n", cs[0][0]); // a
    return 0;
}

• 地址传递

#include <stdio.h>

// 和一位数组一样, 只看形参是基本类型还是数组类型
// 如果是数组类型在函数中修改形参会影响实参
void change(char ch[]){
    ch[0] = 'n';
}
int main()
{
    char cs[2][3] = {
        {'a', 'b', 'c'},
        {'d', 'e', 'f'}
    };
    printf("cs[0][0] = %c\n", cs[0][0]); // a
    change(cs[0]);
    printf("cs[0][0] = %c\n", cs[0][0]); // n
    return 0;
}

#include <stdio.h>

// 和一位数组一样, 只看形参是基本类型还是数组类型
// 如果是数组类型在函数中修改形参会影响实参
void change(char ch[][3]){
    ch[0][0] = 'n';
}
int main()
{
    char cs[2][3] = {
        {'a', 'b', 'c'},
        {'d', 'e', 'f'}
    };
    printf("cs[0][0] = %c\n", cs[0][0]); // a
    change(cs);
    printf("cs[0][0] = %c\n", cs[0][0]); // n
    return 0;
}

• 形参错误写法

void test(char cs[2][]) // 错误写法
{
    printf("我被执行了\n");
}

void test(char cs[2][3]) // 正确写法
{
    printf("我被执行了\n");
}

void test(char cs[][3]) // 正确写法
{
    printf("我被执行了\n");
}

• 二维数组作为函数参数，在被调函数中不能获得其有多少行，需要通过参数传入

void test(char cs[2][3])
{
    int row = sizeof(cs); // 输出4或8
    printf("row = %zu\n", row);
}

• 二维数组作为函数参数，在被调函数中可以计算出二维数组有多少列

void test(char cs[2][3])
{
    size_t col = sizeof(cs[0]); // 输出3
    printf("col = %zd\n", col);
}

---

作业

• 玩家通过键盘录入 w,s,a,d控制小人向不同方向移动,其中w代表向上移动,s代表向 下移动,a代表向左移动,d 代表向右移动,当小人移动到出口位置,玩家胜利
• 思路:
• 1.定义二维数组存放地图

     ######
     #O #
     # ## #
     #  # #
     ##   #
     ######

• 2.规定地图的方向
  
• 3.编写程序控制方向

• 当输入w或者W, 小人向上移动. x-1
• 当输入s 或者S, 小人向下. x+1
• 当输入a或者A, 小人向左. y-1
• 当输入d或者D, 小人向右. y+1

• 4.移动小人

• 用变量记录小人当前的位置
  • 1)如果小人将要移动的位置是墙,则无法移动
  • 2)如果小人将要移动的位置是路,则可以移动

• 5.判断是否走出迷宫

---

字符串的基本概念

• 字符串是位于双引号中的字符序列

• 在内存中以“\0”结束,所占字节比实际多一个
  

字符串的初始化

• 在C语言中没有专门的字符串变量,通常用一个字符数组来存放一个字符串。
• 当把一个字符串存入一个数组时,会把结束符‘\0’存入数组,并以此作为该字符串是否结束的标志。
• 有了‘\0’标志后,就不必再用字符数组 的长度来判断字符串的长度了
• 初始化

    char name[9] = "lnj"; //在内存中以“\0”结束， \0ASCII码值是0
    char name1[9] = {'l','n','j','\0'};
    char name2[9] = {'l','n','j',0};
    // 当数组元素个数大于存储字符内容时, 未被初始化的部分默认值是0, 所以下面也可以看做是一个字符串
    char name3[9] = {'l','n','j'};

• 错误的初始化方式

    //省略元素个数时, 不能省略末尾的\n
    // 不正确地写法，结尾没有\0 ，只是普通的字符数组
    char name4[] = {'l','n','j'};

     //   "中间不能包含\0", 因为\0是字符串的结束标志
     //    \0的作用：字符串结束的标志
    char name[] = "c\0ool";
     printf("name = %s\n",name);
输出结果: c

---

字符串输出

• 如果字符数组中存储的是一个字符串, 那么字符数组的输入输出将变得简单方便。

• 不必使用循环语句逐个地输入输出每个字符
• 可以使用printf函数和scanf函数一次性输出输入一个字符数组中的字符串

• 使用的格式字符串为“%s”,表示输入、输出的是一个字符串 字符串的输出

---

• 输出

• %s的本质就是根据传入的name的地址逐个去取数组中的元素然后输出，直到遇到\0位置

char chs[] = "lnj";
printf("%s\n", chs);

• 注意点:

• \0引发的脏读问题

char name[] = {'c', 'o', 'o', 'l' , '\0'};
char name2[] = {'l', 'n', 'j'};
printf("name2 = %s\n", name2); // 输出结果: lnjcool

---

• 输入

char ch[10];
scanf("%s",ch);

• 注意点:

• 对一个字符串数组, 如果不做初始化赋值, 必须指定数组长度
• ch最多存放由9个字符构成的字符串，其中最后一个字符的位置要留给字符串的结尾标示‘\0’
• 当用scanf函数输入字符串时,字符串中不能含有空格,否则将以空格作为串的结束符

---

字符串常用方法

• C语言中供了丰富的字符串处理函数,大致可分为字符串的输入、输出、合并、修改、比较、转 换、复制、搜索几类。

• 使用这些函数可大大减轻编程的负担。
• 使用输入输出的字符串函数,在使用前应包含头文件"stdio.h"
• 使用其它字符串函数则应包含头文件"string.h"

---

• 字符串输出函数:puts
• 格式: puts(字符数组名)
• 功能:把字符数组中的字符串输出到显示器。即在屏幕上显示该字符串。
• 优点:

• 自动换行
• 可以是数组的任意元素地址

• 缺点

• 不能自定义输出格式, 例如 puts("hello %i");

char ch[] = "lnj";
puts(ch); //输出结果: lnj

• puts函数完全可以由printf函数取代。当需要按一定格式输出时,通常使用printf函数

---

• 字符串输入函数:gets
• 格式: gets (字符数组名)
• 功能:从标准输入设备键盘上输入一个字符串。

char ch[30];
gets(ch); // 输入:lnj
puts(ch); // 输出:lnj

• 可以看出当输入的字符串中含有空格时,输出仍为全部字符串。说明gets函数并不以空格作为字符串输入结束的标志,而只以回车作为输入结束。这是与scanf函数不同的。
• 注意gets很容易导致数组下标越界，是一个不安全的字符串操作函数

---

• 字符串长度
• 利用sizeof字符串长度

• 因为字符串在内存中是逐个字符存储的,一个字符占用一个字节,所以字符串的结束符长度也是占用的内存单元的字节数。

    char name[] = "it666";
    int size = sizeof(name);// 包含\0
    printf("size = %d\n", size); //输出结果:6

---

• 利用系统函数

• 格式: strlen(字符数组名)
• 功能:测字符串的实际长度(不含字符串结束标志‘\0’)并作为函数返回值。

    char name[] = "it666";
    size_t len = strlen(name2);
    printf("len = %lu\n", len); //输出结果:5

---

• 以“\0”为字符串结束条件进行统计

/**
 *  自定义方法计算字符串的长度
 *  @param name 需要计算的字符串
 *  @return 不包含\0的长度
 */
int myStrlen2(char str[])
{
    //    1.定义变量保存字符串的长度
    int length = 0;
    while (str[length] != '\0')
    {
        length++;//1 2 3 4
    }
    return length;
}
/**
 *  自定义方法计算字符串的长度
 *  @param name  需要计算的字符串
 *  @param count 字符串的总长度
 *  @return 不包含\0的长度
 */
int myStrlen(char str[], int count)
{
//    1.定义变量保存字符串的长度
    int length = 0;
//    2.通过遍历取出字符串中的所有字符逐个比较
    for (int i = 0; i < count; i++) {
//        3.判断是否是字符串结尾
        if (str[i] == '\0') {
            return length;
        }
        length++;
    }
    return length;
}

---

• 字符串连接函数:strcat
• 格式: strcat(字符数组名1,字符数组名2)
• 功能:把字符数组2中的字符串连接到字符数组1 中字符串的后面,并删去字符串1后的串标志 “\0”。本函数返回值是字符数组1的首地址。

char oldStr[100] = "welcome to";
char newStr[20] = " lnj";
strcat(oldStr, newStr);
puts(oldStr); //输出: welcome to lnj"

• 本程序把初始化赋值的字符数组与动态赋值的字符串连接起来。要注意的是,字符数组1应定义足 够的长度,否则不能全部装入被连接的字符串。

---

• 字符串拷贝函数:strcpy- 格式: strcpy(字符数组名1,字符数组名2)- 功能:把字符数组2中的字符串拷贝到字符数组1中。串结束标志“\0”也一同拷贝。字符数名2, 也可以是一个字符串常量。这时相当于把一个字符串赋予一个字符数组。

char oldStr[100] = "welcome to";
char newStr[50] = " lnj";
strcpy(oldStr, newStr);
puts(oldStr); // 输出结果:  lnj // 原有数据会被覆盖

• 本函数要求字符数组1应有足够的长度,否则不能全部装入所拷贝的字符串。

---

• 字符串比较函数:strcmp
• 格式: strcmp(字符数组名1,字符数组名2)
• 功能:按照ASCII码顺序比较两个数组中的字符串,并由函数返回值返回比较结果。

• 字符串1=字符串2,返回值=0;
• 字符串1>字符串2,返回值>0;
• 字符串1<字符串2,返回值<0。

    char oldStr[100] = "0";
    char newStr[50] = "1";
    printf("%d", strcmp(oldStr, newStr)); //输出结果:-1
    char oldStr[100] = "1";
    char newStr[50] = "1";
    printf("%d", strcmp(oldStr, newStr));  //输出结果:0
    char oldStr[100] = "1";
    char newStr[50] = "0";
    printf("%d", strcmp(oldStr, newStr)); //输出结果:1

---

练习

• 编写一个函数char_contains(char str[],char key)， 如果字符串str中包含字符key则返回数值1，否则返回数值0

---

字符串数组基本概念

• 字符串数组其实就是定义一个数组保存所有的字符串

• 1.一维字符数组中存放一个字符串，比如一个名字char name[20] = “nj”
• 2.如果要存储多个字符串，比如一个班所有学生的名字，则需要二维字符数组，char names[15][20]可以存放15个学生的姓名(假设姓名不超过20字符)
• 如果要存储两个班的学生姓名，那么可以用三维字符数组char names[2][15][20] ##字符串数组的初始化

char names[2][10] = { {'l','n','j','\0'}, {'l','y','h','\0'} };
char names2[2][10] = { {"lnj"}, {"lyh"} };
char names3[2][10] = { "lnj", "lyh" };

指针基本概念

• 什么是地址

• 生活中的地址:
  
• 内存地址:
  

• 地址与内存单元中的数据是两个完全不同的概念

• 地址如同房间编号, 根据这个编号我们可以找到对应的房间
• 内存单元如同房间, 房间是专门用于存储数据的

• 变量地址:

• 系统分配给"变量"的"内存单元"的起始地址

int num = 6; // 占用4个字节
//那么变量num的地址为: 0ff06

char c = 'a'; // 占用1个字节
//那么变量c的地址为:0ff05

---

什么是指针

• 在计算机中所有数据都存储在内存单元中,而每个内存单元都有一个对应的地址, 只要通过这个地址就能找到对应单元中存储的数据.
• 由于通过地址能找到所需的变量单元，所以我们说该地址指向了该变量单元。将地址形象化的称为“指针”
• 内存单元的指针(地址)和内存单元的内容是两个不同的概念。
  

什么是指针变量

• 在C语言中,允许用一个变量来存放其它变量的地址, 这种专门用于存储其它变量地址的变量, 我们称之为指针变量
  
• 示例:

    int age;// 定义一个普通变量
    num = 10;
    int *pnAge; // 定义一个指针变量
    pnAge = &age;

定义指针变量的格式

• 指针变量的定义包括两个内容:

• 指针类型说明,即定义变量为一个指针变量;
• 指针变量名;
  

• 示例:

char ch = 'a';
char *p; // 一个用于指向字符型变量的指针
p = &ch;  
int num = 666;
int *q; // 一个用于指向整型变量的指针
q = #  

• 其中,*表示这是一个指针变量
• 变量名即为定义的指针变量名
• 类型说明符表示本指针变量所指向的变量的数据类型

---

指针变量的初始化方法

• 指针变量初始化的方法有两种:定义的同时进行初始化和先定义后初始化

• 定义的同时进行初始化

int a = 5;
int *p = &a;

• 先定义后初始化

int a = 5;
int *p;
p=&a;

• 把指针初始化为NULL

int *p=NULL;
int *q=0;

• 不合法的初始化:

• 指针变量只能存储地址, 不能存储其它类型

int *p;
p =  250; // 错误写法

• 给指针变量赋值时,指针变量前不能再加“*”

int *p;
*p=&a; //错误写法

• 注意点:

• 多个指针变量可以指向同一个地址
  

• 指针的指向是可以改变的

int a = 5;
int *p = &a;
int b = 10;
p = &b; // 修改指针指向

• 指针没有初始化里面是一个垃圾值,这时候我们这是一个野指针

• 野指针可能会导致程序崩溃
• 野指针访问你不该访问数据
• 所以指针必须初始化才可以访问其所指向存储区域
  

CDSY,CDSY.XYZ