1. PingCode智库首页
  2. 百科

c语言快速排序如何编程

Edit1 • • 百科

c语言快速排序如何编程

C语言快速排序编程指南

快速排序（Quick Sort）是一种高效的、基于分治法的排序算法。它通过选择一个“基准”元素，将数组分成两部分，然后递归地对这两部分进行排序。快速排序的核心思想是通过一次排序将数据分割成两部分，其中一部分的元素都比另一部分的元素小。详细展开来说，快速排序的关键点在于如何选择基准元素，以及如何进行分区操作。

一、快速排序的基本原理

快速排序的基本原理可以总结为以下几个步骤：

  1. 选择基准元素：从数组中选择一个元素作为基准，一般可以选择第一个元素、最后一个元素、中间元素或随机选择。
  2. 分区操作：重新排序数组，使所有比基准值小的元素都放在基准值的左边，所有比基准值大的元素都放在基准值的右边（相同的值可以放在任意一边）。
  3. 递归排序：递归地对基准元素左边的子数组和右边的子数组进行排序。

以下是快速排序的伪代码：

void quicksort(int array[], int low, int high) {


    if (low < high) {


        int pivot_index = partition(array, low, high);


        quicksort(array, low, pivot_index - 1);


        quicksort(array, pivot_index + 1, high);


    }


}


int partition(int array[], int low, int high) {


    int pivot = array[high];


    int i = (low - 1);


    for (int j = low; j < high; j++) {


        if (array[j] <= pivot) {


            i++;


            swap(&array[i], &array[j]);


        }


    }


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


    return (i + 1);


}


void swap(int* a, int* b) {


    int t = *a;


    *a = *b;


    *b = t;


}

二、选择基准元素的方法

选择基准元素的方法有多种，不同的选择策略会影响排序的效率。常见的选择基准元素的方法包括：

  1. 固定位置选择：选择第一个元素或最后一个元素作为基准。
  2. 随机选择：随机选择一个元素作为基准。
  3. 三数取中：选择第一个元素、最后一个元素和中间元素的中间值作为基准。

三数取中的方法可以有效避免快速排序在处理已经有序或几乎有序的数组时退化为O(n^2)的情况。以下是三数取中的实现代码：

int median_of_three(int array[], int low, int high) {


    int mid = low + (high - low) / 2;


    if (array[low] > array[mid]) {


        swap(&array[low], &array[mid]);


    }


    if (array[low] > array[high]) {


        swap(&array[low], &array[high]);


    }


    if (array[mid] > array[high]) {


        swap(&array[mid], &array[high]);


    }


    return mid;


}


int partition(int array[], int low, int high) {


    int pivot_index = median_of_three(array, low, high);


    int pivot = array[pivot_index];


    swap(&array[pivot_index], &array[high]);


    int i = (low - 1);


    for (int j = low; j < high; j++) {


        if (array[j] <= pivot) {


            i++;


            swap(&array[i], &array[j]);


        }


    }


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


    return (i + 1);


}

三、分区操作的实现

分区操作是快速排序的核心步骤，它决定了基准元素的位置，并将数组分为两部分。分区操作的实现通常采用双指针法：

  1. 初始化两个指针：一个指针（i）从数组的左端开始，另一个指针（j）从数组的右端开始。
  2. 移动指针：从左到右找到第一个大于基准值的元素，从右到左找到第一个小于基准值的元素，然后交换这两个元素。
  3. 重复步骤2：直到两个指针相遇，此时基准元素的位置已经确定。

以下是双指针法的实现代码：

int partition(int array[], int low, int high) {


    int pivot = array[low];


    int left = low + 1;


    int right = high;


    while (left <= right) {


        while (left <= right && array[left] <= pivot) {


            left++;


        }


        while (left <= right && array[right] >= pivot) {


            right--;


        }


        if (left < right) {


            swap(&array[left], &array[right]);


        }


    }


    swap(&array[low], &array[right]);


    return right;


}

四、优化快速排序的技巧

快速排序在实践中有一些优化技巧，可以进一步提高其性能：

  1. 小数组使用插入排序：对于较小的数组（如长度小于10），可以使用插入排序代替快速排序，因为插入排序在小数组上性能更好。
  2. 避免最坏情况：通过随机选择基准元素或三数取中，可以避免最坏情况的发生。
  3. 尾递归优化：在递归调用时，可以优先排序较小的子数组，以减少递归的深度。

以下是结合插入排序的优化代码：

void insertion_sort(int array[], int low, int high) {


    for (int i = low + 1; i <= high; i++) {


        int key = array[i];


        int j = i - 1;


        while (j >= low && array[j] > key) {


            array[j + 1] = array[j];


            j--;


        }


        array[j + 1] = key;


    }


}


void quicksort(int array[], int low, int high) {


    if (low + 10 <= high) {


        int pivot_index = partition(array, low, high);


        quicksort(array, low, pivot_index - 1);


        quicksort(array, pivot_index + 1, high);


    } else {


        insertion_sort(array, low, high);


    }


}

五、快速排序的时间复杂度分析

快速排序的时间复杂度主要取决于基准元素的选择和分区操作的效率。一般情况下，快速排序的时间复杂度为O(n log n)，但在最坏情况下（如每次选择的基准元素都是数组中的最小或最大值），时间复杂度会退化为O(n^2)。通过优化基准元素的选择，可以避免最坏情况的发生。

以下是快速排序的平均和最坏时间复杂度的比较：

  1. 平均时间复杂度：O(n log n)
  2. 最坏时间复杂度：O(n^2)
  3. 空间复杂度：O(log n)（递归调用栈的空间）

六、快速排序的稳定性

快速排序是一种不稳定的排序算法，因为在分区操作中可能会交换相同元素的相对位置。虽然不稳定性在很多应用中不是问题，但在需要保持相同元素相对位置的应用中，应该选择其他稳定排序算法，如归并排序或冒泡排序。

七、快速排序的应用场景

快速排序由于其高效性和简单性，在实际应用中有广泛的使用场景：

  1. 大规模数据排序：快速排序适合用于大规模数据的排序，因为其平均时间复杂度为O(n log n)。
  2. 内存敏感环境：快速排序的空间复杂度较低，适用于内存敏感的环境。
  3. 嵌入式系统：由于其递归实现简单，快速排序在嵌入式系统中也有广泛应用。

八、快速排序的变种

除了传统的快速排序，还有一些变种算法可以在特定场景下进一步优化性能：

  1. 三路快速排序：将数组分为三部分：小于基准值、等于基准值和大于基准值，适用于大量重复元素的数组。
  2. 双基准快速排序：同时选择两个基准值，将数组分为三部分，提高分区效率。

以下是三路快速排序的实现代码：

void quicksort3way(int array[], int low, int high) {


    if (low < high) {


        int lt = low, gt = high;


        int pivot = array[low];


        int i = low;


        while (i <= gt) {


            if (array[i] < pivot) {


                swap(&array[i], &array[lt]);


                lt++;


                i++;


            } else if (array[i] > pivot) {


                swap(&array[i], &array[gt]);


                gt--;


            } else {


                i++;


            }


        }


        quicksort3way(array, low, lt - 1);


        quicksort3way(array, gt + 1, high);


    }


}

九、快速排序的代码实现

以下是一个完整的快速排序代码实现，包括所有优化和变种算法的代码：

#include <stdio.h>


// 交换两个元素


void swap(int* a, int* b) {


    int t = *a;


    *a = *b;


    *a = t;


}


// 插入排序


void insertion_sort(int array[], int low, int high) {


    for (int i = low + 1; i <= high; i++) {


        int key = array[i];


        int j = i - 1;


        while (j >= low && array[j] > key) {


            array[j + 1] = array[j];


            j--;


        }


        array[j + 1] = key;


    }


}


// 三数取中


int median_of_three(int array[], int low, int high) {


    int mid = low + (high - low) / 2;


    if (array[low] > array[mid]) {


        swap(&array[low], &array[mid]);


    }


    if (array[low] > array[high]) {


        swap(&array[low], &array[high]);


    }


    if (array[mid] > array[high]) {


        swap(&array[mid], &array[high]);


    }


    return mid;


}


// 分区操作


int partition(int array[], int low, int high) {


    int pivot_index = median_of_three(array, low, high);


    int pivot = array[pivot_index];


    swap(&array[pivot_index], &array[high]);


    int i = (low - 1);


    for (int j = low; j < high; j++) {


        if (array[j] <= pivot) {


            i++;


            swap(&array[i], &array[j]);


        }


    }


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


    return (i + 1);


}


// 快速排序


void quicksort(int array[], int low, int high) {


    if (low + 10 <= high) {


        int pivot_index = partition(array, low, high);


        quicksort(array, low, pivot_index - 1);


        quicksort(array, pivot_index + 1, high);


    } else {


        insertion_sort(array, low, high);


    }


}


// 三路快速排序


void quicksort3way(int array[], int low, int high) {


    if (low < high) {


        int lt = low, gt = high;


        int pivot = array[low];


        int i = low;


        while (i <= gt) {


            if (array[i] < pivot) {


                swap(&array[i], &array[lt]);


                lt++;


                i++;


            } else if (array[i] > pivot) {


                swap(&array[i], &array[gt]);


                gt--;


            } else {


                i++;


            }


        }


        quicksort3way(array, low, lt - 1);


        quicksort3way(array, gt + 1, high);


    }


}


// 测试快速排序


int main() {


    int array[] = {34, 7, 23, 32, 5, 62, 32, 7, 78, 45, 90, 12};


    int n = sizeof(array) / sizeof(array[0]);


    quicksort(array, 0, n - 1);


    printf("Sorted array: n");


    for (int i = 0; i < n; i++) {


        printf("%d ", array[i]);


    }


    printf("n");


    return 0;


}

通过以上代码，可以轻松实现快速排序并在各种场景下进行优化，以提高排序效率和性能。快速排序作为一种经典的排序算法，仍然是许多编程和算法课程中的重要内容。理解其原理和实现方法，将有助于更好地掌握其他高级算法和数据结构。

相关问答FAQs：

1. 什么是C语言快速排序算法？

C语言快速排序算法是一种常用的排序算法，它通过比较和交换数组中的元素来将其按照升序或降序排列。它的核心思想是选择一个基准元素，将数组分为两个子数组，一个子数组中的所有元素小于等于基准元素，另一个子数组中的所有元素大于基准元素，然后对这两个子数组分别进行递归排序。

2. 如何在C语言中实现快速排序算法？

要在C语言中实现快速排序算法，可以按照以下步骤进行编程：

  • 选择一个基准元素（可以是数组的第一个元素）。
  • 将数组分为两个子数组，一个子数组中的所有元素小于等于基准元素，另一个子数组中的所有元素大于基准元素。
  • 递归地对两个子数组进行快速排序。
  • 合并排序后的子数组，得到最终排序结果。

下面是一个示例代码片段：

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

int partition(int arr[], int low, int high) {
    int pivot = arr[low];
    int i = low + 1;
    int j = high;
    
    while (i <= j) {
        while (i <= j && arr[i] <= pivot) {
            i++;
        }
        while (i <= j && arr[j] > pivot) {
            j--;
        }
        if (i < j) {
            swap(&arr[i], &arr[j]);
        }
    }
    
    swap(&arr[low], &arr[j]);
    return j;
}

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

3. 快速排序算法的时间复杂度是多少？

快速排序算法的平均时间复杂度为O(nlogn)，其中n是待排序数组的长度。最坏情况下的时间复杂度为O(n^2)，发生在数组已经有序的情况下。快速排序算法是一种高效的排序算法，在大多数情况下都能够快速地对数组进行排序。

文章包含AI辅助创作，作者：Edit1，如若转载，请注明出处：https://docs.pingcode.com/baike/963102

赞 (0)
Edit1Edit1
免费注册
电话联系

4008001024

微信咨询
微信咨询
返回顶部