C语言基础（六）

一维数组：

C语言中的数组是一种基本的数据结构，用于在计算机内存中连续存储相同类型的数据。
数组中的每个元素可以通过索引（或下标）来访问，索引通常是从0开始的。

数组的大小在声明时确定，并且之后不能改变（除非使用动态内存分配技术，如指针和malloc/free等）。如果初始化时省略数组的大小，编译器会自动根据初始化列表中元素的数量确定数组的大小。

数组索引越界是C语言中常见的错误。如果尝试访问数组边界之外的元素，程序会崩溃或产生不可预测的行为。
数组的大小在编译时确定，且固定不变。如果需要动态改变数组大小，应考虑使用指针和动态内存分配。
数组名在表达式中通常被当作指向数组首元素的指针。但是，数组名本身并不是一个指针变量，而是一个常量表达式，其值为数组首元素的地址。

测试代码1：

#include <stdio.h>  
int main() {  
    // 定义并初始化一个整型数组  
    int numbers[5] = {1, 2, 3, 4, 5};  
  
    // 访问并打印数组中的每个元素
    // 数组下标从0开始	
    for(int i = 0; i < 5; i++) {  
        printf("numbers[%d] = %d\n", i, numbers[i]);  
    }  
  
    // 修改数组中的某个元素  
    numbers[2] = 10; // 将索引为2的元素（即第三个元素）修改为10  
  
    // 再次访问并打印修改后的数组元素  
    printf("After modification:\n");  
    for(int i = 0; i < 5; i++) {  
        printf("numbers[%d] = %d\n", i, numbers[i]);  
    }  
  
    // 部分初始化和自动初始化为0  
    int partialInit[5] = {1, 2}; // 只初始化了前两个元素，其余自动初始化为0  
    printf("Partially initialized array:\n");  
    for(int i = 0; i < 5; i++) {  
        printf("partialInit[%d] = %d\n", i, partialInit[i]);  
    }  
  
    // 使用变量大小，变长数组（VLA） 
    int size = 3;  
    int vla[size]; // 变长数组  
    for(int i = 0; i < size; i++) {  
        vla[i] = i * 2; // 初始化  
    }  
    printf("Variable Length Array:\n");  
    for(int i = 0; i < size; i++) {  
        printf("vla[%d] = %d\n", i, vla[i]);  
    }   
    return 0;  
}

运行结果如下：

 

测试代码2：

#include <stdio.h>  
// 冒泡排序  
void bubbleSort(int arr[], int n) {  
    int i, j, temp;  
    for (i = 0; i < n-1; i++) {  
        for (j = 0; j < n-i-1; j++) {  
            if (arr[j] > arr[j+1]) {  
                temp = arr[j];  
                arr[j] = arr[j+1];  
                arr[j+1] = temp;  
            }  
        }  
    }  
}  
  
// 选择排序  
void selectionSort(int arr[], int n) {  
    int i, j, minIndex, temp;  
    for (i = 0; i < n-1; i++) {  
        minIndex = i;  
        for (j = i+1; j < n; j++) {  
            if (arr[j] < arr[minIndex]) {  
                minIndex = j;  
            }  
        }  
        temp = arr[minIndex];  
        arr[minIndex] = arr[i];  
        arr[i] = temp;  
    }  
}  
  
int main() {  
    //户输入整数以及整数个数 
    int n, choice, i;  
    printf("请输入整数的个数: ");  
    scanf("%d", &n);  
    int arr[n];  
  
    printf("请输入%d个整数:\n", n);  
    for(i = 0; i < n; i++) {  
        scanf("%d", &arr[i]);  
    }  
  
    printf("选择排序算法（1: 冒泡排序, 2: 选择排序）: ");  
    scanf("%d", &choice);  
    //选择排序方式 
    switch(choice) {  
        case 1:  
            bubbleSort(arr, n);  
            printf("冒泡排序后的数组:\n");  
            break;  
        case 2:  
            selectionSort(arr, n);  
            printf("选择排序后的数组:\n");  
            break;  
        default:  
            printf("无效的选择，请重新运行程序。\n");  
            return 1;  
    }  
    //打印排序后的数组 
    for (i = 0; i < n; i++)  
        printf("%d ", arr[i]);  
    printf("\n");  
    return 0;  
}

运行结果如下：

 

测试代码3：

#include <stdio.h>  
#include <stdlib.h>  
#include <time.h>  
  
// 函数声明  
void generateRandomNumbers(int arr[], int n);  
void sortDescending(int arr[], int n);  
void insertNumber(int arr[], int *n, int number);  
void deleteNumber(int arr[], int *n, int m);  
void printArray(int arr[], int n);  
  
int main() {  
    int n, number, m;  
    int *arr;  
  
    // 初始化随机数生成器  
    srand(time(NULL));  
  
    printf("Enter the number of two-digit integers: ");  
    scanf("%d", &n);  
  
    // 动态分配数组  
    arr = (int *)malloc(n * sizeof(int));  
    if (arr == NULL) {  
        printf("Memory allocation failed!\n");  
        return 1;  
    }  
  
    // 生成随机数  
    generateRandomNumbers(arr, n);  
    printf("Original array:\n");  
    printArray(arr, n);  
  
    // 排序  
    sortDescending(arr, n);  
    printf("Sorted array (descending):\n");  
    printArray(arr, n);  
  
    // 插入数字  
    printf("Enter a number to insert: ");  
    scanf("%d", &number);  
    insertNumber(arr, &n, number);  
    printf("Array after insertion:\n");  
    printArray(arr, n);  
  
    // 删除数字  
    printf("Enter the index (0-%d) to delete: ", n - 1);  
    scanf("%d", &m);  
    if (m >= 0 && m < n) {  
        deleteNumber(arr, &n, m);  
        printf("Array after deletion:\n");  
        printArray(arr, n);  
    } else {  
        printf("Invalid index!\n");  
    }  
  
    // 释放内存  
    free(arr);  
  
    return 0;  
}  
  
// 实现函数  
void generateRandomNumbers(int arr[], int n) {  
    for (int i = 0; i < n; i++) {  
        arr[i] = rand() % 90 + 10; // 生成10到99之间的随机数  
    }  
}  
 //冒泡排序，按降序排列数组 
void sortDescending(int arr[], int n) {  
    for (int i = 0; i < n - 1; i++) {  
        for (int j = 0; j < n - i - 1; j++) {  
            if (arr[j] < arr[j + 1]) {  
                int temp = arr[j];  
                arr[j] = arr[j + 1];  
                arr[j + 1] = temp;  
            }  
        }  
    }  
}  
//在数组中插入一个数，并保持数组的有序性。  
void insertNumber(int arr[], int *n, int number) {  
    int i;  
    for (i = *n - 1; (i >= 0 && arr[i] < number); i--) {  
        arr[i + 1] = arr[i];  
    }  
    arr[i + 1] = number;  
    (*n)++;  
}  
//根据索引删除数组中的一个元素，并调整数组大小。 
void deleteNumber(int arr[], int *n, int m) {  
    for (int i = m; i < *n - 1; i++) {  
        arr[i] = arr[i + 1];  
    }  
    (*n)--;  
}  
// 打印数组 
void printArray(int arr[], int n) {  
    for (int i = 0; i < n; i++) {  
        printf("%d ", arr[i]);  
    }  
    printf("\n");  
}

运行结果如下：

 

测试代码4：

#include <stdio.h>  
//一维数组转换为二维数组
//"转换"只是逻辑上的，物理上仍然是一个一维数组。
//确保不要超出数组的实际边界，即index必须在0到total-1之间。
//这种方法在需要动态确定数组大小或数组大小较大时特别有用，
//可以避免使用二维数组可能带来的内存分配问题。 
int main() {  
    int i, j;  
    int rows = 3; // 3行  
    int cols = 4; // 4列  
    int total = rows * cols; // 总元素数量  
      
    // 初始化一维数组  
    int array[total];  
    for (i = 0; i < total; i++) {  
        array[i] = i + 1; //将数组元素初始化为1到total的整数  
        printf("%d ", array[i]);   
    }  
    printf("\n");
    // 使用二维数组的索引方式访问一维数组  
    // 通过计算索引（index = i * cols + j）访问一个二维数组。
	// i代表行索引，j代表列索引，cols是每行的列数。
    for (i = 0; i < rows; i++) {  
        for (j = 0; j < cols; j++) {  
            // 计算一维数组中的索引  
            int index = i * cols + j;  
            printf("%d ", array[index]);  
        }  
        printf("\n"); // 每完成一行的打印后换行  
    }  
  
    return 0;  
}

运行结果如下：

 

测试代码5：

#include <stdio.h>  
int main() {  
    // 定义一个5x3的二维数组  
    int twoDArray[5][3] = {  
        {1, 2, 3},  
        {4, 5, 6},  
        {7, 8, 9},  
        {10, 11, 12},  
        {13, 14, 15}  
    };  
    // 定义一个足够大的一维数组以存储二维数组的元素  
    int oneDArray[5 * 3]; // 因为是5x3的二维数组，所以一维数组需要15个元素的空间  
  
    // 遍历二维数组，并将元素复制到一维数组中  
    int index = 0; // 用于一维数组的索引  
    for (int i = 0; i < 5; i++) { // 遍历二维数组的行  
        for (int j = 0; j < 3; j++) { // 遍历二维数组的列  
            oneDArray[index++] = twoDArray[i][j]; // 将二维数组的元素复制到一维数组中，并更新索引  
        }  
    }   
    // 打印一维数组的元素
    for (int i = 0; i < 5 * 3; i++) {  
        printf("%d ", oneDArray[i]);  
    }   
    return 0;  
}

运行结果如下：