C语言实例

最新推荐文章于 2023-09-01 11:36:36 发布

宇希啊

最新推荐文章于 2023-09-01 11:36:36 发布

阅读量921

点赞数 3

文章标签： c语言算法 c++

本文链接：https://blog.csdn.net/qq_41410794/article/details/131213184

版权

1. 指针与数组:

知识点:
指针是存储内存地址的变量，而数组是一系列相同类型的数据元素的集合。指针与数组之间存在着紧密的关系，可以使用指针对数组进行操作。

习题实例:
编写一个函数，接受一个整数数组和数组的长度作为参数，计算并返回数组中的最大值。

解析:
可以使用指针遍历数组元素，比较每个元素的大小，找到最大值并返回。

#include <stdio.h>

int findMax(int* arr, int length) {
    int max = *arr;

    for (int i = 1; i < length; i++) {
        if (*(arr + i) > max) {
            max = *(arr + i);
        }
    }

    return max;
}

int main() {
    int arr[] = {2, 9, 7, 5, 4};
    int length = sizeof(arr) / sizeof(arr[0]);

    int max = findMax(arr, length);

    printf("The maximum value is: %d\n", max);

    return 0;
}

代码解析:

int findMax(int* arr, int length): 这是一个函数定义，接受一个整数数组和数组的长度作为参数，并返回最大值。
int max = *arr;: 初始化最大值为数组的第一个元素的值。
for (int i = 1; i < length; i++): 使用循环遍历数组的其他元素。
if (*(arr + i) > max): 使用指针访问数组元素，比较当前元素和最大值的大小。
max = *(arr + i);: 如果当前元素大于最大值，更新最大值。
return max;: 返回最大值。
在 main() 函数中，定义了一个整数数组 arr，计算数组的长度并传递给 findMax 函数，然后打印最大值。

总结:
指针与数组之间有着紧密的关系，可以使用指针对数组进行遍历和操作。理解指针与数组的概念以及它们之间的关系对于C语言编程非常重要。

2. 指针与动态内存分配:

知识点:
指针与动态内存分配是C语言中重要的概念，动态内存分配允许在程序运行时申请和释放内存空间。

习题实例:
编写一个程序，动态分配一个整数数组，并通过指针对数组元素进行操作。

解析:
可以使用malloc函数动态分配内存空间，然后使用指针对分配的数组进行访问和操作。

#include <stdio.h>
#include <stdlib.h>

int main() {
    int length;
    printf("Enter the length of the array: ");
    scanf("%d", &length);

    // 动态分配内存空间
    int* arr = (int*)malloc(length * sizeof(int));

    if (arr == NULL) {
        printf("Failed to allocate memory.\n");
        return 0;
    }

    // 初始化数组元素
    for (int i = 0; i < length; i++) {
        arr[i] = i + 1;
    }

    // 打印数组元素
    for (int i = 0; i < length; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    // 释放内存空间
    free(arr);

    return 0;
}

代码解析:

int* arr = (int*)malloc(length * sizeof(int));: 使用malloc函数动态分配长度为length的整数数组，并将返回的指针赋值给arr。
if (arr == NULL): 检查内存分配是否成功，如果指针为NULL，则说明内存分配失败。
for (int i = 0; i < length; i++): 使用循环对数组元素进行初始化和打印操作。
free(arr);: 使用free函数释放动态分配的内存空间。

总结:
指针与动态内存分配是C语言中重要的概念，可以使用malloc函数动态分配内存空间，并通过指针对动态分配的内存进行访问和操作。理解指针与动态内存分配的概念对于管理和优化内存的使用非常重要。

3. 指针和函数:

知识点:
指针和函数是C语言中常用的概念，指针可以作为函数参数传递，从而实现对变量的间接操作。

习题实例:
编写一个函数，接受两个整数作为参数，并通过指针返回两个数的和与差。

解析:
可以定义一个函数，将两个整数作为指针参数传递给函数，在函数内部通过指针修改传入的变量值。

#include <stdio.h>

void sumAndDifference(int num1, int num2, int* sum, int* difference) {
    *sum = num1 + num2;
    *difference = num1 - num2;
}

int main() {
    int num1, num2;
    printf("Enter two numbers: ");
    scanf("%d %d", &num1, &num2);

    int sum, difference;
    sumAndDifference(num1, num2, &sum, &difference);

    printf("Sum: %d\n", sum);
    printf("Difference: %d\n", difference);

    return 0;
}

代码解析:

void sumAndDifference(int num1, int num2, int* sum, int* difference): 这是一个函数定义，接受两个整数和两个指针作为参数，并通过指针返回计算的和与差。
*sum = num1 + num2;: 通过指针修改 sum 指向的变量的值，计算两个数的和并赋值给 sum。
*difference = num1 - num2;: 通过指针修改 difference 指向的变量的值，计算两个数的差并赋值给 difference。
在 main() 函数中，接受用户输入的两个数，定义 sum 和 difference 变量，并将它们的地址传递给 sumAndDifference 函数。然后打印计算得到的和与差。

总结:
指针和函数是C语言中常用的概念，可以通过指针参数实现对变量的间接操作。理解指针和函数的关系对于编写复杂的程序和实现高效的数据传递非常重要。

4. 指针和字符串:

知识点:
指针和字符串是C语言中常见的概念，字符串实际上是以null字符结尾的字符数组，可以使用指针对字符串进行访问和操作。

习题实例:
编写一个函数，接受一个字符串作为参数，并统计并返回字符串中的单词个数。

解析:
可以使用指针遍历字符串，根据单词的定义进行判断和计数。

#include <stdio.h>

int countWords(char* str) {
    int count = 0;
    int isWord = 0;

    while (*str != '\0') {
        if (*str == ' ' || *str == '\t' || *str == '\n') {
            isWord = 0;
        }
        else if (isWord == 0) {
            isWord = 1;
            count++;
        }

        str++;
    }

    return count;
}

int main() {
    char str[100];
    printf("Enter a string: ");
    fgets(str, sizeof(str), stdin);

    int wordCount = countWords(str);
    printf("Number of words: %d\n", wordCount);

    return 0;
}

代码解析:

int countWords(char* str): 这是一个函数定义，接受一个字符串指针作为参数，并统计字符串中的单词个数。
在 countWords 函数中，使用指针遍历字符串，根据空格、制表符和换行符判断单词的开始和结束，并进行计数。
在 main() 函数中，接受用户输入的字符串，调用 countWords 函数统计单词个数，并打印结果。

总结:
指针和字符串是C语言中常见的概念，可以使用指针对字符串进行访问和操作。理解指针和字符串的关系对于处理文本数据和字符串处理非常重要。

5. 指针和结构体:

知识点:
指针和结构体是C语言中重要的概念，结构体可以用于组织和存储多个不同类型的数据，指针可以用于对结构体进行访问和操作。

习题实例:
定义一个学生结构体，包含学生姓名和年龄，编写一个函数，接受一个指向学生结构体的指针，并打印学生的信息。

解析:
可以定义一个学生结构体，在函数中使用指针访问结构体的成员，并打印学生的信息。

#include <stdio.h>

struct Student {
    char name[50];
    int age;
};

void printStudentInfo(struct Student* student) {
    printf("Name: %s\n", student->name);
    printf("Age: %d\n", student->age);
}

int main() {
    struct Student student1 = {"John Doe", 20};

    // 使用指针传递结构体
    printStudentInfo(&student1);

    return 0;
}

代码解析:

struct Student: 这是一个学生结构体的定义，包含了学生的姓名和年龄。
void printStudentInfo(struct Student* student): 这是一个函数定义，接受一个指向学生结构体的指针作为参数，并打印学生的姓名和年龄。
在 main() 函数中，定义了一个学生结构体变量 student1，并初始化其姓名和年龄。然后通过指针将 student1 的地址传递给 printStudentInfo 函数进行打印。

总结:
指针和结构体是C语言中重要的概念，结构体可以用于组织和存储多个不同类型的数据，指针可以用于对结构体进行访问和操作。理解指针和结构体的关系对于处理复杂的数据结构和数据组织非常重要。

6. 链表反转:

知识点:
链表是一种常见的数据结构，链表反转是对链表中节点顺序进行逆转的操作。

代码示例:

#include <stdio.h>
#include <stdlib.h>

struct Node {
    int data;
    struct Node* next;
};

struct Node* reverseLinkedList(struct Node* head) {
    struct Node* prev = NULL;
    struct Node* current = head;
    struct Node* next = NULL;

    while (current != NULL) {
        next = current->next;
        current->next = prev;
        prev = current;
        current = next;
    }

    return prev;
}

void printLinkedList(struct Node* head) {
    struct Node* current = head;

    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");
}

int main() {
    // 构建链表
    struct Node* head = (struct Node*)malloc(sizeof(struct Node));
    struct Node* second = (struct Node*)malloc(sizeof(struct Node));
    struct Node* third = (struct Node*)malloc(sizeof(struct Node));

    head->data = 1;
    head->next = second;

    second->data = 2;
    second->next = third;

    third->data = 3;
    third->next = NULL;

    printf("Original Linked List: ");
    printLinkedList(head);

    // 反转链表
    struct Node* reversedHead = reverseLinkedList(head);

    printf("Reversed Linked List: ");
    printLinkedList(reversedHead);

    return 0;
}

代码解析:

定义了一个链表结构体 Node，包含数据域 data 和指向下一个节点的指针 next。
reverseLinkedList 函数实现链表反转操作，使用三个指针 prev、current 和 next，逐个将节点的 next 指针指向前一个节点，完成反转。
printLinkedList 函数用于打印链表的节点数据。
在 main 函数中，构建一个简单的链表，调用 reverseLinkedList 函数反转链表，并打印原始链表和反转后的链表。

总结:
链表反转是一个常见的编程问题，通过合理地使用指针和循环，可以高效地完成链表反转操作。此示例展示了链表反转的基本思路和实现方式。

请注意，上述示例中的代码并不是唯一的解决方案，而是展示了一种常见的实现方式。在实际编程中，可以根据具体需求和问题的特点选择最合适的解决方案。

7. 快速排序:

知识点:
快速排序是一种常用的排序算法，基于分治的思想，通过选取一个基准元素，将数组划分为两个子数组，并递归地对子数组进行排序。

代码示例:

#include <stdio.h>

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int partition(int arr[], int low, int high) {
    int pivot = arr[high];
    int i = low - 1;

    for (int j = low; j < high; j++) {
        if (arr[j] <= pivot) {
            i++;
            swap(&arr[i], &arr[j]);
        }
    }

    swap(&arr[i + 1], &arr[high]);
    return i + 1;
}

void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pivot = partition(arr, low, high);
        quickSort(arr, low, pivot - 1);
        quickSort(arr, pivot + 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[] = {5, 2, 9, 1, 7, 6, 3};
    int size = sizeof(arr) / sizeof(arr[0]);

    printf("Original Array: ");
    printArray(arr, size);

    quickSort(arr, 0, size - 1);

    printf("Sorted Array: ");
    printArray(arr, size);

    return 0;
}

代码解析:

swap 函数用于交换两个整数的值。
partition 函数用于在数组中选择基准元素，并将数组划分为两个子数组，返回基准元素的索引位置。
quickSort 函数实现快速排序算法，通过递归地对子数组进行排序。
printArray 函数用于打印数组的元素。
在 main 函数中，定义一个整数数组，调用 quickSort 函数对数组进行排序，并打印原始数组和排序后的数组。

总结:
快速排序是一种常用的排序算法，具有较好的平均时间复杂度和空间复杂度。此示例展示了快速排序算法的基本思想和实现方式。

8.广度优先搜索 (BFS):

知识点:
广度优先搜索是一种用于图或树的遍历算法，它从给定的起始节点开始，逐层扩展，先访问离起始节点最近的节点。

代码示例:

#include <stdio.h>
#include <stdbool.h>

#define MAX_SIZE 100

struct Queue {
    int items[MAX_SIZE];
    int front;
    int rear;
};

void enqueue(struct Queue* q, int value) {
    if (q->rear == MAX_SIZE - 1) {
        printf("Queue is full\n");
        return;
    }

    q->rear++;
    q->items[q->rear] = value;
}

int dequeue(struct Queue* q) {
    if (q->front > q->rear) {
        printf("Queue is empty\n");
        return -1;
    }

    int item = q->items[q->front];
    q->front++;
    return item;
}

bool isEmpty(struct Queue* q) {
    return q->front > q->rear;
}

void bfs(int adjacencyMatrix[][MAX_SIZE], int vertices, int startVertex) {
    bool visited[MAX_SIZE] = {false};

    struct Queue q;
    q.front = 0;
    q.rear = -1;

    visited[startVertex] = true;
    enqueue(&q, startVertex);

    while (!isEmpty(&q)) {
        int currentVertex = dequeue(&q);
        printf("%d ", currentVertex);

        for (int i = 0; i < vertices; i++) {
            if (adjacencyMatrix[currentVertex][i] && !visited[i]) {
                visited[i] = true;
                enqueue(&q, i);
            }
        }
    }
}

int main() {
    int adjacencyMatrix[MAX_SIZE][MAX_SIZE] = {
        {0, 1, 1, 0, 0, 0},
        {1, 0, 0, 1, 1, 0},
        {1, 0, 0, 0, 1, 0},
        {0, 1, 0, 0, 1, 1},
        {0, 1, 1, 1, 0, 1},
        {0, 0, 0, 1, 1, 0}
    };

    int vertices = 6;
    int startVertex = 0;

    printf("BFS Traversal: ");
    bfs(adjacencyMatrix, vertices, startVertex);

    return 0;
}

代码解析:

struct Queue 定义了一个队列结构体，包含了存储队列元素的数组和指向队列头部和尾部的指针。
enqueue 函数用于将元素入队。
dequeue 函数用于将元素出队。
isEmpty 函数用于检查队列是否为空。
bfs 函数实现了广度优先搜索算法，使用一个队列来辅助遍历过程。
在 main 函数中，定义了

一个邻接矩阵表示的图，调用 bfs 函数进行广度优先搜索遍历，并打印遍历结果。

总结:
广度优先搜索是一种常用的图遍历算法，通过使用队列来管理遍历过程中的节点，可以按层次遍历图或树结构。此示例展示了广度优先搜索算法的基本思想和实现方式。

9. Dijkstra算法:

知识点:
Dijkstra算法是一种用于求解带权有向图的单源最短路径的算法。它基于贪心策略，通过逐步确定从起点到其他顶点的最短路径。

代码示例:

#include <stdio.h>
#include <stdbool.h>
#include <limits.h>

#define MAX_SIZE 100

int minDistance(int dist[], bool visited[], int vertices) {
    int min = INT_MAX;
    int minIndex;

    for (int v = 0; v < vertices; v++) {
        if (!visited[v] && dist[v] <= min) {
            min = dist[v];
            minIndex = v;
        }
    }

    return minIndex;
}

void printPath(int parent[], int vertex) {
    if (parent[vertex] == -1) {
        printf("%d ", vertex);
        return;
    }

    printPath(parent, parent[vertex]);
    printf("%d ", vertex);
}

void printSolution(int dist[], int parent[], int vertices, int startVertex) {
    printf("Vertex\tDistance\tPath");

    for (int v = 0; v < vertices; v++) {
        printf("\n%d\t%d\t\t", v, dist[v]);
        printPath(parent, v);
    }
}

void dijkstra(int graph[MAX_SIZE][MAX_SIZE], int vertices, int startVertex) {
    int dist[MAX_SIZE];
    bool visited[MAX_SIZE];
    int parent[MAX_SIZE];

    for (int v = 0; v < vertices; v++) {
        dist[v] = INT_MAX;
        visited[v] = false;
        parent[v] = -1;
    }

    dist[startVertex] = 0;

    for (int count = 0; count < vertices - 1; count++) {
        int u = minDistance(dist, visited, vertices);
        visited[u] = true;

        for (int v = 0; v < vertices; v++) {
            if (!visited[v] && graph[u][v] && dist[u] != INT_MAX && dist[u] + graph[u][v] < dist[v]) {
                dist[v] = dist[u] + graph[u][v];
                parent[v] = u;
            }
        }
    }

    printSolution(dist, parent, vertices, startVertex);
}

int main() {
    int graph[MAX_SIZE][MAX_SIZE] = {
        {0, 4, 0, 0, 0, 0, 0, 8, 0},
        {4, 0, 8, 0, 0, 0, 0, 11, 0},
        {0, 8, 0, 7, 0, 4, 0, 0, 2},
        {0, 0, 7, 0, 9, 14, 0, 0, 0},
        {0, 0, 0, 9, 0, 10, 0, 0, 0},
        {0, 0, 4, 14, 10, 0, 2, 0, 0},
        {0, 0, 0, 0,

0, 2, 0, 1, 6},
        {8, 11, 0, 0, 0, 0, 1, 0, 7},
        {0, 0, 2, 0, 0, 0, 6, 7, 0}
    };

    int vertices = 9;
    int startVertex = 0;

    dijkstra(graph, vertices, startVertex);

    return 0;
}

代码解析:

minDistance 函数用于找到距离数组中最小距离对应的顶点索引。
printPath 函数用于递归打印最短路径中的顶点。
printSolution 函数用于打印最短路径的结果。
dijkstra 函数实现了Dijkstra算法，使用距离数组、访问数组和父节点数组来记录最短路径信息。
在 main 函数中，定义了一个带权有向图的邻接矩阵表示，调用 dijkstra 函数求解最短路径，并打印结果。

总结:
Dijkstra算法是一种经典的求解最短路径问题的算法。它通过贪心策略逐步确定起点到其他顶点的最短路径，并使用邻接矩阵表示图的结构。该示例展示了Dijkstra算法的基本思想和实现方式。

10.快速排序 (Quick Sort):

知识点:
快速排序是一种常用的排序算法，它采用分治法的思想，通过选择一个基准元素，将待排序序列划分为两部分，然后递归地对两部分进行排序。

代码示例:

#include <stdio.h>

void swap(int* a, int* b) {
   int temp = *a;
   *a = *b;
   *b = temp;
}

int partition(int arr[], int low, int high) {
   int pivot = arr[high]; // 将最右边的元素作为基准元素
   int i = low - 1; // i 指向小于基准元素的区域的右边界

   for (int j = low; j <= high - 1; j++) {
       if (arr[j] < pivot) {
           i++;
           swap(&arr[i], &arr[j]); // 交换 arr[i] 和 arr[j] 的值
       }
   }

   swap(&arr[i + 1], &arr[high]); // 将基准元素放到正确的位置上
   return i + 1; // 返回基准元素的索引
}

void quickSort(int arr[], int low, int high) {
   if (low < high) {
       int pivotIndex = partition(arr, low, high); // 对当前划分进行分割

       quickSort(arr, low, pivotIndex - 1); // 对左边的子序列进行递归排序
       quickSort(arr, pivotIndex + 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[] = {9, 7, 5, 11, 12, 2, 14, 3, 10, 6};
   int size = sizeof(arr) / sizeof(arr[0]);

   printf("Original array: ");
   printArray(arr, size);

   quickSort(arr, 0, size - 1); // 调用快速排序算法对数组进行排序

   printf("Sorted array: ");
   printArray(arr, size);

   return 0;
}

代码解析:

swap 函数用于交换两个元素的值。
partition 函数用于选择基准元素，并将序列划分为小于基准值和大于基准值的两部分。
quickSort 函数实现了快速排序算法，使用递归的方式对划分后的两部分进行排序。
printArray 函数用于打印数组的元素。
在 main 函数中，定义了一个待排序的数组，调用 quickSort 函数对数组进行排序，并打印结果。

总结:
快速排序是一种高效的排序算法，通过不断地划分和排序子序列来实现整体的排序。它的平均时间复杂度为 O(nlogn)，在大多数情况下表现优秀。该示例展示了快速排序算法的基本思想和实现方式。

请注意，上述示例中的代码并不是唯一的解决方案，而是展示了一种常见的实现方式。

在实际编程中，可以根据具体需求和问题的特点选择最合适的解决方案。

11.二分查找 (Binary Search):

知识点:
二分查找是一种高效的查找算法，它通过将待查找的元素与中间元素进行比较，从而将查找范围逐渐缩小一半，直到找到目标元素或确定目标元素不存在。

代码示例:

#include <stdio.h>

int binarySearch(int arr[], int low, int high, int target) {
    while (low <= high) {
        int mid = low + (high - low) / 2;

        if (arr[mid] == target) {
            return mid; // 找到目标元素，返回索引
        } else if (arr[mid] < target) {
            low = mid + 1; // 目标元素在右侧，更新搜索范围为右半部分
        } else {
            high = mid - 1; // 目标元素在左侧，更新搜索范围为左半部分
        }
    }

    return -1; // 目标元素不存在，返回-1
}

int main() {
    int arr[] = {2, 5, 8, 12, 16, 23, 38, 56, 72, 91};
    int size = sizeof(arr) / sizeof(arr[0]);
    int target = 23;

    int result = binarySearch(arr, 0, size - 1, target);

    if (result == -1) {
        printf("Element not found.\n");
    } else {
        printf("Element found at index %d.\n", result);
    }

    return 0;
}

代码解析:

binarySearch 函数实现了二分查找算法，使用循环来逐步缩小查找范围。
在 main 函数中，定义了一个已排序的数组，调用 binarySearch 函数查找目标元素，并根据返回值打印查找结果。

总结:
二分查找是一种高效的查找算法，适用于有序数组。它的时间复杂度为 O(log n)，远快于线性查找。该示例展示了二分查找算法的基本思想和实现方式。

12. 链表反转 (Reverse Linked List):

知识点:
链表反转是一种常见的操作，它将链表中的节点顺序颠倒，使链表的尾部成为新的头部。

代码示例:

#include <stdio.h>
#include <stdlib.h>

// 定义链表节点结构
struct ListNode {
    int data;
    struct ListNode* next;
};

// 创建链表节点
struct ListNode* createNode(int data) {
    struct ListNode* newNode = (struct ListNode*)malloc(sizeof(struct ListNode));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// 反转链表
struct ListNode* reverseList(struct ListNode* head) {
    struct ListNode* prev = NULL;
    struct ListNode* current = head;

    while (current != NULL) {
        struct ListNode* next = current->next;
        current->next = prev;
        prev = current;
        current = next;
    }

    return prev;
}

// 打印链表
void printList(struct ListNode* head) {
    struct ListNode* current = head;

    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }

    printf("\n");
}

int main() {
    // 创建链表: 1 -> 2 -> 3 -> 4 -> 5
    struct ListNode* head = createNode(1);
    head->next = createNode(2);
    head->next->next = createNode(3);
    head->next->next->next = createNode(4);
    head->next->next->next->next = createNode(5);

    printf("Original list: ");
    printList(head);

    // 反转链表
    struct ListNode* reversedHead = reverseList(head);

    printf("Reversed list: ");
    printList(reversedHead);

    return 0;
}

代码解析:

struct ListNode 定义了链表节点的结构，包含一个数据成员和一个指向下一个节点的指针。
createNode 函数用于创建新的链表节点，并返回节点的指针。
reverseList 函数实现了链表的反转，通过改变节点之间的指向关系实现反转。
printList 函数用于打印链表的节点值。
在 main 函数中，创建了一个包含五个节点的链表，调用 reverseList 函数反转链表，并打印反转后的链表。

总结:
链表反转是一种常见的链表操作，通过改变节点之间的指向关系，可以高效地实现链表的反转。该示例展示了链表反转算法的基本思想和实现方式。

13.广度优先搜索 (Breadth-First Search):

知识点:
广度优先搜索是一种用于图或树的遍历算法，它从根节点开始，逐层遍历图或树的节点，直到找到目标节点或遍历完所有节点。

代码示例:

#include <stdio.h>
#include <stdlib.h>

// 定义图的最大节点数量
#define MAX_NODES 10

// 定义图的邻接矩阵
int adjacencyMatrix[MAX_NODES][MAX_NODES];

// 定义节点的访问标记数组
int visited[MAX_NODES];

// 广度优先搜索
void breadthFirstSearch(int startNode, int numNodes) {
    int queue[MAX_NODES];
    int front = 0;
    int rear = 0;

    // 将起始节点加入队列，并标记为已访问
    queue[rear++] = startNode;
    visited[startNode] = 1;

    while (front < rear) {
        // 出队列
        int currentNode = queue[front++];

        // 访问当前节点
        printf("%d ", currentNode);

        // 遍历邻接节点
        for (int i = 0; i < numNodes; i++) {
            if (adjacencyMatrix[currentNode][i] == 1 && visited[i] == 0) {
                // 将未访问的邻接节点加入队列，并标记为已访问
                queue[rear++] = i;
                visited[i] = 1;
            }
        }
    }
}

int main() {
    // 初始化邻接矩阵
    for (int i = 0; i < MAX_NODES; i++) {
        for (int j = 0; j < MAX_NODES; j++) {
            adjacencyMatrix[i][j] = 0;
        }
    }

    // 添加图的边关系
    adjacencyMatrix[0][1] = 1;
    adjacencyMatrix[0][2] = 1;
    adjacencyMatrix[1][3] = 1;
    adjacencyMatrix[1][4] = 1;
    adjacencyMatrix[2][5] = 1;
    adjacencyMatrix[2][6] = 1;
    adjacencyMatrix[3][7] = 1;
    adjacencyMatrix[4][7] = 1;
    adjacencyMatrix[5][7] = 1;
    adjacencyMatrix[6][7] = 1;

    // 初始化节点的访问标记数组
    for (int i = 0; i < MAX_NODES; i++) {
        visited[i] = 0;
    }

    printf("Breadth-First Search: ");
    breadthFirstSearch(0, MAX_NODES);
    printf("\n");

    return 0;
}

代码解析:

adjacencyMatrix 是一个二维数组，用于表示图的邻接矩阵。其中，adjacencyMatrix[i][j] 的值为 1 表示节点 i 和节点 j 之间存在边

关系。

visited 是一个一维数组，用于标记节点是否已被访问。
breadthFirstSearch 函数实现了广度优先搜索算法，使用队列来存储待访问的节点，按层级逐个访问节点，并标记已访问的节点。
在 main 函数中，初始化邻接矩阵，添加图的边关系，初始化节点的访问标记数组，然后调用 breadthFirstSearch 函数进行广度优先搜索，并打印搜索结果。

总结:
广度优先搜索是一种常用的图遍历算法，它可以帮助我们在图或树中查找目标节点，或者按层级遍历图或树的节点。该示例展示了广度优先搜索算法的基本思想和实现方式。

14.快速排序 (Quick Sort):

知识点:
快速排序是一种高效的排序算法，它基于分治法的思想，通过将数组划分为较小和较大的两个子数组，递归地对子数组进行排序，从而达到整个数组有序的目的。

代码示例:

#include <stdio.h>

// 交换数组中的两个元素
void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 分区函数，将数组划分为两个子数组
int partition(int arr[], int low, int high) {
    int pivot = arr[high];
    int i = low - 1;

    for (int j = low; j < high; j++) {
        if (arr[j] <= pivot) {
            i++;
            swap(&arr[i], &arr[j]);
        }
    }

    swap(&arr[i + 1], &arr[high]);

    return i + 1;
}

// 快速排序函数
void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);

        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 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[] = {7, 2, 1, 6, 8, 5, 3, 4};
    int size = sizeof(arr) / sizeof(arr[0]);

    printf("Original array: ");
    printArray(arr, size);

    quickSort(arr, 0, size - 1);

    printf("Sorted array: ");
    printArray(arr, size);

    return 0;
}

代码解析:

swap 函数用于交换数组中的两个元素。
partition 函数实现了快速排序的分区过程，选择一个枢轴元素，并根据它的值将数组划分为较小和较大的两个子数组。
quickSort 函数是快速排序的主要函数，通过递归地对子数组进行排序来实现整个数组的排序。
printArray 函数用于打印数组的元素。
在 main 函数中，创建一个整数数组，调用 quickSort 函数对数组进行排序，并打印排序后的结果。

总结:
快速排序是一种常用的排序算法，它的平均时间复杂度为 O(n log n)，具有较好的性能。该示例展示了快速排序算法的基本思想和实现方式。

15.链表反转 (Reverse Linked List):

知识点:
链表反转是一种常见的操作，它可以将链表的节点顺序颠倒过来。通过改变节点之间的指针指向，实现链表的反转。

代码示例:

#include <stdio.h>
#include <stdlib.h>

// 定义链表节点
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// 反转链表函数
Node* reverseLinkedList(Node* head) {
    Node* prev = NULL;
    Node* current = head;
    Node* next = NULL;

    while (current != NULL) {
        next = current->next;
        current->next = prev;
        prev = current;
        current = next;
    }

    return prev;
}

// 打印链表
void printLinkedList(Node* head) {
    Node* current = head;

    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }

    printf("\n");
}

int main() {
    // 创建链表: 1 -> 2 -> 3 -> 4 -> 5
    Node* head = (Node*)malloc(sizeof(Node));
    head->data = 1;

    Node* second = (Node*)malloc(sizeof(Node));
    second->data = 2;
    head->next = second;

    Node* third = (Node*)malloc(sizeof(Node));
    third->data = 3;
    second->next = third;

    Node* fourth = (Node*)malloc(sizeof(Node));
    fourth->data = 4;
    third->next = fourth;

    Node* fifth = (Node*)malloc(sizeof(Node));
    fifth->data = 5;
    fourth->next = fifth;
    fifth->next = NULL;

    printf("Original linked list: ");
    printLinkedList(head);

    // 反转链表
    Node* reversedHead = reverseLinkedList(head);

    printf("Reversed linked list: ");
    printLinkedList(reversedHead);

    // 释放链表内存
    Node* current = reversedHead;
    Node* temp;

    while (current != NULL) {
        temp = current;
        current = current->next;
        free(temp);
    }

    return 0;
}

代码解析:

首先定义了链表节点的结构体，包含数据域和指向下一个节点的指针。
reverseLinkedList 函数实现了链表的反转。通过三个指针 prev、current 和 next 来逐个反转节点的指针指向，实现链表的反转。
printLinkedList 函数用于打印链表的节点。
在 main 函数中，创建一个包含 1 到 5 的链表，调用 reverseLinkedList 函数对链表进行反转，并打印反转后的结果。
最后释放链表的内存。

总结:
链表反转是一种常见的链表操作，它可以将链表的节点顺序颠倒过来。该示例展示了链表反转的基本思想和实现方式。

宇希啊

关注

3
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
C语言实例

快速排序是一种高效的排序算法，它基于分治法的思想，通过将数组划分为较小和较大的两个子数组，递归地对子数组进行排序，从而达到整个数组有序的目的。请注意，上述示例中的代码并不是唯一的解决方案，而是展示了一种常见的实现方式。在实际编程中，可以根据具体需求和问题的特点选择最合适的解决方案。请注意，上述示例中的代码并不是唯一的解决方案，而是展示了一种常见的实现方式。请注意，上述示例中的代码并不是唯一的解决方案，而是展示了一种常见的实现方式。请注意，上述示例中的代码并不是唯一的解决方案，而是展示了一种常见的实现方式。
复制链接

扫一扫