冒泡排序算法

冒泡排序算法的原理是比较两个相邻的元素，将值大的元素和值小的元素进行交换。具体实现思路是：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复第一趟步骤，直至全部排序完成。

冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

程序清单

#include <stdio.h>
// 冒泡排序函数
void bubbleSort(int arr[], int n) {
    int i, j, temp;
    for (i = 0; i < n-1; i++) {     
        // 最后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 printArray(int arr[], int size) {
    int i;
    for (i=0; i < size; i++)
        printf("%d ", arr[i]);
    printf("\n");
}
// 主函数
int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr)/sizeof(arr[0]);
    bubbleSort(arr, n);
    printf("排序后的数组:\n");
    printArray(arr, n);
    return 0;
}

bubbleSort函数接收一个整数数组arr和数组的大小n作为参数。它使用两个嵌套的for循环来遍历数组并比较元素。如果当前元素比下一个元素大，则交换它们的位置。这个过程会重复进行，直到整个数组排序完成。

printArray函数用于打印数组的内容，在main函数中，定义了一个待排序的数组，并调用bubbleSort函数对其进行排序。排序完成后调用printArray函数来打印排序后的数组。

矩阵乘法运算

二维数组常用于表示矩阵，矩阵乘法是指两个矩阵相乘运算。两个矩阵相乘时，必须遵循下面的规则：

第一个矩阵的列数必须等于第二个矩阵的行数。结果矩阵的行数等于第一个矩阵的行数，列数等于第二个矩阵的列数。

下面的C程序，用于计算两个矩阵的乘积：

#include <stdio.h>
#define ROWS_A 3
#define COLS_A 2
#define ROWS_B 2
#define COLS_B 3
// 函数声明
void matrixMultiplication(int A[][COLS_A], int B[][COLS_B], int result[][COLS_B]);
int main() {
    // 定义并初始化两个矩阵A和B
    int A[ROWS_A][COLS_A] = {{1, 2}, {3, 4}, {5, 6}};
    int B[ROWS_B][COLS_B] = {{7, 8, 9}, {10, 11, 12}};
    // 定义结果矩阵，大小为A的行数 x B的列数
    int result[ROWS_A][COLS_B];
    // 执行矩阵乘法
    matrixMultiplication(A, B, result);
    // 打印结果矩阵
    printf("Result matrix:\n");
    for (int i = 0; i < ROWS_A; i++) {
        for (int j = 0; j < COLS_B; j++) {
            printf("%d ", result[i][j]);
        }
        printf("\n");
    }
    return 0;
}
// 矩阵乘法函数
void matrixMultiplication(int A[][COLS_A], int B[][COLS_B], int result[][COLS_B]) {
    for (int i = 0; i < ROWS_A; i++) {
        for (int j = 0; j < COLS_B; j++) {
            result[i][j] = 0; // 初始化结果为0
            for (int k = 0; k < COLS_A; k++) {
                result[i][j] += A[i][k] * B[k][j];
            }
        }
    }
}

在上面的程序中，定义了两个矩阵A和B，维度分别是ROWS_A，COLS_A和ROWS_B、COLS_B。ROWS_A必须等于ROWS_B以便进行乘法运算。matrixMultiplication函数它接受两个矩阵以及一个用于存储结果的矩阵。在函数内部，使用三重循环来计算乘积，并将结果存储在result矩阵中。

程序假设矩阵乘法是可行的（即ROWS_A等于ROWS_B），并且没有进行错误检查。在实际应用中，需要添加额外的检查以确保矩阵乘法可以进行，并处理任何可能的错误情况。

计算斐波那契数列

在C语言中可以使用数组来存储斐波那契数列的值。下面的例子展示了如何使用数组来计算并打印前N个斐波那契数列的值。

#include <stdio.h>
#define FIB_SIZE 10 // 定义斐波那契数列的大小
int main() {
    // 声明一个数组来存储斐波那契数列的值
    int fibonacci[FIB_SIZE] = {0};
    
    // 初始条件
    fibonacci[0] = 0;
    if (FIB_SIZE > 1) {
        fibonacci[1] = 1;
    }
    // 计算斐波那契数列
    for (int i = 2; i < FIB_SIZE; i++) {
        fibonacci[i] = fibonacci[i - 1] + fibonacci[i - 2];
    }
    // 打印斐波那契数列
    printf("Fibonacci Series:\n");
    for (int i = 0; i < FIB_SIZE; i++) {
        printf("%d ", fibonacci[i]);
    }
    printf("\n");
    return 0;
}

在上面的代码中，FIB_SIZE是一个常量，用于定义需要计算的斐波那契数列的长度。数组fibonacci用来存储斐波那契数列的值。程序使用两个循环：第一个循环初始化数组的前两个值，第二个循环计算并填充数组的其余部分。

注意：斐波那契数列的值会随着索引的增加而迅速增长，如果想要计算很大的斐波那契数，可能需要使用更大的数据类型（如long long）或者使用其他算法（如矩阵快速幂）来避免整数溢出。此外，对于非常大的斐波那契数，使用数组可能不是最高效的方法，因为它需要存储所有的中间结果。

存储和打印杨辉三角

杨辉三角是一个经典的数学图形，在编程中经常用来演示递归和数组操作。在C语言中，可以使用二维数组来存储和打印杨辉三角。下面是一个简单的C语言程序，用于生成和打印前N行的杨辉三角。

#include <stdio.h>
#define ROWS 10 // 定义杨辉三角的行数
int main() {
    // 声明一个二维数组来存储杨辉三角
    int pascalTriangle[ROWS][ROWS];
    // 初始化第一列和对角线上的元素为1
    for (int i = 0; i < ROWS; i++) {
        pascalTriangle[i][0] = 1;
        pascalTriangle[i][i] = 1;
    }
    // 计算其他元素的值
    for (int i = 2; i < ROWS; i++) {
        for (int j = 1; j < i; j++) {
            pascalTriangle[i][j] = pascalTriangle[i - 1][j - 1] + pascalTriangle[i - 1][j];
        }
    }
    // 打印杨辉三角
    for (int i = 0; i < ROWS; i++) {
        // 打印每一行前的空格
        for (int k = 0; k < ROWS - i - 1; k++) {
            printf("  ");
        }
        // 打印每一行的元素
        for (int j = 0; j <= i; j++) {
            printf("%4d", pascalTriangle[i][j]);
        }
        printf("\n"); // 换行
    }
    return 0;
}

在这个程序中，首先定义一个二维数组pascalTriangle来存储杨辉三角的值。然后使用两个嵌套的for循环来初始化数组：第一个循环设置每一行的开始和结束元素为1，第二个循环计算每一行的其他元素，这些元素是它们正上方的元素和左上方元素之和。

最后使用另外两个嵌套的for循环来打印杨辉三角。外部循环遍历每一行，内部循环的第一个部分打印出每一行前面的空格，以确保杨辉三角在控制台上正确对齐。然后，内部循环的第二个部分打印出每一行的元素。

折半查找算法

折半查找（也称为二分查找）是一种在有序数组中查找特定元素的搜索算法。搜索过程从数组的中间元素开始，如果中间元素正好是目标值，则搜索过程结束；如果目标值大于或小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且同样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。

程序清单

#include <stdio.h>
// 折半查找函数
int binarySearch(int arr[], int left, int right, int target) {
    while (left <= right) {
        int mid = left + (right - left) / 2; // 防止溢出
        if (arr[mid] == target) {
            return mid; // 找到目标，返回其索引
        } else if (arr[mid] < target) {
            left = mid + 1; // 在右半部分继续查找
        } else {
            right = mid - 1; // 在左半部分继续查找
        }
    }
    return -1; // 没找到目标，返回-1
}
int main() {
    int arr[] = {2, 3, 4, 10, 40}; // 已排序的数组
    int n = sizeof(arr) / sizeof(arr[0]); // 数组元素个数
    int target = 10; // 要查找的目标值
    int result = binarySearch(arr, 0, n - 1, target); // 调用折半查找函数
    if (result == -1) {
        printf("Element not found\n");
    } else {
        printf("Element found at index %d\n", result);
    }
    return 0;
}

binarySearch函数接收一个整型数组arr，参数left是数组的左边界，参数right是数组的右边界，参数target为要查找的目标值。函数使用while循环来执行折半查找，直到找到目标值或搜索范围为空。如果找到目标值，函数返回其索引；否则，返回-1表示未找到。

在main函数内部定义了一个已排序的数组arr，并初始化要查找的目标值target。然后调用binarySearch函数来查找目标值，并根据返回值输出相应的结果。