基于C语言的数组从入门到精通

简介:本篇文章主要介绍了一维数组,二维数组,字符数组的定义,数组的应用,数组的核心代码解析,适用于0基础的初学者.

• C语言数组

• 1.一维数组
  • 1.1定义
    • 1.1.1声明
      • 语法:数据类型 数组名[数组大小];
      • 示例:int arr[5];
    • 1.1.2初始化
      • a.静态初始化
        • 完全初始化：int arr[5] = {1, 2, 3, 4, 5};
        • 部分初始化：int arr[5] = {1, 2};（剩余元素初始化为0）
        • 特殊初始化：int arr[] = {1, 2, 3, 4, 5};（编译器自动计算大小）
      • b.动态初始化
        • 使用malloc
          • int *arr = (int *)malloc(5 * sizeof(int));
          • for (int i = 0; i < 5; i++) { arr[i] = i + 1; }
        • 使用calloc
          • int *arr = (int *)calloc(5, sizeof(int));
          • for (int i = 0; i < 5; i++) { arr[i] = i + 1; }
  • 1.2一维数组访问
    • 1.2.1通过索引访问
      • 语法：数组名[索引]
      • 示例：int value = arr[0];
    • 1.2.2边界检查
      • if (index >= 0 && index < n) { int value = arr[index]; }
  • 1.3一维数组操作
    • 1.3.1遍历数组
      • 使用for循环;
      • for (int i = 0; i < 数组大小; i++) {    printf("%d ", arr[i]);}
    • 1.3.2数组排序
      • a.选择排序
        • for (int i = 0; i < 数组大小 - 1; i++) {    int minIndex = i;    for (int j = i + 1; j < 数组大小; j++) {        if (arr[j] < arr[minIndex]) {            minIndex = j;        }    }    int temp = arr[minIndex];    arr[minIndex] = arr[i];    arr[i] = temp;}
      • b.冒泡排序
        • for (int i = 0; i < 数组大小 - 1; i++) {    for (int j = 0; j < 数组大小 - i - 1; j++) {        if (arr[j] > arr[j + 1]) {            int temp = arr[j];            arr[j] = arr[j + 1];            arr[j + 1] = temp;        }    }}
    • 1.3.3数组搜索
      • a.线性搜索
        • int search(int arr[], int 数组大小, int key) {    for (int i = 0; i < 数组大小; i++) {        if (arr[i] == key) {            return i;        }    }    return -1;}
      • b.二分搜索
        • int binarySearch(int arr[], int 数组大小, int key) {    int left = 0, right = 数组大小 - 1;    while (left <= right) {        int mid = left + (right - left) / 2;        if (arr[mid] == key) {            return mid;        }        if (arr[mid] < key) {            left = mid + 1;        } else {            right = mid - 1;        }    }    return -1;}
    • 1.3.4数组长度
      • 使用sizeof运算符计算
      • int length = sizeof(numbers) / sizeof(numbers[0]);
  • 1.4数组与指针
    • 1.4.1数组名作为指针：数组名是指向数组第一个元素的常量指针：int *ptr = arr;
    • 1.4.2指针运算：移动到下一个元素：ptr++;
    • 1.4.3指针与数组的关系：*(arr + i)等价于arr[i]
  • 1.5数组作为函数参数
    • 1.5.1传递一维数组：函数声明：void func(int arr[], int 数组大小);函数调用：int arr[5] = {1, 2, 3, 4, 5}; func(arr, 5);
• 2.二维数组
  • 2.1定义
    • 2.1.1声明
      • 数据类型 数组名[行数][列数];
      • 示例：int arr[3][4];
    • 2.1.2初始化
      • 完全初始化：int arr[3][4] = { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
      • 部分初始化：int arr[3][4] = { {1, 2}, {5, 6}, {9, 10}};（剩余元素初始化为0）
      • 特殊初始化：int arr[][4] = { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};（编译器自动计算行数）
  • 2.2访问
    • 2.2.1通过索引访问：int value = arr[行索引][列索引];
    • 2.2.2示例：int value = arr[1][2][3];
  • 2.3操作
    • 2.3.1遍历二维数组
      • 使用嵌套for循环：
      • for (int i = 0; i < 行数; i++) {    for (int j = 0; j < 列数; j++) {        printf("%d ", arr[i][j]);    }    printf("\n");}
  • 2.4二维数组与指针
    • 2.4.1数组名作为指针：int (*ptr)[列数] = arr;
    • 2.4.2指针运算：ptr++;（移动到下一行）
    • 2.4.3指针与数组的关系：*(*(arr + i) + j)等价于arr[i][j]
  • 2.5二维数组作为函数参数
    • 2.5.1传递二维数组：函数声明：void func(int arr[][列数], int 行数);函数调用：int arr[3][4] = { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}; func(arr, 3);
• 3.字符数组
  • 3.1定义
    • 3.1.1声明
      • 语法：char 数组名[数组大小];
      • 示例：char str[10];
    • 3.1.2初始化
      • a.字符初始化
        • a.1完全初始化
          • 定义:初始化数组长度所有的值
          • char str[5] = {'H', 'e', 'l', 'l', 'o',}; //长度为5
        • a.2部分初始化
          • 定义:初始化元素的个数,小于数组的长度,没有初始化部分使用'\0'补齐
          • char str[10] = {'H', 'e', 'l', 'l', 'o'}; //剩余元素初始化为'\0'）
        • a.3特殊初始化
          • 定义:不定义数组的长度,由初始化元素的个数来决定
          • char str[ ] = {'H', 'e', 'l', 'l', 'o'}; //长度为5
      • b.字符串初始化
        • b.1完全初始化
          • 定义:初始化数组长度所有的值
          • char str[6] = {"hello"};  //长度为6,最后一位是补'\0'
          • char str[6] = "hello";  //长度为6,最后一位是补'\0'
        • b.2部分初始化
          • 定义:初始化元素的个数,小于数组的长度,没有初始化部分使用'\0'补齐
          • char str[4] = {"hi"}; //剩余元素初始化为'\0'）
        • b.3特殊初始化
          • 定义:不定义数组的长度,由初始化元素的个数来决定
          • char str[ ] = {"hello"}; //长度为6
  • 3.2访问
    • 3.2.1通过索引访问
      • 字符数组中的每个字符都可以通过其索引进行访问。索引从0开始，最后一个字符的索引是length - 1，其中length是字符串的长度。char str[] = "Hello";printf("First character: %c\n", str[0]);  // 输出 'H'printf("Last character: %c\n", str[4]);   // 输出 'o'
    • 3.2.2使用指针访问
      • 字符数组的名称可以作为指向数组首元素的指针来使用。可以通过指针运算来访问字符数组中的各个字符。char str[] = "Hello";char *ptr = str;printf("First character: %c\n", *ptr);    // 输出 'H'printf("Second character: %c\n", *(ptr + 1));  // 输出 'e'// 使用循环遍历字符数组while (*ptr != '\0') {    printf("%c", *ptr);    ptr++;}printf("\n");
    • 3.3.3边界检查
      • 为了避免越界访问，应该始终进行边界检查，确保索引在合法范围内。char str[] = "Hello";int length = strlen(str);int index = 2;if (index >= 0 && index < length) {    printf("Character at index %d: %c\n", index, str[index]);} else {    printf("Index out of bounds\n");}
    • 3.2.4遍历字符数组
      • 使用for循环或while循环来遍历字符数组，直到遇到字符串结束符\0。char str[] = "Hello";int length = strlen(str);for (int i = 0; i < length; i++) {    printf("%c", str[i]);}printf("\n");
      • 使用while循环char str[] = "Hello";char *ptr = str;while (*ptr != '\0') {    printf("%c", *ptr);    ptr++;}printf("\n");
    • 3.3.5二维字符数组
      • 可以通过多个索引来访问每个字符。char strArray[3][6] = {"Hello", "World", "C"};// 访问第一个字符串的第一个字符printf("out %c\n", strArray[0][0]);// 遍历所有字符串并输出for (int i = 0; i < 3; i++) {    for (int j = 0; j < 6 && strArray[i][j] != '\0'; j++) {        printf("%c", strArray[i][j]);    }    printf("\n");}
    • 3.3.6动态内存分配的数组
      • 对于使用malloc或calloc动态分配的字符数组，同样可以通过索引或指针进行访问，但需要注意内存管理，使用完后要释放内存。#include <stdio.h>#include <stdlib.h>#include <string.h>int main() {    char *str = (char *)malloc(6 * sizeof(char));    strcpy(str, "Hello");    // 通过索引访问    printf("First character: %c\n", str[0]);    // 通过指针访问    char *ptr = str;    while (*ptr != '\0') {        printf("%c", *ptr);        ptr++;    }    printf("\n");    free(str);  // 释放动态分配的内存    return 0;}
  • 3.3字符数组操作
    • 3.3.1字符及字符串输入
      • scanf
        • int scanf(const char *format, ...)：从标准输入读取格式化输入。
        • char str[100];scanf("%s", str);  // 读取一个单词（遇到空格、换行或制表符停止）
      • fscanf
        • int fscanf(FILE *stream, const char *format, ...)：从指定文件流读取格式化输入。
      • fgets
        • char *fgets(char *str, int n, FILE *stream)：从指定文件流读取最多n-1个字符，直到遇到换行符或EOF。自动添加\0作为字符串结束符。
        • char str[100];fgets(str, sizeof(str), stdin);  // 读取一行字符串
      • getline（非标准）
        • ssize_t getline(char **lineptr, size_t *n, FILE *stream)：动态分配内存读取一行字符串。适用于不确定长度的输入。
        • char *line = NULL;size_t len = 0;ssize_t read = getline(&line, &len, stdin);if (read != -1) {    printf("Read line: %s", line);    free(line);}
      • gets（不推荐）
        • char *gets(char *str)：从标准输入读取一行字符串，直到遇到换行符或EOF。由于不检查缓冲区溢出，存在安全风险，已被弃用。
    • 3.3.2字符及字符串输出
      • printf
        • int printf(const char *format, ...)：向标准输出写入格式化输出。
        • char str[] = "Hello, World!";printf("%s\n", str);  // 输出字符串
      • fprintf
        • int fprintf(FILE *stream, const char *format, ...)：向指定文件流写入格式化输出。
      • puts
        • int puts(const char *str)：将字符串str和一个换行符写入标准输出。
        • char str[] = "Hello, World!";puts(str);  // 输出字符串并换行
      • fputs
        • int fputs(const char *str, FILE *stream)：将字符串str写入指定文件流，不添加换行符。
        • char str[] = "Hello, World!";fputs(str, stdout);  // 输出字符串，不换行
      • sprintf
        • int sprintf(char *str, const char *format, ...)：将格式化数据写入字符串str。
        • char buffer[50];sprintf(buffer, "Value: %d", 42);  // 格式化输出到字符串printf("%s\n", buffer);
      • snprintf
        • int snprintf(char *str, size_t size, const char *format, ...)：将格式化数据写入字符串str，最多写入size-1个字符，确保以\0结尾。
        • snprintf(buffer, sizeof(buffer), "Value: %d", 42);  // 安全的格式化输出printf("%s\n", buffer);
    • 3.3.3字符处理函数<ctype.h> 库
      • 字符检查函数
        • isalnum(c)：检查字符c是否为字母或数字。
        • isalpha(c)：检查字符c是否为字母（包括大写和小写字母）。
        • iscntrl(c)：检查字符c是否为控制字符。
        • isdigit(c)：检查字符c是否为数字（0-9）。
        • isgraph(c)：检查字符c是否为图形字符（非空字符，不包括空格）。
        • islower(c)：检查字符c是否为小写字母。
        • isprint(c)：检查字符c是否为可打印字符（包括空格）。
        • ispunct(c)：检查字符c是否为标点符号。
        • isspace(c)：检查字符c是否为空白字符（如空格、制表符、换行符等）。
        • isupper(c)：检查字符c是否为大写字母。
        • isxdigit(c)：检查字符c是否为十六进制数字（0-9, a-f, A-F）。
      • 字符转换函数
        • tolower(c)：将字符c转换为小写，如果不是大写字母则保持不变。
        • toupper(c)：将字符c转换为大写，如果不是小写字母则保持不变。
    • 3.3.4字符串处理函数<string.h> 库
      • a.字符串操作
        • a1.计算字符串长度strlen(s)：计算字符串s的长度，不包括结尾的\0。size_t len = strlen("Hello, World!");
        • a2.复制字符串
          • strcpy(dest, src)：将字符串src复制到dest，包括结尾的\0。char dest[50];strcpy(dest, "Hello, World!");
          • strncpy(dest, src, n)：最多复制src的前n个字符到dest，如果src长度小于n，则用\0填充剩余部分。char dest[50];strncpy(dest, "Hello, World!", 5);dest[5] = '\0'; // 保证字符串以'\0'结尾
        • a3.连接字符串
          • strcat(dest, src)：将字符串src连接到dest的末尾，覆盖dest原有的结尾\0。char dest[50] = "Hello, ";strcat(dest, "World!");
          • strncat(dest, src, n)：最多将src的前n个字符连接到dest的末尾。char dest[50] = "Hello, ";strncat(dest, "World!", 5);
      • b.字符串比较
        • b1.比较两个字符串
          • strcmp(s1, s2)：比较两个字符串s1和s2，返回值为0表示相等，负数表示s1小于s2，正数表示s1大于s2。int result = strcmp("apple", "banana");
          • strncmp(s1, s2, n)：最多比较两个字符串的前n个字符。int result = strncmp("apple", "apples", 5);
        • b2.忽略大小写比较
          • strcasecmp(s1, s2)：忽略大小写比较两个字符串（非标准，但广泛支持）。int result = strcasecmp("Apple", "apple");
          • strncasecmp(s1, s2, n)：忽略大小写最多比较两个字符串的前n个字符（非标准，但广泛支持）。int result = strncasecmp("Apple", "apple", 5);
      • c.字符串查找与替换
        • c1.查找字符
          • strchr(s, c)：在字符串s中查找字符c第一次出现的位置，返回指向该位置的指针，未找到则返回NULL。
          • strrchr(s, c)：在字符串s中查找字符c最后一次出现的位置，返回指向该位置的指针，未找到则返回NULL。char *ptr = strrchr("Hello, World!", 'o');
        • c2.查找子串strstr(s1, s2)：在字符串s1中查找子串s2第一次出现的位置，返回指向该位置的指针，未找到则返回NULL。char *ptr = strstr("Hello, World!", "World");
        • c3.分割字符串char *strtok(char *str, const char *delim)：strtok(s, delim)：将字符串s按分隔符delim分割成多个子串，每次调用返回一个子串，直到没有更多子串时返回NULL。
      • d.内存操作
        • d1.内存复制void *memcpy(void *dest, const void *src, size_t n)：从src复制n个字节到dest。void *memmove(void *dest, const void *src, size_t n)：与memcpy类似，但处理重叠内存区域更安全。
        • d2.内存设置void *memset(void *s, int c, size_t n)：将n个字节的内容设置为字符c。
      • e.字符串转换.
        • e1.字符串转整数int atoi(const char *s)：将字符串s转换为整数。long atol(const char *s)：将字符串s转换为长整数。long long atoll(const char *s)：将字符串s转换为长整数（64位）。
        • e2.字符串转浮点数double atof(const char *s)：将字符串s转换为双精度浮点数。
        • e3.格式化输入输出int sprintf(char *str, const char *format, ...)：按照格式化字符串format将数据写入字符串str。int sscanf(const char *str, const char *format, ...)：从字符串str中读取数据，并根据格式化字符串format解析到参数中。
  • 3.4字符数组与指针
    • 3.4.1字符数组与指针的定义
      • 字符数组的名称实际上是一个指向数组首元素的常量指针。可以使用数组名来访问数组中的元素，就像使用指针一样。
      • char str[] = "Hello";printf("First character: %c\n", *str);  // 输出 'H'str 是一个指向字符数组首元素的指针。*str 解引用指针，获取第一个字符。
    • 3.4.2指针赋值与字符数组
      • 可以通过指针变量指向字符数组，并使用指针运算来遍历或修改字符数组中的内容。
      • char str[] = "Hello";char *ptr = str;// 使用指针遍历字符数组while (*ptr != '\0') {    printf("%c", *ptr);    ptr++;}printf("\n");
        • ptr 指向字符数组的首元素。
        • *ptr 访问当前指针指向的字符。
        • ptr++ 移动指针到下一个字符。
    • 3.4.3指针算术与字符数组
      • 指针算术允许你通过指针偏移量来访问字符数组中的任意元素。
      • char str[] = "Hello";
      • char *ptr = str;
      • printf("Second character: %c\n", *(ptr + 1));  // 输出 'e'
      • *(ptr + 1) 访问指针指向位置后一个字符。
    • 3.4.4使用动态分配字符数组
      • 使用malloc或calloc动态分配字符数组时，返回的是一个指向字符数组的指针。
      • #include <stdio.h>#include <stdlib.h>#include <string.h>int main() {    char *str = (char *)malloc(6 * sizeof(char));    strcpy(str, "Hello");    // 使用指针访问动态分配的字符数组    printf("First character: %c\n", *str);    // 使用循环遍历字符数组    for (int i = 0; i < 5; i++) {        printf("%c", str[i]);    }    printf("\n");    free(str);  // 释放动态分配的内存    return 0;}
    • 3.4.5字符串字面量与指针
      • 字符串字面量（如 "Hello"）实际上是存储在只读内存区域中的字符数组，使用时会返回一个指向该区域的指针。
      • char *str = "Hello";  // str 指向字符串字面量printf("First character: %c\n", *str);  // 输出 'H'// 注意：不能修改字符串字面量的内容// *str = 'h';  // 这将导致未定义行为
    • 3.4.6多维字符数组与指针
      • 对于多维字符数组（如二维字符数组），可以通过多个指针来访问每个字符。
      • char strArray[3][6] = {"Hello", "World", "C"};// 使用指针访问多维字符数组for (int i = 0; i < 3; i++) {    char *ptr = strArray[i];    while (*ptr != '\0') {        printf("%c", *ptr);        ptr++;    }    printf("\n");}
    • 3.4.7 指针与数组的关系总结
      • 数组名是常量指针：数组名等价于指向数组首元素的指针，但不能修改数组名本身。
      • 指针算术：可以使用指针算术（如ptr + n）来访问数组中的任意元素。
      • 解引用指针：使用*ptr可以访问指针所指向的字符。
      • 动态分配：动态分配的字符数组通过指针进行访问和操作，记得释放内存。
      • 字符串字面量：字符串字面量是只读的，不能修改其内容。
  • 3.5字符数组作为函数参数
    • 3.5.1定义
      • 当将字符数组作为参数传递给函数时，实际上是传递了一个指向数组首元素的指针。
    • 3.5.2传递字符数组声明调用
      • 函数声明：void func(char str[]);
      • 函数调用：char str[100] = "Hello"; func(str);
    • 3.5.3函数实现
      • void printString(char *str) {    while (*str != '\0') {        putchar(*str++);    }    putchar('\n');}int main() {    char str[] = "Hello";    printString(str);  // 传递字符数组的指针    return 0;}
• 4.思维导图
  • 根据思维导图,能够了解所要学习数组所有核心点的知识

5.数组核心代码

        5.1数组声明与定义

#include <stdio.h>
#include <string.h>
#include <stdlib.h>int main(int argc, const char *argv[])
{// 一维数组声明与静态初始化int arr1[5];int arr2[5] = {1, 2, 3, 4, 5};// 二维数组声明与静态初始化int arr3[3][4];int arr4[3][4] = { {1, 2, 3, 4}, {5, 6, 7, 8},{9, 10, 11, 12}};// 动态数组（使用malloc）int *arr5 = (int *)malloc(5 * sizeof(int));if (arr5 == NULL) 
{// 内存分配失败处理perror("Memory allocation failed");exit(EXIT_FAILURE);}for (int i = 0; i < 5; i++) 
{arr5[i] = i + 1;}// 打印一维数组 arr2printf("一维数组 arr2: ");for (int i = 0; i < 5; i++) 
{printf("%d ", arr2[i]);}printf("\n");// 打印二维数组 arr4printf("二维数组 arr4:\n");for (int i = 0; i < 3; i++) 
{for (int j = 0; j < 4; j++) 
{printf("%d ", arr4[i][j]);}printf("\n");}// 打印动态数组 arr5printf("动态数组 arr5: ");for (int i = 0; i < 5; i++) 
{printf("%d ", arr5[i]);}printf("\n");// 释放动态分配的内存free(arr5);return 0;
}

        5.2数组的访问

#include <stdio.h>
#include <string.h>
#include <stdlib.h>int main(int argc, const char *argv[])
{// 一维数组声明与静态初始化int arr2[5] = {1, 2, 3, 4, 5};// 二维数组声明与静态初始化int arr4[3][4] = {{1, 2, 3, 4},{5, 6, 7, 8},{9, 10, 11, 12}};// 访问一维数组第一个元素int value1 = arr2[0];printf("Value1 (arr2[0]): %d\n", value1);// 访问二维数组第二行第三列元素int value2 = arr4[1][2];printf("Value2 (arr4[1][2]): %d\n", value2);// 边界检查示例int index = 3;if (index >= 0 && index < 5) 
{int value3 = arr2[index];printf("Value3 (arr2[%d]): %d\n", index, value3);} else {printf("Index out of bounds\n");}// 测试超出范围的索引index = 5;if (index >= 0 && index < 5) {int value3 = arr2[index];printf("Value3 (arr2[%d]): %d\n", index, value3);} else {printf("Index out of bounds\n");}return 0;
}

        5.3数组的遍历

#include <stdio.h>int main(int argc, const char *argv[])
{// 一维数组声明与静态初始化int arr2[5] = {1, 2, 3, 4, 5};// 二维数组声明与静态初始化int arr4[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8},{9, 10, 11, 12}};// 遍历一维数组printf("一维数组 arr2: ");for (int i = 0; i < 5; i++) 
{printf("%d ", arr2[i]);}printf("\n");// 遍历二维数组printf("二维数组 arr4:\n");for (int i = 0; i < 3; i++) 
{for (int j = 0; j < 4; j++) 
{printf("%d ", arr4[i][j]);}printf("\n");}return 0;
}/*一维数组：
arr2 初始化为 {1, 2, 3, 4, 5}。
使用单层 for 循环遍历并打印每个元素。
二维数组：
arr4 初始化为指定的二维数组。
使用嵌套的 for 循环遍历并打印每个元素，每行结束后打印换行符。
通过这个示例代码，你可以更好地理解C语言数组的遍历方法。
*/

        5.4数组的排序

                5.4.1冒泡排序

 a.冒泡排序的原理:依次比较相邻的元素，如果前面的比后面的大(小)就进行交换每一趟比较后，就会得到一个最大值(小)，该值不进行下一轮的比较对剩余的部分，再次进行前面的操作，直到剩余一个元素为止，排序成功。

        天蓝色:待排序

        绿色:正在比较的数组元素

        橙色:已经拍好的数组元素

b.冒泡排序的要素

b1.需要双重循环来解决:

        外层循环：控制遍历的次数。总共需要 n-1 次遍历。
        i 从 0 到 n-2。
        内层循环：比较相邻的元素并交换它们。
        j 从 0 到 n-i-2。

b2.每趟的比较次数 +所在趟数 == 元素总个数.
b3.每次内层循环结束后，最大的元素会被“冒泡”到数组的末尾。
b4.比较和交换：
        如果 arr[j] 大于 arr[j + 1]，则交换这两个元素。
        使用临时变量 temp 来交换元素的值。

#include <stdio.h>int main(int argc, const char *argv[]){int arr[] = {64, 25, 12, 22, 11};int n = sizeof(arr) / sizeof(arr[0]);int i, j, temp;printf("原始数组: \n");for (i = 0; i < n; i++) 
{printf("%d ", arr[i]);}printf("\n");// 冒泡排序算法for (i = 0; i < n - 1; i++) 
{for (j = 0; j < n - i - 1; j++) {if (arr[j] > arr[j + 1]) {// 交换 arr[j] 和 arr[j + 1]temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}printf("冒泡排序后的数组: \n");for (i = 0; i < n; i++) 
{printf("%d ", arr[i]);}printf("\n");return 0;
}

                   5.4.2选择排序

a.选择排序的原理:每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

b.选择排序的算法

b1.外层循环 for (int i = 0; i < n - 1; i++) 遍历数组中的每个元素，i 表示当前考虑的元素位置。

b2.内层循环 for (int j = i + 1; j < n; j++) 从当前元素的下一个元素开始遍历，寻找从 i 开始的最小元素。

b3.如果在内层循环中发现比当前最小值更小的元素，则更新最小值的索引 minIndex。

b4.内层循环结束后，如果 minIndex 不等于 i，则交换 arr[i] 和 arr[minIndex]。

c.选择排序注意:选择排序的时间复杂度为O(n^2)，其中n是数组的长度。它不是一种高效的排序算法，但它的实现简单，对于小型数据集来说足够使用。对于大型数据集，通常会使用更高效的排序算法，如快速排序、归并排序或堆排序。

#include <stdio.h>
int main(int argc, const char *argv[])
{int arr[] = {64, 25, 12, 22, 11}; // 待排序数组int n = sizeof(arr) / sizeof(arr[0]); // 计算数组长度// 外层循环，遍历数组中的每个元素for (int i = 0; i < n - 1; i++) 
{// 假设当前元素为最小值int minIndex = i;// 内层循环，从当前元素的下一个元素开始遍历，寻找最小值for (int j = i + 1; j < n; j++) 
{// 如果找到更小的元素，则更新最小值的索引if (arr[j] < arr[minIndex]){minIndex = j;}}// 如果最小值不是当前元素，则交换它们if (minIndex != i) 
{int temp = arr[i];arr[i] = arr[minIndex];arr[minIndex] = temp;}}// 打印排序后的数组printf("排序后的数组: ");for (int i = 0; i < n; i++) 
{printf("%d ", arr[i]);}printf("\n");return 0;
}

                5.4.3插入排序

         是一种简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。在C语言中，插入排序的实现通常涉及到数组的操作。

a.插入排序的原理

a1.初始状态： 假设数组的第一个元素已经是有序的（因为一个元素本身就是有序的）。

a2.排序过程：

        从数组的第二个元素开始，依次将每个元素插入到前面已经排好序的子数组中。

        对于每个待插入的元素，从后向前比较它与已排序子数组中的元素。

         如果待插入元素小于已排序子数组中的某个元素，则将该元素向后移动一位，为待插入元素腾出位置。

        重复这个过程，直到找到合适的位置插入待插入元素。

a3.重复步骤2： 继续处理数组中的下一个元素，直到整个数组都被排序。

b.插入排序的算法

b1.外层循环 for (int i = 1; i < n; i++) 从数组的第二个元素开始遍历，因为第一个元素默认是已排序的。

b2.int key = arr[i]; 保存当前要插入的元素。

b3.int j = i - 1; 初始化一个指针，指向当前元素的前一个位置。

b4.内层循环 while (j >= 0 && arr[j] > key) 将大于 key 的元素向后移动一位，直到找到 key 应该插入的位置。

b5..arr[j + 1] = key; 将 key 插入到正确的位置。

#include <stdio.h>
int main(int argc, const char *argv[])
{int arr[] = {12, 11, 13, 5, 6}; // 待排序数组int n = sizeof(arr) / sizeof(arr[0]); // 计算数组长度// 插入排序算法for (int i = 1; i < n; i++) 
{int key = arr[i]; // 当前要插入的元素int j = i - 1;// 将大于key的元素向后移动一位while (j >= 0 && arr[j] > key) 
{arr[j + 1] = arr[j];j--;}// 插入key到正确的位置arr[j + 1] = key;}// 打印排序后的数组printf("排序后的数组: ");for (int i = 0; i < n; i++) 
{printf("%d ", arr[i]);}printf("\n");return 0;
}

6.数组练习题