白骑士的C语言教学高级篇 3.4 C语言中的算法

白骑士所长

已于 2024-07-07 10:38:55 修改

阅读量465

点赞数 5

分类专栏：教学 C语言文章标签：算法 c语言排序算法

于 2024-07-06 00:24:00 首次发布

本文链接：https://blog.csdn.net/JeremyTC/article/details/140193419

版权

教学同时被 2 个专栏收录

332 篇文章 3 订阅

订阅专栏

C语言

22 篇文章 0 订阅

订阅专栏

系列目录

上一篇：白骑士的C语言教学高级篇 3.3 并发与多线程

算法是解决问题的核心。无论是排序、搜索，还是递归与动态规划，算法的选择和实现对程序的效率和性能有着重要影响。本节将介绍几种常见的算法，包括排序算法、搜索算法，以及递归和动态规划的应用。

排序算法

排序算法是将一组数据按特定顺序排列的过程。常见的排序算法有冒泡排序、选择排序、插入排序、快速排序和归并排序等。下面是几种常见排序算法的介绍和示例代码。

冒泡排序

冒泡排序通过多次遍历数组，每次比较相邻的元素，如果顺序错误就交换，直到整个数组有序，例如：

#include <stdio.h>


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


int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr)/sizeof(arr[0]);

    bubbleSort(arr, n);

    printf("排序后的数组: ");

    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);

    return 0;
}

选择排序

选择排序每次从未排序部分中选出最小（或最大）的元素，放到已排序部分的末尾，例如：

#include <stdio.h>


void selectionSort(int arr[], int n) {
    for (int i = 0; i < n-1; i++) {
        int minIndex = i;

        for (int j = i+1; j < n; j++) {
            if (arr[j] < arr[minIndex])
                minIndex = j;
        }

        int temp = arr[minIndex];
        arr[minIndex] = arr[i];
        arr[i] = temp;
    }
}


int main() {
    int arr[] = {64, 25, 12, 22, 11};
    int n = sizeof(arr)/sizeof(arr[0]);
    selectionSort(arr, n);

    printf("排序后的数组: ");

    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);

    return 0;
}

快速排序

快速排序通过选择一个基准元素，将数组分成两部分，一部分所有元素比基准元素小，另一部分所有元素比基准元素大，然后递归地对这两部分进行排序，例如：

#include <stdio.h>


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


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

    for (int j = low; j <= high-1; 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);
    }
}


int main() {
    int arr[] = {10, 7, 8, 9, 1, 5};
    int n = sizeof(arr)/sizeof(arr[0]);

    quickSort(arr, 0, n-1);

    printf("排序后的数组: ");

    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);

    return 0;
}

搜索算法

搜索算法用于在数据集合中查找特定元素。常见的搜索算法有线性搜索和二分搜索。

线性搜索

线性搜索逐一比较数据集合中的每个元素，直到找到目标元素或搜索完所有元素，例如：

#include <stdio.h>


int linearSearch(int arr[], int n, int x) {
    for (int i = 0; i < n; i++) {
        if (arr[i] == x)
            return i;
    }

    return -1;
}


int main() {
    int arr[] = {2, 3, 4, 10, 40};
    int x = 10;
    int n = sizeof(arr)/sizeof(arr[0]);
    int result = linearSearch(arr, n, x);

    if(result == -1)
        printf("元素不在数组中\n");

    else
        printf("元素在数组中的索引: %d\n", result);

    return 0;
}

二分搜索

二分搜索在有序数组中查找目标元素，通过反复将搜索范围缩小为一半，直到找到目标元素或搜索范围为空，例如：

#include <stdio.h>


int binarySearch(int arr[], int l, int r, int x) {
    while (l <= r) {
        int m = l + (r - l) / 2;

        if (arr[m] == x)
            return m;

        if (arr[m] < x)
            l = m + 1;

        else
            r = m - 1;
    }

    return -1;
}


int main() {
    int arr[] = {2, 3, 4, 10, 40};
    int x = 10;
    int n = sizeof(arr)/sizeof(arr[0]);
    int result = binarySearch(arr, 0, n-1, x);

    if(result == -1)
        printf("元素不在数组中\n");

    else
        printf("元素在数组中的索引: %d\n", result);

    return 0;
}

递归与动态规划

递归

是指一个函数调用其自身。递归算法通常用于解决分治问题，例如斐波那契数列和阶乘，例如：

#include <stdio.h>


int fibonacci(int n) {
    if (n <= 1)
        return n;

    return fibonacci(n - 1) + fibonacci(n - 2);
}


int main() {
    int n = 9;

    printf("Fibonacci数列的第%d项是: %d\n", n, fibonacci(n));

    return 0;
}

动态规划

是一种将复杂问题分解为更小子问题的技术，通过记忆化或表格化存储子问题的结果，避免重复计算，提升算法效率，例如：

#include <stdio.h>


int fibonacci(int n) {
    int f[n+1];
    f[0] = 0;
    f[1] = 1;

    for (int i = 2; i <= n; i++) {
        f[i] = f[i-1] + f[i-2];
    }

    return f[n];
}


int main() {
    int n = 9;

    printf("Fibonacci数列的第%d项是: %d\n", n, fibonacci(n));

    return 0;
}