add

public/c/.vscode/launch.json

@@ -0,0 +1,31 @@
+{
+    "configurations": [
+        {
+            "name": "C/C++: gcc.exe 生成和调试活动文件",
+            "type": "cppdbg",
+            "request": "launch",
+            "program": "${fileDirname}\\${fileBasenameNoExtension}.exe",
+            "args": [],
+            "stopAtEntry": false,
+            "cwd": "${fileDirname}",
+            "environment": [],
+            "externalConsole": false,
+            "MIMode": "gdb",
+            "miDebuggerPath": "C:\\msys64\\ucrt64\\bin\\gdb.exe",
+            "setupCommands": [
+                {
+                    "description": "为 gdb 启用整齐打印",
+                    "text": "-enable-pretty-printing",
+                    "ignoreFailures": true
+                },
+                {
+                    "description": "将反汇编风格设置为 Intel",
+                    "text": "-gdb-set disassembly-flavor intel",
+                    "ignoreFailures": true
+                }
+            ],
+            "preLaunchTask": "C/C++: gcc.exe 生成活动文件"
+        }
+    ],
+    "version": "2.0.0"
+}

public/c/.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+    "files.associations": {
+        "limits.h": "c"
+    },
+    "C_Cpp.errorSquiggles": "disabled"
+}

public/c/.vscode/tasks.json

@@ -0,0 +1,28 @@
+{
+    "tasks": [
+        {
+            "type": "cppbuild",
+            "label": "C/C++: gcc.exe 生成活动文件",
+            "command": "C:\\msys64\\ucrt64\\bin\\gcc.exe",
+            "args": [
+                "-fdiagnostics-color=always",
+                "-g",
+                "${file}",
+                "-o",
+                "${fileDirname}\\${fileBasenameNoExtension}.exe"
+            ],
+            "options": {
+                "cwd": "${fileDirname}"
+            },
+            "problemMatcher": [
+                "$gcc"
+            ],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "detail": "调试器生成的任务。"
+        }
+    ],
+    "version": "2.0.0"
+}

public/c/ch1/compare.c

@@ -0,0 +1,21 @@
+#include <stdio.h>
+#include <time.h>
+
+int main() {
+    long timea, timeb, timec;//clock_t timea;
+    long a = 1LL, b = 100000000LL;
+    long long result1 = 0LL, result2 = 0LL;  
+
+    timea = clock();    
+    for (long long i = a; i <= b; i++) {
+        result1 += i;    
+    }
+    timeb = clock();    
+    printf("累加结果: %lld, 所用时间: %lf 毫秒\n", result1, (double)(timeb - timea) / CLOCKS_PER_SEC * 1000);
+
+    result2 = (a + b) * (b - a + 1) / 2;
+    timec = clock();    
+    printf("高斯结果: %lld, 所用时间: %lf 毫秒\n", result2, (double)(timec - timeb) / CLOCKS_PER_SEC * 1000);    
+ 
+    return 0; 
+}

public/c/ch1/compareall.c

@@ -0,0 +1,33 @@
+#include <stdio.h>
+#include <time.h>
+// 函数声明
+long long sum_leijia(long long a, long long b);
+long long sum_gaosi(long long a, long long b);
+
+int main() {
+    clock_t before, middle, after;
+    long long a = 1LL, b = 100000000LL;
+    long long result1 = 0LL, result2 = 0LL;     
+    before = clock();    
+    result1 = sum_leijia(a, b);
+    middle = clock();    
+    printf("累加计算结果: %lld, 所用时间: %lf 毫秒\n", result1, (double)(middle - before) / CLOCKS_PER_SEC * 1000);
+    
+    // 计算公式方式的和并计时
+    result2 = sum_gaosi(a, b);
+    after = clock();    
+    printf("高斯求和结果: %lld, 所用时间: %lf 毫秒\n", result2, (double)(after - middle) / CLOCKS_PER_SEC * 1000);    
+
+    return 0;
+} 
+long long sum_leijia(long long a, long long b) {
+    long long sum = 0LL;
+    for (long long i = a; i <= b; i++) {
+        sum += i;
+    }
+    return sum;
+}
+ 
+long long sum_gaosi(long long a, long long b) {
+    return (a + b) * (b - a + 1) / 2;
+}

public/c/ch1/first.c

@@ -0,0 +1,16 @@
+#include <stdio.h>   
+// row 表示当前要打印的行号（从1开始），n 表示总行数  
+void printAt(int row, int n) {   
+    if (row > n)  
+        return;  
+    for (int i = 0; i < row; i++)  
+        printf("@");   
+    printf("\n"); // 打印完一行后换行  
+    printAt(row + 1, n);  
+}   
+int main() {  
+    int n = 3; 
+    printAt(1, n);   
+    return 0;  
+}
+ 

public/c/ch2/bigcheng/bigchengnew.c

@@ -0,0 +1,41 @@
+#include <stdio.h>
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+// 递归计算大整数乘积
+double bigdataride(long x, long y, int n) {
+    x = llabs(x);    y = llabs(y);
+    if (n == 1) {
+        return (double)x * y; // 基本情况
+    } else {
+        if (n % 2 == 1) n--; // 处理奇数位
+        long halfPow = (long)pow(10, n / 2);
+        long a = x / halfPow;
+        long b = x % halfPow;
+        long c = y / halfPow;
+        long d = y % halfPow;
+
+        // 递归计算
+        double ac = bigdataride(a, c, n / 2);
+        double bd = bigdataride(b, d, n / 2);
+        long aJb = a + b;
+        long cJd = c + d;
+        double abcd = bigdataride(aJb, cJd, n / 2);
+        // 返回最终结果
+        return ac * pow(10, n) + (abcd - ac - bd) * pow(10, n / 2) + bd;
+    }
+}
+
+int main() {
+    long x = 8782346786879887887L;
+    long y = 4524387689998798768L;
+    // 计算数字长度
+    char sx[20];
+    snprintf(sx, sizeof(sx), "%ld", x);
+    int n = strlen(sx);
+    // 计算并输出结果
+    double s = bigdataride(x, y, n);
+    printf("大数相乘的计算结果为：%lf\n", s);
+
+    return 0;
+}

public/c/ch2/bigcheng/bigchengold.c

@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <string.h>
+#define MAX_LEN 1000
+// 计算两个大整数的乘积
+void multiply(const char* a, const char* b, char* result) {
+    int lenA = strlen(a), lenB = strlen(b), lenResult = lenA + lenB;
+    int arr[MAX_LEN * 2] = {0};
+
+    // 进行乘法运算
+    for (int i = 0; i < lenA; ++i)
+        for (int j = 0; j < lenB; ++j)
+            arr[i + j] += (a[lenA - i - 1] - '0') * (b[lenB - j - 1] - '0');
+    // 处理进位
+    for (int i = 0; i < lenResult - 1; ++i) {
+        arr[i + 1] += arr[i] / 10;
+        arr[i] %= 10;
+    }    
+    // 构建结果字符串
+    int index = 0;
+    while (index < lenResult && arr[index] == 0) ++index;
+    if (index == lenResult) strcpy(result, "0");
+    else {
+        for (int i = index; i < lenResult; ++i)
+            result[i - index] = arr[lenResult - i - 1] + '0';
+        result[lenResult - index] = '\0';
+    }
+}
+
+int main() {
+    char a[MAX_LEN + 1], b[MAX_LEN + 1], result[MAX_LEN * 2 + 1];
+    printf("输入第一个大整数: ");
+    scanf("%s", a);
+    printf("输入第二个大整数: ");
+    scanf("%s", b);
+    multiply(a, b, result);
+    printf("结果: %s\n", result);
+    return 0;
+}

public/c/ch2/ch2.allpai/allpai.c

@@ -0,0 +1,30 @@
+#include <stdio.h>
+// 交换数组中两个指定位置的元素
+void swap(int arr[], int a, int b) {
+    int temp = arr[a];
+    arr[a] = arr[b];
+    arr[b] = temp;
+}
+
+// 递归生成数组的所有排列
+void permutation(int arr[], int size, int n) {
+    if (n == size) {// 当排列到最后一个元素时，打印当前排列
+        for (int i = 0; i < size; i++) {
+            printf("%d ", arr[i]); // 打印当前排列
+        }
+        printf("\n"); // 换行
+    } else {//将每个元素放在当前位置n，并递归排列剩下的元素
+        for (int i = n; i < size; i++) {
+            swap(arr, i, n); // 交换第i和n个元素，固定第n个位置的元素
+            permutation(arr, size, n + 1); // 递归处理下一个位置
+            swap(arr, i, n); // 恢复原顺序，准备下一个交换
+        }
+    }
+}
+
+int main() {
+    int arr[] = {1,2,3, 4}; // 初始数组
+    int size = sizeof(arr) / sizeof(arr[0]); 
+    permutation(arr, size, 0);
+    return 0;
+}

public/c/ch2/ch2.allpai/allpaichong.c

@@ -0,0 +1,65 @@
+#include <stdio.h>
+#include <stdbool.h>
+
+// 交换数组中两个指定位置的元素
+void swap(int arr[], int a, int b)
+{
+    int temp = arr[a];
+    arr[a] = arr[b];
+    arr[b] = temp;
+}
+
+// 递归生成数组的所有排列，并排除重复的排列
+void permutation(int arr[], int size, int n)
+{
+    if (n == size)
+    {
+        for (int i = 0; i < size; i++)
+        {
+            printf("%d ", arr[i]);
+        }
+        printf("\n");
+    }
+    else
+    {
+        bool used[100] = {false}; // 用于标记重复元素
+        for (int i = n; i < size; i++)
+        {
+            if (!used[arr[i]])
+            {                                  // 检查当前元素是否已经被使用过
+                used[arr[i]] = true;           // 标记当前元素为已使用
+               
+                swap(arr, i, n);               // 交换第i和n个元素，固定第n个位置的元素
+                permutation(arr, size, n + 1); // 递归处理下一个位置
+                swap(arr, i, n);               // 恢复原顺序，准备下一个交换
+            }
+        }
+            
+            // for (int i = 0; i < 10; ++i) {
+            //      printf("used[%d] = %s ", i, used[i] ? "true" : "false");
+            // }
+            //  printf("\n");
+    }
+}
+
+int main()
+{
+    int arr[] = {1, 2, 2, 3}; // 初始数组，包含重复元素
+    int size = sizeof(arr) / sizeof(arr[0]);
+
+    // 排序数组，以确保重复元素在一起
+    // 这样处理后，重复元素会在相邻位置
+    for (int i = 0; i < size - 1; i++)
+    {
+        for (int j = i + 1; j < size; j++)
+        {
+            if (arr[i] > arr[j])
+            {
+                swap(arr, i, j);
+            }
+        }
+    }
+
+    permutation(arr, size, 0);
+    return 0;
+}

public/c/ch2/ch2.allpai/arrpaichong.c

@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <stdbool.h>
+
+#define SIZE 10
+
+int main() {
+    int arr[SIZE] = {2, 5, 3, 5, 1, 2, 6, 7, 8, 9};
+    bool used[SIZE] = {false};  // 用于标记数字是否已被使用
+
+    for (int i = 0; i < SIZE; ++i) {
+        if (!used[arr[i]]) {  // 检查当前值是否已被使用
+            printf("First occurrence of %d\n", arr[i]);
+            used[arr[i]] = true;  // 标记该值为已使用
+        }
+    }
+
+    return 0;
+}

public/c/ch2/digui/printnumber.c

@@ -0,0 +1,24 @@
+#include <stdio.h>
+
+void printNumber2(int n)
+{
+    if (n > 9)
+    {
+        printNumber2(n / 10);
+    }
+    printf("%d", n % 10);
+}
+
+int main()
+{
+    int number = 12345; // Example number
+    printNumber2(number);
+    printf("\n"); // Newline for better output formatting
+
+    char *str = "abcde";
+    printf("%s\n", str); // 输出: abcde
+
+    char arr[] = "abcde";
+    printf("%s\n", arr); // 输出: abcde
+    return 0;
+}

public/c/ch2/digui/tuxing.c

@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+char* getStar(int n) {
+    if (n < 0) {
+        return "*";
+    } else {
+        return getStar(n - 1);
+    }
+}
+
+int main() {
+    int n = 5;
+    printf("%s\n", getStar(n));
+    return 0;
+}

public/c/ch2/halfsearch/fenzhi.c

@@ -0,0 +1,28 @@
+#include <stdio.h>
+
+int binarySearch(int a[], int size, int key) {
+    int left = 0;
+    int right = size - 1;
+    while (left <= right) {
+        int middle = (left + right) / 2;
+        if (key == a[middle])
+            return middle;
+        else if (key > a[middle])
+            left = middle + 1;
+        else
+            right = middle - 1;
+    }
+    return -1;
+}
+
+int main() {
+    int a[] = {1, 3, 5, 7, 9};
+    int size = sizeof(a) / sizeof(a[0]);
+    int key = 7;
+    int index = binarySearch(a, size, key);
+    if (index != -1)
+        printf("元素索引是 %d\n", index);
+    else
+        printf("没有找到\n");
+    return 0;
+}

public/c/ch2/halfsearch/fenzhirec.c

@@ -0,0 +1,26 @@
+#include <stdio.h>
+int RecursionHalfSearch(int a[], int left, int right, int key) {
+    if (left <= right) {
+        int middle = (left + right) / 2;
+        if (key == a[middle])
+            return middle;
+        else if (key > a[middle])
+            return RecursionHalfSearch(a, middle + 1, right, key);
+        else
+            return RecursionHalfSearch(a, left, middle - 1, key);
+    } else {
+        return -1;
+    }
+}
+
+int main() {
+    int a[] = {1, 3, 5, 7, 9};
+    int size = sizeof(a) / sizeof(a[0]);
+    int key = 7;
+    int index = RecursionHalfSearch(a, 0, size - 1, key);
+    if (index != -1)
+        printf("Element found at index %d\n", index);
+    else
+        printf("Element not found\n");
+    return 0;
+}

public/c/ch2/juzhen/juzhennew.c

@@ -0,0 +1,150 @@
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+#define SIZE 4 // 矩阵的大小
+
+// 检查一个数是否是2的幂次方
+bool isPowerOfTwo(int num) {
+    return (num & (num - 1)) == 0;
+}
+
+// 矩阵加法
+void add(int* a, int* b, int* c, int length) {
+    for (int i = 0; i < length * length; i++) {
+        c[i] = a[i] + b[i];
+    }
+}
+
+// 获取结果矩阵
+void getResult(int* a, int* b, int* result) {
+    int p1 = a[0] * (b[1] - b[3]);
+    int p2 = (a[0] + a[1]) * b[3];
+    int p3 = (a[2] + a[3]) * b[0];
+    int p4 = a[3] * (b[2] - b[0]);
+    int p5 = (a[0] + a[3]) * (b[0] + b[3]);
+    int p6 = (a[1] - a[3]) * (b[2] + b[3]);
+    int p7 = (a[0] - a[2]) * (b[0] + b[1]);
+
+    result[0] = p5 + p4 - p2 + p6;
+    result[1] = p1 + p2;
+    result[2] = p3 + p4;
+    result[3] = p5 + p1 - p3 - p7;
+}
+
+// Strassen 矩阵乘法
+void sMM(int* a, int* b, int* result, int length) {
+    if (length == 2) {
+        getResult(a, b, result);
+    } else {
+        int tlength = length / 2;
+        int* aa = (int*)malloc(tlength * tlength * sizeof(int));
+        int* ab = (int*)malloc(tlength * tlength * sizeof(int));
+        int* ac = (int*)malloc(tlength * tlength * sizeof(int));
+        int* ad = (int*)malloc(tlength * tlength * sizeof(int));
+        int* ba = (int*)malloc(tlength * tlength * sizeof(int));
+        int* bb = (int*)malloc(tlength * tlength * sizeof(int));
+        int* bc = (int*)malloc(tlength * tlength * sizeof(int));
+        int* bd = (int*)malloc(tlength * tlength * sizeof(int));
+        int* t1 = (int*)malloc(tlength * tlength * sizeof(int));
+        int* t2 = (int*)malloc(tlength * tlength * sizeof(int));
+        int* t3 = (int*)malloc(tlength * tlength * sizeof(int));
+        int* t4 = (int*)malloc(tlength * tlength * sizeof(int));
+        int* temp = (int*)malloc(length * length * sizeof(int));
+
+        for (int i = 0; i < length; i++) {
+            for (int j = 0; j < length; j++) {
+                if (i < tlength) {
+                    if (j < tlength) {
+                        aa[i * tlength + j] = a[i * length + j];
+                        ba[i * tlength + j] = b[i * length + j];
+                    } else {
+                        ab[i * tlength + (j - tlength)] = a[i * length + j];
+                        bb[i * tlength + (j - tlength)] = b[i * length + j];
+                    }
+                } else {
+                    if (j < tlength) {
+                        ac[(i - tlength) * tlength + j] = a[i * length + j];
+                        bc[(i - tlength) * tlength + j] = b[i * length + j];
+                    } else {
+                        ad[(i - tlength) * tlength + (j - tlength)] = a[i * length + j];
+                        bd[(i - tlength) * tlength + (j - tlength)] = b[i * length + j];
+                    }
+                }
+            }
+        }
+
+        int* t1_ = (int*)malloc(tlength * tlength * sizeof(int));
+        int* t2_ = (int*)malloc(tlength * tlength * sizeof(int));
+        int* t3_ = (int*)malloc(tlength * tlength * sizeof(int));
+        int* t4_ = (int*)malloc(tlength * tlength * sizeof(int));
+        
+        sMM(aa, ba, t1_, tlength);
+        sMM(ab, bc, t2_, tlength);
+        add(t1_, t2_, t1_, tlength);
+        
+        sMM(aa, bb, t2_, tlength);
+        sMM(ab, bd, t3_, tlength);
+        add(t2_, t3_, t2_, tlength);
+        
+        sMM(ac, ba, t3_, tlength);
+        sMM(ad, bc, t4_, tlength);
+        add(t3_, t4_, t3_, tlength);
+        
+        sMM(ac, bb, t4_, tlength);
+        sMM(ad, bd, t1_, tlength);
+        add(t4_, t1_, t4_, tlength);
+        
+        for (int i = 0; i < length; i++) {
+            for (int j = 0; j < length; j++) {
+                if (i < tlength) {
+                    if (j < tlength)
+                        result[i * length + j] = t1[i * tlength + j];
+                    else
+                        result[i * length + j] = t2[i * tlength + (j - tlength)];
+                } else {
+                    if (j < tlength)
+                        result[i * length + j] = t3[(i - tlength) * tlength + j];
+                    else
+                        result[i * length + j] = t4[(i - tlength) * tlength + (j - tlength)];
+                }
+            }
+        }
+
+        free(aa);
+        free(ab);
+        free(ac);
+        free(ad);
+        free(ba);
+        free(bb);
+        free(bc);
+        free(bd);
+        free(t1_);
+        free(t2_);
+        free(t3_);
+        free(t4_);
+        free(temp);
+    }
+}
+
+int main() {
+    int a[SIZE * SIZE] = { 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4 };
+    int b[SIZE * SIZE] = { 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4 };
+    int c[SIZE * SIZE];
+    
+    sMM(a, b, c, SIZE);
+    
+    for (int i = 0; i < SIZE * SIZE; i++) {
+        printf("%d ", c[i]);
+        if ((i + 1) % SIZE == 0) // 换行
+            printf("\n");
+    }
+    
+    printf("%d\n", isPowerOfTwo(1));
+    printf("%d\n", isPowerOfTwo(2));
+    printf("%d\n", isPowerOfTwo(4));
+    printf("%d\n", isPowerOfTwo(6));
+    printf("%d\n", isPowerOfTwo(443));
+
+    return 0;
+}

public/c/ch2/juzhen/juzhenold.c

@@ -0,0 +1,27 @@
+#include <stdio.h>
+#define SIZE 3 // 矩阵的大小
+int main() {
+    // 初始化矩阵
+    int matrix1[SIZE][SIZE] = { { 1, 2, 3 }, { 3, 4, 5 }, { 3, 4, 5 } };
+    int matrix2[SIZE][SIZE] = { { 4, 5, 6 }, { 6, 7, 8 }, { 6, 7, 8 } };
+    int result[SIZE][SIZE] = { { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } };
+    int n = SIZE;    int count = 0;
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < n; j++) {
+            result[i][j] = 0;
+            for (int k = 0; k < n; k++) {
+                result[i][j] += matrix1[i][k] * matrix2[k][j];
+                count++;
+            }
+        }
+    }
+    // 输出结果
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < n; j++) {
+            printf("%d ", result[i][j]);
+        }
+        printf("\n");
+    }
+    printf("N: %d, count: %d\n", n, count);
+    return 0;
+}

public/c/ch2/maopao/mp.c

@@ -0,0 +1,36 @@
+#include <stdio.h>
+void printArray(int arr[], int size); // 函数声明
+void bubbleSort(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]) {
+                // 交换 arr[j] 和 arr[j + 1]
+                int temp = arr[j];
+                arr[j] = arr[j + 1];
+                arr[j + 1] = temp; 
+                printArray(arr, n);
+            }
+        }
+    }
+}
+
+void printArray(int arr[], int size) {
+    for (int i = 0; i < size; i++) {
+        printf("%d ", arr[i]);
+    }
+    printf("\n");
+}
+
+int main() {
+    int arr[] = {4, 2, 3, 1};
+    int n = sizeof(arr) / sizeof(arr[0]);
+
+    printf("原始数组: ");
+    printArray(arr, n);
+
+    bubbleSort(arr, n);
+
+    printf("排序后的数组: ");
+    printArray(arr, n);
+    return 0;
+}

public/c/ch2/matrix/macheng.c

@@ -0,0 +1,94 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#define N 2 // 矩阵大小
+
+void matrix_multiply(int A[][N], int B[][N], int C[][N])
+{
+    int i, j, k;
+    if (N == 1) {
+        C[0][0] = A[0][0] * B[0][0];
+        return;
+    }  else  {
+        int A11[N / 2][N / 2], A12[N / 2][N / 2], A21[N / 2][N / 2], A22[N / 2][N / 2];
+        int B11[N / 2][N / 2], B12[N / 2][N / 2], B21[N / 2][N / 2], B22[N / 2][N / 2];
+        int C11[N / 2][N / 2], C12[N / 2][N / 2], C21[N / 2][N / 2], C22[N / 2][N / 2];
+        int P[N / 2][N / 2], Q[N / 2][N / 2], R[N / 2][N / 2], S[N / 2][N / 2], 
+                 T[N / 2][N / 2], U[N / 2][N / 2], V[N / 2][N / 2];
+        // 将矩阵分成4个小矩阵
+        for (i = 0; i < N / 2; i++)   {
+            for (j = 0; j < N / 2; j++)     {
+                A11[i][j] = A[i][j];
+                A12[i][j] = A[i][j + N / 2];
+                A21[i][j] = A[i + N / 2][j];
+                A22[i][j] = A[i + N / 2][j + N / 2];
+                B11[i][j] = B[i][j];
+                B12[i][j] = B[i][j + N / 2];
+                B21[i][j] = B[i + N / 2][j];
+                B22[i][j] = B[i + N / 2][j + N / 2];
+            }
+        }
+        // 求7个小矩阵
+        matrix_multiply(A11, B11, P);
+        matrix_multiply(A12, B21, Q);
+        matrix_multiply(A11, B12, R);
+        matrix_multiply(A12, B22, S);
+        matrix_multiply(A21, B11, T);
+        matrix_multiply(A22, B21, U);
+        matrix_multiply(A21, B12, V);
+
+        // 根据公式计算四个子矩阵
+        for (i = 0; i < N / 2; i++)        {
+            for (j = 0; j < N / 2; j++)          {
+                C11[i][j] = P[i][j] + Q[i][j];
+                C12[i][j] = R[i][j] + S[i][j];
+                C21[i][j] = T[i][j] + U[i][j];
+                C22[i][j] = V[i][j] + P[i][j] - R[i][j] + T[i][j];
+            }
+        }
+        // 将四个子矩阵合并成一个大矩阵
+        for (i = 0; i < N / 2; i++)        {
+            for (j = 0; j < N / 2; j++)           {
+                C[i][j] = C11[i][j];
+                C[i][j + N / 2] = C12[i][j];
+                C[i + N / 2][j] = C21[i][j];
+                C[i + N / 2][j + N / 2] = C22[i][j];
+            }
+        }
+    }
+}
+
+int main()
+{
+    int A[N][N] = {{1, 2}, {3, 4}};
+    int B[N][N] = {{5, 6}, {7, 8}};
+    int C[N][N];
+    int i, j;
+
+    matrix_multiply(A, B, C);
+
+    printf("矩阵A:\n");
+    for (i = 0; i < N; i++)    {
+        for (j = 0; j < N; j++)        {
+            printf("%d ", A[i][j]);
+        }
+        printf("\n");
+    }
+
+    printf("矩阵B:\n");
+    for (i = 0; i < N; i++)    {
+        for (j = 0; j < N; j++)        {
+            printf("%d ", B[i][j]);
+        }
+        printf("\n");
+    }
+
+    printf("矩阵C:\n");
+    for (i = 0; i < N; i++)    {
+        for (j = 0; j < N; j++)        {
+            printf("%d ", C[i][j]);
+        }
+        printf("\n");
+    }
+    return 0;
+}

public/c/ch2/mergesort/guibing.c

@@ -0,0 +1,57 @@
+#include <stdio.h>
+ 
+// 归并函数
+void merge(int arr[], int left, int middle, int right, int temp[]) {
+    int i = left;  // 左数组起始索引
+    int j = middle + 1; // 右数组起始索引
+    int k = left; // 合并后数组起始索引 
+    // 将数据复制到临时数组
+    for (int m = left; m <= right; ++m)  
+        temp[m] = arr[m]; 
+    // 合并临时数组到 arr[left..right]
+    while (i <= middle && j <= right) {
+        if (temp[i] <= temp[j]) 
+            arr[k++] = temp[i++];
+          else 
+            arr[k++] = temp[j++]; 
+    } 
+    // 拷贝剩余元素（如果有）
+    while (i <= middle)  
+        arr[k++] = temp[i++]; 
+}
+
+// 归并排序函数
+void mergeSort(int arr[], int left, int right, int temp[]) {
+    if (left < right) {
+        int middle = left + (right - left) / 2;
+        mergeSort(arr, left, middle, temp); // 排序左半部分
+        mergeSort(arr, middle + 1, right, temp); // 排序右半部分
+        merge(arr, left, middle, right, temp); // 合并两个已排序的部分
+    }
+}
+
+// 打印数组
+void printArray(int arr[], int size) {
+    for (int i = 0; i < size; i++) {
+        printf("%d ", arr[i]);
+    }
+    printf("\n");
+}
+
+int main() {
+    int arr[] = {8, 7, 6, 15, 4, 3, 2, 10};
+    int arrSize = sizeof(arr) / sizeof(arr[0]);
+
+    // 定义临时数组
+    int temp[arrSize];
+
+    printf("原始数组: ");
+    printArray(arr, arrSize);
+
+    mergeSort(arr, 0, arrSize - 1, temp);
+
+    printf("排序后的数组: ");
+    printArray(arr, arrSize);
+
+    return 0;
+}

public/c/ch2/mergesort/merge.c

@@ -0,0 +1,64 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+// 函数声明
+void merge(int arr[], int left, int middle, int right);
+void mergeSort(int arr[], int left, int right);
+void printArray(int arr[], int size);
+// 归并函数
+void merge(int arr[], int left, int middle, int right) {
+    int i, j, k;
+    int n1 = middle - left + 1;
+    int n2 = right - middle;
+    // 创建临时数组
+    int *L = (int *)malloc(n1 * sizeof(int));
+    int *R = (int *)malloc(n2 * sizeof(int));
+    // 拷贝数据到临时数组 L[] 和 R[]
+    for (i = 0; i < n1; i++)        L[i] = arr[left + i];
+    for (j = 0; j < n2; j++)        R[j] = arr[middle + 1 + j];
+    // 合并临时数组
+    i = 0; // 初始索引 L
+    j = 0; // 初始索引 R
+    k = left; // 初始索引合并数组
+    while (i < n1 && j < n2) {
+        if (L[i] <= R[j]) { arr[k] = L[i];  i++;
+        } else {            arr[k] = R[j];  j++;   }
+        k++;
+    }
+    while (i < n1) {// 拷贝 L[] 的剩余元素
+        arr[k] = L[i];        i++;        k++;
+    }   
+    while (j < n2) { // 拷贝 R[] 的剩余元素
+        arr[k] = R[j];        j++;        k++;
+    }   
+    free(L);    free(R); // 释放临时数组内存
+}
+// 归并排序函数
+void mergeSort(int arr[], int left, int right) {
+    if (left < right) {
+        //int middle = left + (right - left) / 2;       
+        int middle = (left+right)/2;
+        mergeSort(arr, left, middle); // 递归调用归并排序
+        mergeSort(arr, middle + 1, right);     
+        merge(arr, left, middle, right);   // 合并排序后的子数组
+    }
+}
+// 打印数组
+void printArray(int arr[], int size) {
+    for (int i = 0; i < size; i++) {  printf("%d ", arr[i]); }
+    printf("\n");
+}
+int main() {
+    int arr[] = {8, 7, 6, 15, 4, 3, 2, 10};
+    int arrSize = sizeof(arr) / sizeof(arr[0]);
+
+    printf("原始数组: ");
+    printArray(arr, arrSize);
+
+    mergeSort(arr, 0, arrSize - 1);
+
+    printf("排序后的数组: ");
+    printArray(arr, arrSize);
+    return 0;
+}
+

public/c/ch2/quicksort/danleft.c

@@ -0,0 +1,42 @@
+#include <stdio.h>
+
+void quickSort(int arr[], int low, int high);
+int getIndex(int arr[], int low, int high);
+
+void quickSort(int arr[], int low, int high) {
+    if (low < high) {
+        int index = getIndex(arr, low, high); // 找寻基准数据的正确索引
+        quickSort(arr, low, index - 1); // 对左半段排序
+        quickSort(arr, index + 1, high); // 对右半段排序
+    }
+}
+
+int getIndex(int arr[], int low, int high) {
+    int tmp = arr[low]; // 基准数据
+    while (low < high) {
+        // 从左向右找到第一个大于基准的数据
+        while (low < high && arr[low] <= tmp) {
+            low++;
+        }
+        arr[high] = arr[low]; // 将大于基准的数据移到右侧
+
+        // 从右向左找到第一个小于基准的数据
+        while (low < high && arr[high] >= tmp) {
+            high--;
+        }
+        arr[low] = arr[high]; // 将小于基准的数据移到左侧
+    }
+    arr[low] = tmp; // 将基准数据放到正确位置
+    return low; // 返回基准数据的索引
+}
+
+int main() {
+    int arr[] = { 1, 5, 8, 2, 0, -1, 6 };
+    int n = sizeof(arr) / sizeof(arr[0]);
+    quickSort(arr, 0, n - 1);    
+    printf("排序后: ");
+    for (int i = 0; i < n; i++)   
+         printf("%d ", arr[i]);  
+    printf("\n");
+    return 0;
+}

public/c/ch2/quicksort/danppt.c

@@ -0,0 +1,39 @@
+#include <stdio.h>
+void quickSort(int arr[], int low, int high);
+int getIndex(int arr[], int low, int high);
+void quickSort(int arr[], int low, int high) {
+    if (low < high) {
+        int index = getIndex(arr, low, high); // 找寻基准数据的正确索引
+        quickSort(arr, low, index - 1); // 对左半段排序
+        quickSort(arr, index + 1, high); // 对右半段排序
+    }
+}
+int getIndex(int arr[], int low, int high) {
+    int pivot = arr[low]; // 基准数据
+    int mark = low + 1; // mark 指针，从基准的下一个位置开始
+    for (int i = mark; i <= high; i++) {
+        if (arr[i] < pivot) { // 如果当前元素小于基准元素
+            // 交换 arr[i] 和 arr[mark] 的值
+            int temp = arr[i];
+            arr[i] = arr[mark];
+            arr[mark] = temp;
+            mark++; // mark 指针右移
+        }
+    }
+    // 最后将基准元素放到正确的位置
+    arr[low] = arr[mark - 1];
+    arr[mark - 1] = pivot;
+    return mark - 1; // 返回基准数据的索引
+}
+
+int main() {
+    int arr[] = {3, 5, 2, 6, 1, 4,-1,9,0};
+    int n = sizeof(arr) / sizeof(arr[0]);
+    quickSort(arr, 0, n - 1);    
+
+    printf("排序后: ");
+    for (int i = 0; i < n; i++)   
+         printf("%d ", arr[i]);  
+    printf("\n");
+    return 0;
+}

public/c/ch2/quicksort/dantwo.c

@@ -0,0 +1,33 @@
+#include <stdio.h>
+void quickSort(int arr[], int low, int high);
+int getIndex(int arr[], int low, int high);
+void quickSort(int arr[], int low, int high) {
+    if (low < high) {
+        int index = getIndex(arr, low, high); // 找寻基准数据的正确索引
+        quickSort(arr, low, index - 1); // 对左半段排序
+        quickSort(arr, index + 1, high); // 对右半段排序
+    }
+}
+int getIndex(int arr[], int low, int high) {
+    int pivot = arr[low]; // 基准数据
+    while (low < high) {
+        // 从右边找到第一个小于基准的元素
+        while (low < high && arr[high] >= pivot) { high--; }
+        arr[low] = arr[high]; // 将小于基准的数据移到左侧
+        // 从左边找到第一个大于基准的元素
+        while (low < high && arr[low] <= pivot) {  low++; }
+        arr[high] = arr[low]; // 将大于基准的数据移到右侧
+    }
+    arr[low] = pivot; // 将基准数据放到正确位置
+    return low; // 返回基准数据的索引
+}
+int main() {
+    int arr[] = { 3, 5, 2, 6};
+    int n = sizeof(arr) / sizeof(arr[0]);
+    quickSort(arr, 0, n - 1);    
+    printf("排序后: ");
+    for (int i = 0; i < n; i++)   
+         printf("%d ", arr[i]);  
+    printf("\n");
+    return 0;
+}

public/c/ch2/quicksort/shuangbian.c

@@ -0,0 +1,43 @@
+#include <stdio.h>
+void quicksort(int arr[], int low, int high) {
+    if (low < high) {
+        int pivot = arr[low]; // 选择基准元素
+        int left = low + 1;
+        int right = high;
+        while (left <= right) {
+            // 从左侧查找大于基准的元素
+            while (left <= high && arr[left] <= pivot) { left++; }
+            // 从右侧查找小于基准的元素
+            while (right >= low && arr[right] > pivot) {  right--; }
+            // 如果找到需要交换的元素
+            if (left < right) {
+                int temp = arr[left]; arr[left] = arr[right];
+                arr[right] = temp;
+            }
+        }
+        // 将基准元素放到合适的位置
+        arr[low] = arr[right];
+        arr[right] = pivot;
+        // 递归排序基准元素左侧和右侧的子数组
+        quicksort(arr, low, right - 1);
+        quicksort(arr, right + 1, high);
+    }
+}
+
+void printArray(int arr[], int size) {
+    for (int i = 0; i < size; i++) {
+        printf("%d ", arr[i]);
+    }
+    printf("\n");
+}
+
+int main() {
+    int arr[] = {10, 7, 8, 9, 1, 5};
+    int n = sizeof(arr) / sizeof(arr[0]);
+    printf("原始数组: \n");
+    printArray(arr, n);
+    quicksort(arr, 0, n - 1);
+    printf("排序后的数组: \n");
+    printArray(arr, n);
+    return 0;
+}

public/c/ch2/richeng/bisan.c

@@ -0,0 +1,60 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+void table(int k, int **a, int n);
+void printTable(int **array, int n);
+
+void table(int k, int **a, int n) {
+    // 设置日程表第一行
+    for (int i = 0; i < n; i++) {
+        a[i][0] = i + 1;  // 第一列设置为选手序号
+    }
+    // 填充表格
+    for (int s = 0; s < k; s++) {
+        int half = 1 << s; // 2^s
+        for (int t = 0; t < (1 << (k - s - 1)); t++) { // 2^(k-s-1)
+            for (int i = 0; i < half; i++) {
+                for (int j = 0; j < half; j++) {
+                    a[i + half * t][j + half * t] = a[i][j];
+                    a[i + half * t][j + half * t + half] = a[i][j + half];
+                    a[i + half * t + half][j + half * t] = a[i + half][j];
+                    a[i + half * t + half][j + half * t + half] = a[i + half][j + half];
+                }
+            }
+        }
+    }
+}
+
+void printTable(int **array, int n) {
+    // 打印表头
+    printf("选手 | ");
+    for (int j = 1; j < n; j++) {      printf("第%d天 | ", j);    }  
+    printf("\n");
+    // 打印分隔行
+    for (int j = 0; j <= n; j++) {     printf("-----");    }
+    printf("\n");
+    for (int i = 0; i < n; i++) {
+        printf("%2d   | ", array[i][0]);  // 打印选手序号
+        for (int j = 1; j < n; j++) {  printf("%2d    | ", array[i][j]);  }
+        printf("\n");
+    }
+}
+
+int main() {
+    int k = 3;  // 2^3 = 8个运动员
+    int n = 1 << k;  // 计算2^k
+    // 创建二维数组作为日程表
+    int **array = (int **)malloc(n * sizeof(int *));
+    for (int i = 0; i < n; i++) {
+        array[i] = (int *)malloc(n * sizeof(int));
+        for (int j = 0; j < n; j++) {  // 确保初始化
+            array[i][j] = 0;
+        }
+    }    
+    table(k, array, n);// 制作日程表    
+    printTable(array, n);// 输出日程表
+    // 释放动态分配的内存
+    for (int i = 0; i < n; i++) { free(array[i]); }
+    free(array);
+    return 0;
+}

public/c/ch2/shangji/findarrmax.c

@@ -0,0 +1,26 @@
+#include <stdio.h>
+
+// 递归函数来找最大值
+int findMax(int arr[], int size) { 
+    if (size == 1) {
+        return arr[0];
+    } 
+    // 递归查找前 size-1 个元素的最大值，
+    //arr + 1 是指向数组中第二个元素的指针，即 arr[1] 的地址
+    int maxOfRest = findMax(arr + 1, size - 1);
+    
+    // 返回当前第一个元素和递归结果中的较大者
+    return (arr[0] > maxOfRest) ? arr[0] : maxOfRest;
+}
+
+int main() {
+    int arr[] = {3, 5, 2, 8, 6, 7}; // 示例数组
+    int size = sizeof(arr) / sizeof(arr[0]);
+    
+    // 调用递归函数，初始时数组的大小为 size
+    int max = findMax(arr, size);
+    
+    printf("数组中最大的值是：%d\n", max);
+    
+    return 0;
+}

public/c/ch2/shangji/sanjiao.c

@@ -0,0 +1,20 @@
+#include <stdio.h>
+
+// 定义递归打印三角形的函数
+void recursionSanjiao(int n) {
+    // 如果n大于等于0
+    if (n >= 0) {
+        // 打印一行星号
+        for (int i = 0; i < n; i++) {
+            printf("*");
+        }
+        printf("\n"); // 换行
+        recursionSanjiao(n - 1); // 递归调用，n减1
+    }
+}
+
+int main() {
+    int testValue = 5; // 可以改变这个值来测试不同的情况
+    recursionSanjiao(testValue);
+    return 0;
+}

public/c/ch2/student/halfsearch.c

@@ -0,0 +1,40 @@
+#include<stdio.h>
+void Search(int a[],int n,int x,int*i,int*j){
+     int start=0,end=n-1;
+     *i=-1;
+	 *j=-1;
+     while(start<end){
+       	 int mid=start+(end-start)/2;
+	      if(a[mid]==x){
+		    *i=mid;
+		    *j=mid;
+	      }
+	      else if(a[mid]<x){
+	  	       start=mid+1;
+		       *i=mid;
+	      }
+	      else {
+		     end=mid-1;
+	         *j=mid;
+	      }
+     }
+}
+int main(){
+	int a[]={2,4,6,8,9,10,12,13};
+	int x=8;
+	int n=sizeof(a)/sizeof(a[0]);
+	int i,j;
+	 Search(a,n,x,&i,&j);
+	if(i==-1&&j==-1){
+		printf("未找到%d的信息\n",x);
+	}
+	else if(i==j){
+		printf("目标元素%d位于%d\n",x,i);
+	}
+	else{
+		printf("未找到目标元素%d的值\n",x);
+		printf("小于%d的最大元素位置%d\n",x,i);
+		printf("大于%d的最小元素位置%d\n",x,j);
+	} 
+}
+

public/c/ch2/student/halfsearchnew.c

@@ -0,0 +1,49 @@
+#include<stdio.h>
+
+void Search(int a[], int n, int x, int *i, int *j) {
+    int start = 0, end = n - 1;
+    *i = -1;
+    *j = -1;
+
+    while (start <= end) {
+        int mid = start + (end - start) / 2;
+
+        if (a[mid] == x) {
+            *i = mid; // 找到目标元素
+            *j = mid; // 初始化 *j
+            // 向左查找相同元素
+            while (*i > 0 && a[*i - 1] == x) {
+                (*i)--;
+            }
+            // 向右查找相同元素
+            while (*j < n - 1 && a[*j + 1] == x) {
+                (*j)++;
+            }
+            return;
+        } else if (a[mid] < x) {
+            start = mid + 1;
+            *i = mid; // 可能是小于 x 的最大元素
+        } else {
+            end = mid - 1;
+            *j = mid; // 可能是大于 x 的最小元素
+        }
+    }
+}
+
+int main() {
+    int a[] = {2, 4, 6, 8, 9, 10, 12, 13};
+    int x = 7;
+    int n = sizeof(a) / sizeof(a[0]);
+    int i, j;
+
+    Search(a, n, x, &i, &j);
+    if (i == -1 && j == -1) {
+        printf("未找到%d的信息\n", x);
+    } else if (i == j) {
+        printf("目标元素%d位于%d\n", x, i);
+    } else {
+        printf("未找到目标元素%d的值\n", x);
+        printf("小于%d的最大元素位置%d\n", x, i);
+        printf("大于%d的最小元素位置%d\n", x, j);
+    }
+}

public/c/ch2/student/paichongright.c

@@ -0,0 +1,61 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int bijiao(const void* a, const void* b) {
+    return (*(int*)a - *(int*)b);
+}
+
+int used[100];
+
+void dayi(int *arr, int n) {
+    for (int i = 0; i < n; i++) {
+        printf("%d ", arr[i]); // 添加空格以便于阅读
+    }
+    printf("\n");
+}
+
+void pailie(int *arr, int start, int end) {
+    if (start == end) {
+        dayi(arr, end + 1);
+    } else {
+        for (int i = start; i <= end; i++) {
+            // 检查当前元素是否已经使用
+            if (!used[i]) {
+                // 检查前一个元素是否相同且未被使用
+                if (i > start && arr[i] == arr[i - 1] && !used[i - 1]) {
+                    continue; // 跳过重复元素
+                }
+
+                used[i] = 1;
+                // 交换元素
+                int t = arr[start];
+                arr[start] = arr[i];
+                arr[i] = t;
+
+                pailie(arr, start + 1, end);
+
+                // 交换回去
+                t = arr[start];
+                arr[start] = arr[i];
+                arr[i] = t;
+                used[i] = 0;
+            }
+        }
+    }
+}
+
+int main() {
+    int arr[] = {1, 2, 3, 4, 3, 6};
+    int size = sizeof(arr) / sizeof(arr[0]);
+
+    // 排序以方便后续去重
+    qsort(arr, size, sizeof(int), bijiao);
+
+    // 初始化使用标记数组
+    for (int i = 0; i < size; i++) {
+        used[i] = 0;
+    }
+
+    pailie(arr, 0, size - 1);
+    return 0;
+}

public/c/ch2/student/ppp.c

@@ -0,0 +1,42 @@
+
+#include"stdio.h"
+#include"stdlib.h"
+int bijiao(const void* a, const void*b){
+	return (*(int*)a-*(int*)b);
+}
+int used[100];
+void dayi(int *arr,int n){
+	for(int i=0;i<n;i++){
+		printf("%d",arr[i]);
+	}
+	printf("\n");
+}
+void pailie(int *arr,int start,int end){
+	if(start==end){
+		dayi(arr,end+1);
+	}
+	else{
+		for(int i=start;i<=end;i++){
+			if(!used[i]){
+				used[i]=1;
+				int t=arr[start];
+				arr[start]=arr[i];
+				arr[i]=t;
+				pailie(arr,start+1,end);
+				t=arr[start];
+				arr[start]=arr[i];
+				arr[i]=t;
+				used[i]=0;
+			}
+		}
+	}
+}
+int main(){
+	int arr[]={1,2,3,4,3,6};
+	int size=sizeof(arr)/sizeof(arr[0]);
+    qsort(arr,size,sizeof(int),bijiao);
+	for(int i=0;i<size;i++){
+		used[i]=0;
+	}
+	pailie(arr,0,size-1);
+}

public/c/ch2/student/quanpai.c

@@ -0,0 +1,42 @@
+
+#include"stdio.h"
+#include"stdlib.h"
+int bijiao(const void* a, const void*b){
+	return (*(int*)a-*(int*)b);
+}
+int used[100];
+void dayi(int *arr,int n){
+	for(int i=0;i<n;i++){
+		printf("%d",arr[i]);
+	}
+	printf("\n");
+}
+void pailie(int *arr,int start,int end){
+	if(start==end){
+		dayi(arr,end+1);
+	}
+	else{
+		for(int i=start;i<=end;i++){
+			if(!used[i]){
+				used[i]=1;
+				int t=arr[start];
+				arr[start]=arr[i];
+				arr[i]=t;
+				pailie(arr,start+1,end);
+				t=arr[start];
+				arr[start]=arr[i];
+				arr[i]=t;
+				used[i]=0;
+			}
+		}
+	}
+}
+int main(){
+	int arr[]={1,2,3,4,3,6};
+	int size=sizeof(arr)/sizeof(arr[0]);
+    qsort(arr,size,sizeof(int),bijiao);
+	for(int i=0;i<size;i++){
+		used[i]=0;
+	}
+	pailie(arr,0,size-1);
+}

public/c/ch2/student/sanjiao.c

@@ -0,0 +1,22 @@
+#include "stdio.h"
+
+int findMax(int arr[], int a, int size) {
+    if (size == 1) {
+        return arr[a]; // 返回当前元素值
+    }
+    
+    int maxOfRest = findMax(arr, a + 1, size - 1); // 递归调用
+    if (arr[a] > maxOfRest) {
+        return arr[a]; // 返回当前元素值
+    } else {
+        return maxOfRest; // 返回剩余部分的最大值
+    }
+}
+
+int main() {
+    int arr[] = {8, 1, 5, 9};
+    int size = sizeof(arr) / sizeof(arr[0]);
+    int Max = findMax(arr, 0, size); // 获取最大值
+    printf("最大元素是：%d\n", Max);
+    return 0;
+}

public/c/ch3/bag01/bag01.c

@@ -0,0 +1,58 @@
+#include <stdio.h>
+#define ITEM_COUNT 5
+#define CAPACITY 6
+
+int weights[ITEM_COUNT] = { 2, 3, 6, 5, 4 };
+int values[ITEM_COUNT] = { 60, 30, 50, 40, 60 };
+
+// 递推实现
+void bag01Ditui() {
+    int f[CAPACITY + 1] = {0}; // 初始化数组
+    int taken[ITEM_COUNT][CAPACITY + 1] = {0}; // 用于记录物品放置状态
+    for (int i = 0; i < ITEM_COUNT; i++) {
+        int w = weights[i];
+        int v = values[i];
+        for (int j = CAPACITY; j >= w; j--) {
+            if (f[j] < f[j - w] + v) { // 如果放入当前物品后价值更高
+                f[j] = f[j - w] + v;
+                taken[i][j] = 1; // 标记当前物品被放入
+            }
+        }
+    }
+    printf("最大价值为: %d\n", f[CAPACITY]);
+
+    // 打印各物品的放置情况
+    printf("放入背包的物品: ");
+    for (int i = ITEM_COUNT - 1, j = CAPACITY; i >= 0; i--) {
+        if (taken[i][j]) {
+            printf("%d ", i + 1); // 输出物品编号 (1-based index)
+            j -= weights[i]; // 减去相应的重量
+        }
+    }
+    printf("\n");
+}
+
+// 递归实现
+int bagProblem(int i, int j) {
+    if (i < 0) { 
+        return 0; 
+    }
+    int r = 0;
+    // 如果剩余空间大于或等于当前物品的重量
+    if (j >= weights[i]) {
+        // 放入当前物品的价值
+        int r1 = bagProblem(i - 1, j - weights[i]) + values[i]; 
+        // 不放入当前物品的价值
+        int r2 = bagProblem(i - 1, j);
+        r = (r1 > r2) ? r1 : r2;
+    } else {
+        r = bagProblem(i - 1, j); 
+    }
+    return r;
+}
+
+int main() {
+    bag01Ditui();
+    printf("递归方式得到的最大价值为: %d\n", bagProblem(ITEM_COUNT - 1, CAPACITY));
+    return 0;
+}

public/c/ch3/bag01/bagbag.c

@@ -0,0 +1,84 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+#define MAX_N 100
+#define MAX_C 100
+
+// 定义结构体以存储背包问题的相关数据
+typedef struct {
+    int N; // 物体的个数
+    int C; // 背包的容量
+    int weight[MAX_N]; // 每个物体的重量
+    int value[MAX_N]; // 每个物体的价值
+    int DP[MAX_N][MAX_C]; // 动态规划表
+} Bag;
+
+void bag01NoRec(Bag* bag) {
+    // 初始化 DP 表
+    for (int j = 0; j <= bag->C; j++) {
+        bag->DP[0][j] = 0;
+    }
+
+    // 填充 DP 表
+    for (int i = 1; i <= bag->N; i++) {
+        for (int j = 0; j <= bag->C; j++) {
+            if (j >= bag->weight[i]) { // 如果容量为 j 的背包能够放下第 i 个物体
+                bag->DP[i][j] = (bag->DP[i - 1][j - bag->weight[i]] + bag->value[i] > bag->DP[i - 1][j]) ?
+                               (bag->DP[i - 1][j - bag->weight[i]] + bag->value[i]) : bag->DP[i - 1][j];
+            } else {
+                // 物体放不下，仅选择不放该物体
+                bag->DP[i][j] = bag->DP[i - 1][j];
+            }
+        }
+    }
+
+    // 打印 DP 表
+    for (int i = 0; i <= bag->N; i++) {
+        for (int j = 0; j <= bag->C; j++) {
+            printf("%d  ", bag->DP[i][j]);
+        }
+        printf("\n");
+    }
+}
+
+void printResult(Bag* bag, int n, int v) {
+    bool isAdd[MAX_N] = {false};
+    for (int i = n; i >= 1; i--) {
+        if (bag->DP[i][v] == bag->DP[i - 1][v])
+            isAdd[i] = false;
+        else {
+            isAdd[i] = true;
+            v -= bag->weight[i];
+        }
+    }
+    for (int i = 1; i <= n; i++) {
+        printf("%d号 %s; ", i, isAdd[i] ? "放" : "不放");
+    }
+    printf("\n");
+}
+
+// 使用 init2 函数初始化，并测试背包算法
+void init2(Bag* bag) {
+    bag->C = 6;
+    bag->weight[1] = 3;
+    bag->weight[2] = 2;
+    bag->weight[3] = 6;
+    bag->weight[4] = 5;
+    bag->weight[5] = 4;
+    bag->value[1] = 30;
+    bag->value[2] = 60;
+    bag->value[3] = 50;
+    bag->value[4] = 40;
+    bag->value[5] = 60;
+    bag->N = 5;
+
+    bag01NoRec(bag);
+    printResult(bag, bag->N, bag->C);
+}
+
+int main() {
+    Bag bag;
+    init2(&bag);
+    return 0;
+}

public/c/ch3/bag01/bagevery.c

@@ -0,0 +1,40 @@
+#include <stdio.h>
+#define ITEM_COUNT 5
+#define CAPACITY 6
+int weights[ITEM_COUNT + 1] = {0, 2, 3, 6, 5, 4}; // 物品重量，从1开始以匹配索引
+int values[ITEM_COUNT + 1] = {0, 60, 30, 50, 40, 60}; // 物品价值，从1开始以匹配索引
+int DP[ITEM_COUNT + 1][CAPACITY + 1] = {0}; // 动态规划数组
+void bag01Ditui() {
+    for (int i = 1; i <= ITEM_COUNT; i++) {
+        for (int j = 0; j <= CAPACITY; j++) {
+            if (j >= weights[i]) {
+                DP[i][j] = (DP[i - 1][j] > DP[i - 1][j - weights[i]] + values[i]) 
+                           ? DP[i - 1][j] 
+                           : DP[i - 1][j - weights[i]] + values[i];
+            } else {
+                DP[i][j] = DP[i - 1][j];
+            }
+        }
+    }
+}
+void printResult(int n, int v) {
+    int isAdd[ITEM_COUNT + 1] = {0}; // 记录物品放置情况
+    for (int i = n; i >= 1; i--) {
+        if (DP[i][v] == DP[i - 1][v])
+            isAdd[i] = 0; // 不放此物品
+        else {
+            isAdd[i] = 1; // 放此物品
+            v -= weights[i]; // 减去相应的重量
+        }
+    }
+    for (int i = 1; i <= n; i++) {
+        printf(" %d号%s; ", i, isAdd[i] ? "放" : "不放");
+    }
+    printf("\n");
+}
+int main() {
+    bag01Ditui(); // 计算动态规划数组
+    printf("最大价值为: %d\n", DP[ITEM_COUNT][CAPACITY]);
+    printResult(ITEM_COUNT, CAPACITY); // 打印物品放置情况
+    return 0;
+}

public/c/ch3/bag01/yanghui.c

@@ -0,0 +1,43 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+void CreatYH(int n) {
+    // 创建一个n行n列的二维数组
+    int **arr = (int **)malloc(n * sizeof(int *));
+    for (int i = 0; i < n; i++) {
+        arr[i] = (int *)malloc(n * sizeof(int));
+    }
+
+    // 初始化数组元素值
+    for (int i = 0; i < n; i++) {
+        arr[i][0] = 1; // 第一列值
+        arr[i][i] = 1; // 斜边值
+    }
+
+    // 使用杨辉三角的填充规则
+    for (int i = 3; i <= n; i++) {
+        for (int j = 2; j < i; j++) {
+            arr[i - 1][j - 1] = arr[i - 2][j - 1] + arr[i - 2][j - 2]; // 赋值
+        }
+        // C语言不需要裁剪数组，因为定义了最大大小
+    }
+
+    // 输出数组
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j <= i; j++) {
+            printf("%d ", arr[i][j]);
+        }
+        printf("\n");
+    }
+
+    // 释放内存
+    for (int i = 0; i < n; i++) {
+        free(arr[i]); // 释放每一行
+    }
+    free(arr); // 释放数组指针
+}
+
+int main() {
+    CreatYH(5);
+    return 0;
+}

public/c/ch3/bag01/yanghuiarr.c

@@ -0,0 +1,27 @@
+#include <stdio.h>
+#define MAX_SIZE 10 // 定义最大大小，可以根据需要调整
+void creatYH(int n) {
+    int arr[MAX_SIZE][MAX_SIZE] = {0}; // 初始化为 0
+    // 初始化数组元素值
+    for (int i = 0; i < n; i++) {
+        arr[i][0] = 1; // 第一列值
+        arr[i][i] = 1; // 斜边值
+    }
+    // 使用杨辉三角的填充规则
+    for (int i = 2; i < n; i++) { // 从第三行开始填充
+        for (int j = 1; j < i; j++) {
+            arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j]; // 赋值
+        }
+    }
+    // 输出数组
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j <= i; j++) {
+            printf("%d ", arr[i][j]);
+        }
+        printf("\n");
+    }
+}
+int main() {
+    creatYH(5); // 调用函数打印杨辉三角的前5行
+    return 0;
+}

public/c/ch3/homework/lesscoin.c

@@ -0,0 +1,48 @@
+#include <stdio.h>
+#include <limits.h> // 用于 INT_MAX
+
+#define MAX_AMOUNT 100 // 定义最大金额
+
+// 函数原型
+int coinChange(int coins[], int numCoins, int amount);
+
+int main() {
+    int coins[] = {1, 2, 5};  // 硬币面额数组
+    int amount = 29;          // 目标金额
+    int numCoins = sizeof(coins) / sizeof(coins[0]); // 硬币数量
+
+    int result = coinChange(coins, numCoins, amount);
+    if (result != -1) {
+        printf("组成金额 %d 所需的最少硬币数为: %d\n", amount, result);
+    } else {
+        printf("无法组成金额 %d。\n", amount);
+    }
+
+    return 0;
+}
+
+int coinChange(int coins[], int numCoins, int amount) {
+    // 创建一个固定大小的数组来存储最少硬币数
+    int dp[MAX_AMOUNT + 1];
+
+    // 初始化 dp 数组
+    for (int i = 0; i <= MAX_AMOUNT; i++) {
+        dp[i] = INT_MAX; // 将每个值初始化为无穷大
+    }
+    dp[0] = 0; // 组成金额 0 所需的硬币数为 0
+
+    // 填充 dp 数组
+    for (int i = 1; i <= MAX_AMOUNT; i++) {
+        for (int j = 0; j < numCoins; j++) {
+            if (coins[j] <= i) {
+                // 更新 dp[i] 的值
+                if (dp[i - coins[j]] != INT_MAX) {
+                    dp[i] = (dp[i] < dp[i - coins[j]] + 1) ? dp[i] : (dp[i - coins[j]] + 1);
+                }
+            }
+        }
+    }
+
+    // 返回结果
+    return (amount <= MAX_AMOUNT && dp[amount] != INT_MAX) ? dp[amount] : -1;
+}

public/c/ch3/image/get2Len.c

@@ -0,0 +1,30 @@
+#include <stdio.h>
+#include <math.h>
+int binaryLength1(int i) {
+    if (i == 0) return 1; 
+    int k = 1;
+    i = i / 2;
+    while (i > 0) {
+        k++;
+        i = i / 2;
+    }
+    return k;
+}
+int binaryLength2(int n) {
+    if (n == 0) return 1; 
+    return (int)(log2(n)) + 1; 
+}
+int binaryLength3(int n) {
+    if (n == 0) return 1; 
+    int length = 0;
+    while (n > 0) {
+        n >>= 1; // 右移一位，相当于除以2
+        length++;
+    }
+    return length;
+}
+int main(){
+    printf("%d\n",binaryLength1(8));
+    printf("%d\n",binaryLength2(8));
+    printf("%d\n",binaryLength3(8));
+}

public/c/ch3/image/imgcompress.c

@@ -0,0 +1,95 @@
+#include <stdio.h>
+#include <math.h>
+
+#define N 9  // 定义数组大小为9
+
+// 计算一个整数在二进制中需要的位数
+int length(int i) {   
+    int k = 1;  // 初始化位数计数器
+    i = i / 2;  // 将整数除以2，开始计算
+    while (i > 0) {  // 当i大于0时继续
+        k++;  // 每次循环位数增加1
+        i = i / 2;  // 继续除以2
+    }  
+    return k;  // 返回计算得到的位数
+}
+ 
+void Compress(int n, int p[], int s[], int l[], int b[]) {  
+    int Lmax = 256, header = 11;  // 定义最大段数和头部长度
+    s[0] = 0;  // 初始化s数组  
+    for (int i = 0; i <= n; i++) { // 遍历每个元素 
+        b[i] = length(p[i]);  // 计算当前元素的位数
+        int bmax = b[i];  // 记录当前最大位数
+        s[i] = (i > 0 ? s[i - 1] : 0) + bmax + header;  //当前段的最小存储长度
+        l[i] = 1;  // 初始段数为1  
+        for (int j = 2; j <= i + 1 && j <= Lmax; j++) {  // 遍历可能的段数 
+            if (bmax < length(p[i - j + 1])) { // 更新最大位数  
+                bmax = length(p[i - j + 1]);  
+            }  
+            // 判断是否需要更新存储长度
+            if (s[i] > s[i - j] + j * bmax + header) {  
+                s[i] = s[i - j] + j * bmax + header;  // 更新最小存储长度
+                l[i] = j;  // 更新段数
+                b[i] = bmax;  // 更新位数
+            }  
+        }  
+        printf("组 %d: L = %d, B = %d, S = %d\n", i, l[i], b[i], s[i]);
+    }  
+}  
+
+// 追溯函数，恢复最优分段信息
+int TraceBack(int n, int l[], int b[]) {  
+    int i = 0;
+    int temp_l[N], temp_b[N];  // 临时数组存储分段信息
+
+    // 从最后一个元素向前追溯
+    while (n >= 0) {
+        temp_l[i] = l[n];  // 记录段数
+        temp_b[i] = b[n];  // 记录位数
+        n = n - l[n];  // 更新n，向前移动
+        i++;  // 增加索引
+    } 
+
+    // 反转数组，恢复正确顺序
+    for (int j = 0; j < i; j++) {
+        b[j] = temp_b[i - j - 1];  // 反向赋值位数
+        l[j] = temp_l[i - j - 1];  // 反向赋值段数
+    }
+    return i;  // 返回段数
+}
+
+// 输出函数，展示最终结果
+void Out(int m, int min_len, int l[], int b[], int p[]) {
+    printf("最小长度：%d\n", min_len);  // 输出最小存储长度
+    printf("共分成：%d段\n", m);  // 输出段数
+    int index = 0;  // 初始化索引
+    for (int i = 0; i < m; i++) {
+        // 输出每段的信息
+        printf("第%d段含有%d元素. 需要存储位数%d，", i + 1, l[i], b[i]);
+        printf("元素值：");
+        // 输出当前段的元素值
+        for (int j = 0; j < l[i]; j++) {
+            printf("%d ", p[index++]);  // 逐个输出元素
+        }
+        printf("\n");  // 换行
+    }
+}
+
+// 主函数，程序入口
+int main() {  
+    int p[] = {4, 6,5,  7, 129, 138, 1,2,3};  // 输入的灰度序列
+    int s[N] = {0}, l[N] = {0}, b[N] = {0};  // 初始化存储长度、段数和位数的数组
+
+    // 输出输入序列
+    printf("图像的灰度序列为：\n");  
+    for (int i = 0; i < N; i++) {  
+        printf("%d ", p[i]);  
+    }  
+    printf("\n");    
+
+    // 调用压缩函数
+    Compress(N - 1, p, s, l, b);  
+    int m = TraceBack(N - 1, l, b);  // 调用追溯函数获取段数
+    Out(m, s[N - 1], l, b, p);  // 输出结果
+    return 0;  
+}  

public/c/ch3/image/imgcompress0.c

@@ -0,0 +1,107 @@
+#include <stdio.h>
+#include <math.h>
+
+#define N 10  // 定义数组大小为10，包括占位符0
+
+// 计算一个整数在二进制中需要的位数
+int length(int i) {   
+    int k = 1;  // 初始化位数计数器
+    i = i / 2;  // 将整数除以2，开始计算
+    while (i > 0) {  // 当i大于0时继续
+        k++;  // 每次循环位数增加1
+        i = i / 2;  // 继续除以2
+    }  
+    return k;  // 返回计算得到的位数
+}
+
+// 压缩函数，计算最优分段
+void Compress(int n, int p[], int s[], int l[], int b[]) {  
+    int Lmax = 256, header = 11;  // 定义最大段数和头部长度
+    s[0] = 0;  // 初始化s数组
+
+    // 遍历实际数据，不包括第一个元素
+    for (int i = 1; i <= n; i++) {  
+        b[i] = length(p[i]);  // 计算当前元素的位数
+        int bmax = b[i];  // 记录当前最大位数
+        s[i] = (i > 1 ? s[i - 1] : 0) + bmax + header;  // 计算当前段的最小存储长度
+        l[i] = 1;  // 初始段数为1
+        printf("mid==%d\n",s[i]);
+        // 遍历可能的段数
+        for (int j = 2; j <= i && j <= Lmax; j++) {  
+            // 更新最大位数
+            printf("bmax前**=%d",bmax);
+            if (bmax < length(p[i - j + 1])) {  
+                bmax = length(p[i - j + 1]); 
+                printf("bmax后**=%d",bmax);                
+            }  
+            // 判断是否需要更新存储长度
+            printf("\nmid=%d\n",s[i - j] + j * bmax + header);
+            if (s[i] > s[i - j] + j * bmax + header) {  
+
+                s[i] = s[i - j] + j * bmax + header;  // 更新最小存储长度
+                l[i] = j;  // 更新段数
+                b[i] = bmax;  // 更新位数
+                // printf("s[i]=%d,mid=%d\n",s[i],s[i - j] + j * bmax + header);
+            }  
+        } 
+        // 输出当前组的信息
+        printf("组 %d: L = %d, B = %d, S = %d\n", i, l[i], b[i], s[i]);
+    }  
+}  
+
+// 追溯函数，恢复最优分段信息
+int TraceBack(int n, int l[], int b[]) {  
+    int i = 0;
+    int temp_l[N], temp_b[N];  // 临时数组存储分段信息
+
+    // 从最后一个元素向前追溯
+    while (n >= 1) {  // 只从1开始追溯，跳过0
+        temp_l[i] = l[n];  // 记录段数
+        temp_b[i] = b[n];  // 记录位数
+        n = n - l[n];  // 更新n，向前移动
+        i++;  // 增加索引
+    } 
+
+    // 反转数组，恢复正确顺序
+    for (int j = 0; j < i; j++) {
+        b[j] = temp_b[i - j - 1];  // 反向赋值位数
+        l[j] = temp_l[i - j - 1];  // 反向赋值段数
+    }
+    return i;  // 返回段数
+}
+
+// 输出函数，展示最终结果
+void Out(int m, int min_len, int l[], int b[], int p[]) {
+    printf("最小长度：%d\n", min_len);  // 输出最小存储长度
+    printf("共分成：%d段\n", m);  // 输出段数
+    int index = 1;  // 从1开始，跳过0
+    for (int i = 0; i < m; i++) {
+        // 输出每段的信息
+        printf("第%d段含有%d元素. 需要存储位数%d，", i + 1, l[i], b[i]);
+        printf("元素值：");
+        // 输出当前段的元素值
+        for (int j = 0; j < l[i]; j++) {
+            printf("%d ", p[index++]);  // 逐个输出元素，跳过第一个0
+        }
+        printf("\n");  // 换行
+    }
+}
+
+// 主函数，程序入口
+int main() {  
+    int p[] = {0, 4, 6, 5, 7, 129, 138, 1, 2, 3};  // 输入的灰度序列（加了0）
+    int s[N] = {0}, l[N] = {0}, b[N] = {0};  // 初始化存储长度、段数和位数的数组
+
+    // 输出输入序列
+    printf("图像的灰度序列为：\n");  
+    for (int i = 0; i < N; i++) {  
+        printf("%d ", p[i]);  
+    }  
+    printf("\n");    
+
+    // 调用压缩函数
+    Compress(N - 1, p, s, l, b);  
+    int m = TraceBack(N - 1, l, b);  // 调用追溯函数获取段数
+    Out(m, s[N - 1], l, b, p);  // 输出结果
+    return 0;  
+}  

public/c/ch3/lcs/lcs1.c

@@ -0,0 +1,88 @@
+#include <stdio.h>
+#include <string.h> 
+#define MAX 100  
+int getLCS(char* text1, char* text2) {
+    int t1_len = strlen(text1);
+    int t2_len = strlen(text2);
+    int dp[MAX][MAX] = {0}; 
+    for (int i = 1; i <= t1_len; i++) {
+        for (int j = 1; j <= t2_len; j++) {
+            if (text1[i - 1] == text2[j - 1]) {
+                //找到一个 lcs 的元素，继续往前找
+                dp[i][j] = 1 + dp[i - 1][j - 1];
+            } else {//谁能让 lcs 最长，就取谁的值
+                dp[i][j] = (dp[i - 1][j] > dp[i][j - 1])?
+                           dp[i - 1][j] : dp[i][j - 1];
+            }
+        }
+    }
+    return dp[t1_len][t2_len];
+}
+
+void getLCSTable(int dp[MAX][MAX], char* text1, char* text2, char b[MAX][MAX]) {
+    int t1_len = strlen(text1);
+    int t2_len = strlen(text2);    
+    for (int i = 1; i <= t1_len; i++) {
+        for (int j = 1; j <= t2_len; j++) {
+            if (text1[i - 1] == text2[j - 1]) {
+                dp[i][j] = 1 + dp[i - 1][j - 1];
+                b[i][j] = 'X'; // LCS元素，使用 'X' 作为占位符
+            } else if (dp[i - 1][j] >= dp[i][j - 1]) {
+                dp[i][j] = dp[i - 1][j];
+                b[i][j] = '|'; // 取上面的值
+            } else {
+                dp[i][j] = dp[i][j - 1];
+                b[i][j] = '-'; // 取左边的值
+            }
+        }
+    }
+}
+
+void printLCSTable(char b[MAX][MAX], char* t1, char* t2, int l1, int l2) {
+    printf("\t");
+    for (int j = 0; j < l2; j++)  
+        printf("%c\t", t2[j]); 
+    printf("\n"); 
+    for (int i = 0; i <= l1; i++) {
+        printf("%c\t", (i == 0) ? ' ' : t1[i - 1]);
+        for (int j = 0; j <= l2; j++) {
+            if (i == 0 && j == 0) {
+                printf("\t");
+            } else {
+                printf("%c\t", b[i][j]);
+            }
+        }
+        printf("\n");
+    }
+}
+
+void printLCSString(char b[MAX][MAX], char* x, int i, int j) {
+    if (i == 0 || j == 0) return; 
+    if (b[i][j] == 'X') {
+        printLCSString(b, x, i - 1, j - 1);
+        // 打印当前字符
+        printf("%c", x[i - 1]);
+    } else if (b[i][j] == '|') {
+        printLCSString(b, x, i - 1, j);
+    } else {
+        printLCSString(b, x, i, j - 1);
+    }
+}
+
+int main() {
+    char t1[] = "ABCB";
+    char t2[] = "BDCA"; 
+    printf("字符串: %s 和字符串: %s 的 LCS 长度为: %d\n", t1, t2, getLCS(t1, t2));
+    printf("--------------------------------\n"); 
+    int dp[MAX][MAX] = {0};
+    char b[MAX][MAX] = {0};
+    getLCSTable(dp, t1, t2, b);
+    printLCSTable(b, t1, t2, strlen(t1), strlen(t2));
+    printf("-------------------------------\n");
+    
+    printf("LCS 字符串为: ");
+    printLCSString(b, t1, strlen(t1), strlen(t2));
+    printf("\n");
+
+    return 0;
+}

public/c/ch3/lcs/lcs2.c

@@ -0,0 +1,96 @@
+#include <stdio.h>
+#include <string.h>
+ 
+
+// 打印LCS的函数
+void PrintLCS(int path[][100], char *x, int i, int j) {
+    if (i == 0 || j == 0) {
+        return;
+    } 
+    if (path[i][j] == 0) {
+        PrintLCS(path, x, i - 1, j - 1);
+        printf("%c", x[i - 1]);
+    } else if (path[i][j] == 1) {
+        PrintLCS(path, x, i - 1, j);
+    } else {
+        PrintLCS(path, x, i, j - 1);
+    }
+}
+
+// 找到LCS的长度
+int findLCS(int dp[][100], char *A, int n, char *B, int m) {
+    // 初始化dp数组
+    for (int i = 0; i <= n; i++) {
+        for (int j = 0; j <= m; j++) {
+            dp[i][j] = 0; // 数组初始化
+        }
+    }
+    for (int i = 1; i <= n; i++) {
+        for (int j = 1; j <= m; j++) { // 执行状态转移方程
+            if (A[i - 1] == B[j - 1]) {
+                dp[i][j] = dp[i - 1][j - 1] + 1;
+            } else {
+                dp[i][j] = dp[i - 1][j] > dp[i][j - 1] ? dp[i - 1][j] : dp[i][j - 1];
+            }
+        }
+    }
+    return dp[n][m];
+}
+
+int main() {
+    char x[] = "w8xta2px0i1jf4jfn8du8dk1fk2kvchd32";
+    char y[] = "i3xsmdxwuv6a2yt520";
+
+    int m = strlen(x);
+    int n = strlen(y);
+    
+    // 创建二维数组
+    int c[101][101];  // 101用于存储m+1和n+1的值
+    int path[101][101];  // 路径数组
+
+    // 初始化二维数组
+    for (int i = 0; i <= m; i++) {
+        c[i][0] = 0;
+    }
+    for (int i = 0; i <= n; i++) {
+        c[0][i] = 0;
+    }
+
+    // 实现LCS逻辑
+    for (int i = 1; i <= m; i++) {
+        for (int j = 1; j <= n; j++) {
+            if (x[i - 1] == y[j - 1]) {
+                c[i][j] = c[i - 1][j - 1] + 1;
+            } else if (c[i - 1][j] >= c[i][j - 1]) {
+                c[i][j] = c[i - 1][j];
+                path[i][j] = 1;  // 来自上方
+            } else {
+                c[i][j] = c[i][j - 1];
+                path[i][j] = -1; // 来自左侧
+            }
+        }
+    }
+
+    // 输出c数组
+    printf("c:\n");
+    for (int i = 0; i <= m; i++) {
+        for (int j = 0; j <= n; j++) {
+            printf("%d\t", c[i][j]);
+        }
+        printf("\n");
+    }
+
+    // 输出path数组
+    printf("path:\n");
+    for (int i = 0; i <= m; i++) {
+        for (int j = 0; j <= n; j++) {
+            printf("%d\t", path[i][j]);
+        }
+        printf("\n");
+    }
+
+    printf("%s与%s的最长公共子序列为：\n", x, y);
+    PrintLCS(path, x, m, n);
+
+    return 0;
+}

public/c/ch3/lcs/printtable.c

@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <string.h>
+
+#define MAX_LENGTH 30  // 定义一个最大长度常量 
+int main() {
+    char s1[] = "abcdefg";  char s2[] = "cdefgh"; 
+    // 获取字符串的长度
+    int len1 = strlen(s1);   int len2 = strlen(s2); 
+    // 使用固定大小的数组
+    char s1_with_space[MAX_LENGTH];  char s2_with_space[MAX_LENGTH];  
+    // 填充带空格的字符串
+    s1_with_space[0] = ' ';  // 添加空格
+    strcpy(s1_with_space + 1, s1); // 复制原字符串到新字符串
+    s2_with_space[0] = ' ';  // 添加空格
+    strcpy(s2_with_space + 1, s2); // 复制原字符串到新字符串 
+    for (int i = 0; i <= len1; i++) { // 打印矩阵
+        for (int j = 0; j <= len2; j++) {
+            if (i == 0 && j <=len2) {
+                printf("%c\t", s2_with_space[j]); // 打印第二行的字符
+            } else if (j == 0 && i <= len1) {
+                printf("%c\t", s1_with_space[i]); // 打印第一列的字符
+            } else if (i > 0 && j > 0) {// 打印组合字符
+                printf("%c%c\t", s1_with_space[i], s2_with_space[j]); 
+            }
+        }
+        printf("\n"); 
+    } 
+    return 0;
+}

public/c/ch3/matrix/chengJia.c

@@ -0,0 +1,50 @@
+#include <stdio.h>
+#include <time.h>
+
+void doAddition(int iterations);
+void doMultiplication(int iterations);
+
+int main() {
+    const int iterations = 1000000000; // 操作次数
+    const int repetitions = 10; // 重复测试的次数
+    double totalAdditionTime = 0.0;
+    double totalMultiplicationTime = 0.0;
+
+    // 重复测试加法
+    for (int i = 0; i < repetitions; ++i) {
+        clock_t begin = clock();
+        doAddition(iterations);
+        clock_t end = clock();
+        totalAdditionTime += (double)(end - begin) / CLOCKS_PER_SEC;
+    }
+    printf("加法操作平均耗时: %.5f s\n", totalAdditionTime / repetitions);
+
+    // 重复测试乘法
+    for (int i = 0; i < repetitions; ++i) {
+        clock_t begin = clock();
+        doMultiplication(iterations);
+        clock_t end = clock();
+        totalMultiplicationTime += (double)(end - begin) / CLOCKS_PER_SEC;
+    }
+    printf("乘法操作平均耗时: %.5f s\n", totalMultiplicationTime / repetitions);
+
+    return 0;
+}
+
+// 加法函数
+void doAddition(int iterations) {
+    long long result = 0; // 使用 long long 以避免溢出
+    for (int i = 0; i < iterations; ++i) {
+        result += 1; // 简单的加法操作
+    }
+    // printf("Addition result: %lld\n", result); // 可以取消注释以验证结果
+}
+
+// 乘法函数
+void doMultiplication(int iterations) {
+    long long result = 1; // 使用 long long 以避免溢出
+    for (int i = 0; i < iterations; ++i) {
+        result *= 2; // 简单的乘法操作
+    }
+    // printf("Multiplication result: %lld\n", result); // 可以取消注释以验证结果
+}

public/c/ch3/matrix/duijiaoxian.c

@@ -0,0 +1,17 @@
+#include <stdio.h>
+
+void pringDuijiao(int n) {
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < n; j++) {
+            if (i == j || i + j == n - 1)
+                printf("*");
+            printf("    ");
+        }
+        printf("\n");
+    }
+}
+
+int main(){
+    pringDuijiao(9);
+    return 0;
+}

public/c/ch3/matrix/kuohao.c

@@ -0,0 +1,39 @@
+#include <stdio.h>
+
+void trace(int i, int j, int s[][5]) {
+    if (i == j) {
+        printf("A%d", i); 
+    } else {
+        printf("("); 
+        trace(i, s[i][j], s); // 递归输出左边
+        trace(s[i][j] + 1, j, s); // 递归输出右边
+        printf(")");
+    }
+}
+
+int main() {
+    int wei[] = { 2, 3, 4, 5, 6 };
+    int s[5][5] = {
+        {0, 0, 0, 0, 0}, 
+        {0, 0, 1, 2, 2}, 
+        {0, 0, 0, 2, 2}, 
+        {0, 0, 0, 0, 3}, 
+        {0, 0, 0, 0, 0}
+    };
+    
+    // 打印二维数组 s 的特定格式
+    for (int i = 0; i < 5; i++) {
+        for (int j = 0; j < 5; j++) {
+            if (i == j || i + j == 4) // wei.length - 1 = 4
+                printf("%d", s[i][j]); 
+            printf("\t");
+        }
+        printf("\n");
+    }
+    
+    // 打印括号表示法
+    trace(1, 4, s); // wei.length - 1 = 4
+    printf("\n");
+
+    return 0;
+}

public/c/ch3/matrix/matrixmul.c

@@ -0,0 +1,45 @@
+#include <stdio.h>
+#include <limits.h>
+void matrixChain(int p[], int m[][5], int s[][5], int n) {
+    for (int i = 1; i <= n; i++) {
+        m[i][i] = 0; // 初始化对角线
+    }
+    for (int d = 2; d <= n; d++) { // d为链的长度
+        for (int i = 1; i <= n - d + 1; i++) { // i是起始位置
+            int j = i + d - 1; // 结束位置
+            m[i][j] = INT_MAX; // 初始化为无穷大
+            for (int k = i; k < j; k++) {
+                // 计算当前划分的最小值
+                int t = m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j];
+                if (t < m[i][j]) {
+                    m[i][j] = t; // 更新最小值
+                    s[i][j] = k; // 记录划分位置
+                }
+            }
+        }
+    }
+}
+//输出A[i,j]的最优计算次序
+void traceback(int i, int j, int s[][5]) {
+    if (i == j) {
+        printf("A%d", i); // 输出矩阵名
+    } else {
+        printf("(");
+        traceback(i, s[i][j], s); // 递归输出左边
+        traceback(s[i][j] + 1, j, s); // 递归输出右边
+        printf(")");
+    }
+}
+
+int main() {
+    int p[] = {6, 7, 8, 9, 10}; // 矩阵的维数
+    int n = sizeof(p) / sizeof(p[0]) - 1; // 矩阵个数
+    int m[6][5] = {0}; // 存放最优值的数组
+    int s[6][5] = {0}; // 存放分割位置下标的数组
+    matrixChain(p, m, s, n);
+    printf("最优值为： %d\n", m[1][n]); // 输出最优值
+    printf("最优计算次序为： ");
+    traceback(1, n, s); // 输出最优计算次序 
+
+    return 0;
+}

public/c/ch3/matrix/weishu.c

@@ -0,0 +1,26 @@
+#include <stdio.h>
+
+void printAi(int arr[], int i, int length) {
+    if (i < 1 || i >= length) {
+        printf("值不符合要求.\n");
+    } else {
+        printf("矩阵A%d的维数：%d行x%d列\n", 
+              i, arr[i - 1], arr[i]);
+        for (int m = 0; m < arr[i - 1]; m++) {
+            for (int n = 0; n < arr[i]; n++) {
+                printf("0\t");
+            }
+            printf("\n");
+        }
+    }
+}
+
+int main() {
+    int arr[] = {2, 3, 4, 5, 6};
+    int length = sizeof(arr) / sizeof(arr[0]);
+ 
+    // 打印矩阵 A2 的维数
+    printAi(arr, 2, length);
+
+    return 0;
+}

public/c/ch4/bag/tanbag.c

@@ -0,0 +1,42 @@
+#include <stdio.h> 
+#define MAX_CAPACITY 150
+#define MAX_ITEMS 7 
+typedef struct {// 物品结构体，包含重量、价值和性价比
+    int weight;
+    int value;
+    double ratio; // 性价比
+} Item;  
+void sortItems(Item items[], int n) {// 计算性价比并进行排序
+    for (int i = 0; i < n - 1; i++) {
+        for (int j = i + 1; j < n; j++) {
+            if (items[i].ratio < items[j].ratio) {
+                // 交换物品
+                Item temp = items[i];
+                items[i] = items[j];
+                items[j] = temp;
+            }
+        }
+    }
+}
+
+int main() {
+    // 初始化物品
+    Item items[MAX_ITEMS] = {  {35, 10, 0}, {30, 40, 0}, {60, 30, 0},
+        {50, 50, 0}, {40, 35, 0}, {10, 40, 0},  {25, 30, 0} };  
+    for (int i = 0; i < MAX_ITEMS; i++) { // 计算性价比
+        items[i].ratio = (double)items[i].value / items[i].weight;
+    }  
+    sortItems(items, MAX_ITEMS);// 按性价比排序 
+    int capacity = MAX_CAPACITY;
+    int maxValue = 0;  
+    printf("背包装入物品:\n"); // 装入背包
+    for (int i = 0; i < MAX_ITEMS; i++) {
+        if (items[i].weight <= capacity) {
+            printf("重量为：%d的物品被选中了\n", items[i].weight);
+            maxValue += items[i].value;
+            capacity -= items[i].weight;
+        }
+    } 
+    printf("最大价值为：%d\n", maxValue);
+    return 0;
+}

public/c/ch4/bag/tanbagtest.c

@@ -0,0 +1,42 @@
+#include <stdio.h> 
+#define MAX_CAPACITY 15
+#define MAX_ITEMS 5 
+typedef struct {// 物品结构体，包含重量、价值和性价比
+    int weight;
+    int value;
+    double ratio; // 性价比
+} Item;  
+void sortItems(Item items[], int n) {// 计算性价比并进行排序
+    for (int i = 0; i < n - 1; i++) {
+        for (int j = i + 1; j < n; j++) {
+            if (items[i].ratio < items[j].ratio) {
+                // 交换物品
+                Item temp = items[i];
+                items[i] = items[j];
+                items[j] = temp;
+            }
+        }
+    }
+}
+
+int main() {
+    // 初始化物品
+    Item items[MAX_ITEMS] = {  {10, 8, 0}, {2,1, 0}, {5, 6, 0},
+        {5,3, 0}, {7, 7, 0} };  
+    for (int i = 0; i < MAX_ITEMS; i++) { // 计算性价比
+        items[i].ratio = (double)items[i].value / items[i].weight;
+    }  
+    sortItems(items, MAX_ITEMS);// 按性价比排序 
+    int capacity = MAX_CAPACITY;
+    int maxValue = 0;  
+    printf("背包装入物品:\n"); // 装入背包
+    for (int i = 0; i < MAX_ITEMS; i++) {
+        if (items[i].weight <= capacity) {
+            printf("重量为：%d的物品被选中了\n", items[i].weight);
+            maxValue += items[i].value;
+            capacity -= items[i].weight;
+        }
+    } 
+    printf("最大价值为：%d\n", maxValue);
+    return 0;
+}

public/c/ch4/bestload/loading.c

@@ -0,0 +1,47 @@
+#include <stdio.h>
+#include <stdlib.h> 
+typedef struct { float weight;  int index;} Element;  
+int compare(const void *a, const void *b) {
+    const Element *elemA = (const Element *)a;
+    const Element *elemB = (const Element *)b;
+    return (elemA->weight > elemB->weight) - (elemA->weight < elemB->weight);
+}
+// 最优装载函数
+float loading(float capacity, float weights[], int count, int x[]) {
+    Element *elements = malloc(count * sizeof(Element));  
+    for (int i = 0; i < count; i++) {  // 初始化元素
+        elements[i].weight = weights[i];
+        elements[i].index = i;
+    }  
+    qsort(elements, count, sizeof(Element), compare); // 排序元素
+    // 初始化装载情况
+    for (int i = 0; i < count; i++) { x[i] = 0; } 
+    float totalWeight = 0; 
+    // 贪心选择
+    for (int i = 0; i < count && elements[i].weight <= capacity; i++) {
+        totalWeight += elements[i].weight;
+        capacity -= elements[i].weight;
+        x[elements[i].index] = 1; // 标记被装载的集装箱
+    } 
+    free(elements); // 释放动态分配的内存
+    return totalWeight;
+}
+int main() {
+    float weights[] = {20, 30, 26, 15, 30, 40, 35,50,25};
+    float capacity = 100;
+    int count = sizeof(weights) / sizeof(weights[0]);
+    int *x = malloc(count * sizeof(int));
+    
+    float optimalWeight = loading(capacity, weights, count, x);
+    
+    printf("最优得到装载重量为：%.2f\n", optimalWeight);
+    printf("被装载的集装箱序号为(下标从0开始)：");
+    
+    for (int i = 0; i < count; i++) {
+        if (x[i] == 1) {
+            printf("%d ", i);
+        }
+    } 
+    free(x); // 释放动态分配的内存
+    return 0;
+}