add

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;
+}