C语言基础（十四）

指针的使用：

测试代码1：

#include "date.h" 
#include <stdio.h>  
  
// 加法函数  
int add(int a, int b) {  
    return a + b;  
}  
  
// 减法函数  
int subtract(int a, int b) {  
    return a - b;  
}  
  
// 定义一个指向接收两个int参数并返回int的函数  
typedef int (*FuncPtr)(int, int);  
  
// 定义一个函数，接收一个指向函数的指针和两个整数作为参数  
void applyFunction(FuncPtr func, int x, int y) {  
    int result = func(x, y);  
    printf("Result: %d\n", result);  
}  
  
int main() {  
    int time = getTime(); 
    // 调用applyFunction并传递add函数作为参数  
    applyFunction(add, 5, 3); 
    
    // 调用applyFunction并传递subtract函数作为参数  
    applyFunction(subtract, 9, 12); 
    return 0;  
}

运行结果如下：

 

测试代码2：

#include "date.h"
#include <stdio.h>  
#include <string.h>  
int main() {  

    int time = getTime();
    // 声明字符指针并初始化  
    const char *ptr = "Hello, World!";  
  
    // 不能直接修改ptr指向的字符串（因为是字符串常量），  
    char str[50] = "C programming";  
    char *ptr2 = str; // ptr2 现在指向 str  
  
    printf("String pointed by ptr: %s\n", ptr);  
  
    // 使用字符指针和标准库函数  
    strcpy(ptr2, "New programming language");  
    printf("After strcpy: %s\n", ptr2);  
  
    // 通过指针算术访问和修改字符串  
    ptr2[5] = 'S'; // 修改字符  
    printf("Modified string: %s\n", ptr2);  
  
    return 0;  
}

运行结果如下：

 

测试代码3：

#include "date.h" 
#include <stdio.h>  
// 自定义 strcpy 函数  
void my_strcpy(char *dest, const char *src) {  
    // 遍历源字符串，直到遇到空字符  
    while (*src != '\0') {  
        // 将源字符串的当前字符复制到目标字符串  
        *dest = *src;  
        // 移动指针到下一个字符  
        dest++;  
        src++;  
    }  
    // 在目标字符串的末尾添加空字符  
    *dest = '\0';  
}  
  
int main() {  
    int time = getTime();
    char source[] = "Hello, World!";  
    char destination[50]; // 确保目标数组足够大以容纳源字符串  
  
    // 使用自定义的 strcpy 函数复制字符串  
    my_strcpy(destination, source);  
  
    // 输出复制后的字符串  
    printf("Copied string: %s\n", destination);  
  
    return 0;  
}

运行结果如下：

 

测试代码4：

#include "date.h"
#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  

int main() {  
    int time = getTime();
    // 使用字符数组存储字符串  
    char strArray[50] = "Hello, World from an array!";  
  
    // 访问和修改字符数组中的元素  
    printf("Original string in array: %s\n", strArray);  
    strArray[7] = 'C'; // 修改数组中的字符  
    printf("Modified string in array: %s\n", strArray);  
  
    // 使用字符指针和动态内存分配存储可修改的字符串  
    char *dynamicStr = (char *)malloc(50 * sizeof(char)); // 分配内存  
    if (dynamicStr != NULL) {  
        strcpy(dynamicStr, "Hello, World from dynamically allocated memory!");  
        // 访问动态分配的字符串  
        printf("String from dynamic memory: %s\n", dynamicStr);  
  
        // 修改动态分配的字符串  
        dynamicStr[7] = 'E';  
        printf("Modified string from dynamic memory: %s\n", dynamicStr);  
  
        // 释放动态分配的内存  
        free(dynamicStr);  
    } else {  
        // 如果内存分配失败  
        printf("Memory allocation failed!\n");  
    }  
  
    // 不要访问dynamicStr，已经被释放了  
  
    return 0;  
}

运行结果如下：

 

测试代码5：

#include "date.h"
#include <stdio.h>  
// 指针数组特别适用于处理字符串数组、动态数据结构（如链表和树）中的节点指针等场景。 
int main() {  
    int time = getTime();
    // 定义并初始化整型指针数组  
    int a = 10, b = 20, c = 30;  
    int *intArr[3] = {&a, &b, &c};  
  
    // 访问并修改整型指针数组指向的值  
    for(int i = 0; i < 3; i++) {  
        printf("Original %d: %d\n", i, *(intArr[i]));  
        *(intArr[i]) += 10; // 将每个值增加10  
    }  
  
    // 再次访问并打印修改后的值  
    printf("\nModified values:\n");  
    for(int i = 0; i < 3; i++) {  
        printf("%d ", *(intArr[i]));  
    }  
    printf("\n");  
  
    // 定义并初始化字符串指针数组  
    const char *strArr[3] = {"Hello", "World", "!"};  
  
    // 遍历并打印字符串指针数组中的每个字符串  
    printf("\nString array:\n");  
    for(int i = 0; i < 3; i++) {  
        printf("%s ", strArr[i]);  
    }  
    printf("\n");  
  
    return 0;  
}

运行结果如下：

 

测试代码6：

#include "date.h"
#include <stdio.h>
#include <string.h>

// 快速排序的分区函数
int partition(const char *arr[], int low, int high) {
    const char *pivot = arr[high]; // 选择最后一个元素作为基准
    int i = low - 1; // 较小元素的索引

    for (int j = low; j <= high - 1; j++) {
        // 如果当前元素小于或等于pivot
        if (strcmp(arr[j], pivot) >= 0) {
            i++; // 移动较小元素的索引
            // 交换arr[i]和arr[j]
            const char *temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    // 交换arr[i+1]和arr[high]（或pivot）
    const char *temp = arr[i + 1];
    arr[i + 1] = arr[high];
    arr[high] = temp;

    return (i + 1);
}

// 快速排序函数
void quickSort(const char *arr[], int low, int high) {
    if (low < high) {
        // pi是分区后基准的索引
        int pi = partition(arr, low, high);

        // 分别对基准前后的子数组进行排序
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

// 查找并返回最小字符串的索引（不需要，因为数组已排序）
int findMinStringIndex(const char *arr[], int n) {
    return 0; // 排序后，最小字符串在索引0处
}

int main() {
	int time = getTime();
    // 初始化字符串指针数组
    const char *strings[] = {"banana", "apple", "cherry", "date"};
    int n = sizeof(strings) / sizeof(strings[0]);

    // 排序字符串
    quickSort(strings, 0, n - 1);

    // 打印排序后的字符串
    printf("Sorted strings (from largest to smallest):\n");
    for (int i = 0; i < n; i++) {
        printf("%s\n", strings[i]);
    }

    // 由于已经排序，所以最小字符串就是第一个
    printf("The smallest string is: %s\n", strings[0]);

    return 0;
}

运行结果如下：