秩序的构建：探寻排序算法的奥秘，开启数据世界的诗篇

Exhausted、

于 2024-10-15 13:01:31 发布

阅读量688

点赞数 16

分类专栏： C_数据结构 C C++ 文章标签：算法数据结构排序算法 c语言 c++ 开发语言

本文链接：https://blog.csdn.net/2302_80871796/article/details/142946058

版权

C++ 同时被 3 个专栏收录

16 篇文章 0 订阅

订阅专栏

C_数据结构

10 篇文章 0 订阅

订阅专栏

10 篇文章 0 订阅

订阅专栏

一、排序算法的基本概念

二、常见排序算法的运行方式和 C 语言实现

一、排序算法的基本概念

排序算法是指将一组无序的数据元素按照特定的顺序进行排列的过程。常见的排序算法有：

冒泡排序 (Bubble Sort)：通过比较相邻元素，将较大的元素交换到后面，逐次遍历整个数组，直到数组有序。
选择排序 (Selection Sort)：在未排序的数组中找到最小元素，将其与第一个元素交换位置，然后在剩余未排序的数组中继续寻找最小元素，并与第二个元素交换位置，以此类推。
插入排序 (Insertion Sort)：将数组分为已排序和未排序两个部分，每次从未排序部分中取出第一个元素，将其插入到已排序部分的合适位置，直到所有元素都排序完毕。
归并排序 (Merge Sort)：将数组递归地分成两半，直到每个子数组只有一个元素，然后将两个有序子数组合并成一个有序数组。
快速排序 (Quick Sort)：选择一个基准元素，将数组中比基准元素小的元素放在基准元素的左边，比基准元素大的元素放在基准元素的右边，然后递归地对左右两部分进行排序。

二、常见排序算法的运行方式和 C 语言实现

1. 冒泡排序

运行方式：
- 比较相邻元素，如果顺序错误则交换。
- 遍历数组，重复比较和交换，直到没有元素需要交换。

C 语言实现：

void bubbleSort(int arr[], int n) 
{
    int i, j, temp;
    for (i = 0; i < n - 1; i++) 
    {
        for (j = 0; j < n - i - 1; j++) 
        {
            if (arr[j] > arr[j + 1]) 
            {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

流程图：

2. 选择排序

运行方式：
- 找到未排序数组中的最小元素。
- 将最小元素与第一个元素交换位置。
- 重复上述步骤，直到所有元素都排序完毕。

C 语言实现：

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

流程图：

3. 插入排序

运行方式：
- 将第一个元素视为已排序数组。
- 从第二个元素开始，每次将一个元素插入到已排序数组中的合适位置。

C 语言实现：

void insertionSort(int arr[], int n) 
{
    int i, j, key;
    for (i = 1; i < n; i++) 
    {
        key = arr[i];
        j = i - 1;
        while (j >= 0 && arr[j] > key) 
        {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

流程图：

4. 归并排序

运行方式：
- 将数组递归地分成两半，直到每个子数组只有一个元素。
- 将两个有序子数组合并成一个有序数组。

C 语言实现：

void merge(int arr[], int left, int mid, int right) 
{
    int n1 = mid - left + 1;
    int n2 = right - mid;
    int L[n1], R[n2];
    int i, j, k;

    for (i = 0; i < n1; i++) 
    {
        L[i] = arr[left + i];
    }

    for (j = 0; j < n2; j++) 
    {
        R[j] = arr[mid + 1 + j];
    }

    i = 0;
    j = 0;
    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) 
    {
        arr[k] = L[i];
        i++;
        k++;
    }

    while (j < n2) 
    {
        arr[k] = R[j];
        j++;
        k++;
    }
}

void mergeSort(int arr[], int left, int right) 
{
    if (left < right) 
    {
        int mid = left + (right - left) / 2;
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);
        merge(arr, left, mid, right);
    }
}

流程图：

5. 快速排序

运行方式：
- 选择一个基准元素。
- 将数组中比基准元素小的元素放在基准元素的左边，比基准元素大的元素放在基准元素的右边。
- 递归地对左右两部分进行排序。

C 语言实现：

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, j);
        }
    }
    swap(arr, i + 1, 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 swap(int arr[], int i, int j) 
{
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

流程图：