代码实现 快速排序 数据结构 算法 头歌

快速排序

快速排序是建立在冒泡排序基础上的一种排序方法

基本思想 :通过一趟排序将要排序的数据分割成独立的两部分

其中一部分的所有数据都比另外一部分的所有数据都要小,

然后再按此方法对这两部分数据分别进行快速排序,

整个排序过程可以递归进行,以此达到整个数据变成有序序列。

实现方法:

1.选择一个基准元素,通常选择第一个元素或者最后一个元素。

2.比较排序,将小于基准元素的数据移到左边,大于基准元素的数据移到右边。

3.再次对左右两边的数据进行排序。

4.重复步骤2和3,直到整个数据变成有序序列。

通关代码


int partition_array(int *arr, int l, int r)
// 编程实现arr[l, r]分区:选定一个基准,左边比基准小,右边比基准大
// 返回基准所处位置
{
    // 请在这里补充代码,完成本关任务
    /********** Begin *********/
    // 基准元素
    int pivot = arr[l];
    // 左右两边的指针
    int i = l + 1;
    int j = r;
    // 将arr[l+1, r]分为两部分,左边比pivot小,右边比pivot大
    while (i <= j)
    {
        // 左边找到一个比pivot大的元素
        while (i <= r && arr[i] <= pivot)
        {
            i++;
        }
        // 右边找到一个比pivot小的元素
        while (j >= l + 1 && arr[j] >= pivot)
        {
            j--;
        }
        // 如果左边比pivot大,右边比pivot小,交换两个元素
        if (i < j)
        {
            swap(arr[i], arr[j]);
        }
    }
    // 将pivot放到正确的位置
    swap(arr[l], arr[j]);
    // 返回pivot所处位置
    return j;
    /********** End **********/
}

int *quick_sort(int *arr, int l, int r)
//  基于partition_array函数编程实现快速排序:自上而下的递归方法
//  函数参数:有序数组arr 初始l=0,r=n-1
//  函数返回值:返回从小到大排序后的数组
{
    // 请在这里补充代码,完成本关任务
    /********** Begin *********/
    if (l >= r)
    {
        return arr;
    }
    // 分区
    int pivot = partition_array(arr, l, r);
    // 左边排序
    quick_sort(arr, l, pivot - 1);
    // 右边排序
    quick_sort(arr, pivot + 1, r);

    return arr;

    /********** End **********/
}

完整代码


#include <cstdio>
#include <algorithm>
#include <iostream>
using namespace std;

void print_array(int *arr, int n);
// 打印数组

int partition_array(int *arr, int l, int r);
// arr[l, r]分区:选定一个基准,左边比基准小,右边比基准大
// 返回基准所处位置

int *quick_sort(int *arr, int l, int r);
// 快速排序:自上而下的递归方法,初始l=0,r=n-1

void print_array(int *arr, int n)
// 打印数组
{
    if (n == 0)
    {
        printf("ERROR: Array length is ZERO\n");
        return;
    }
    printf("%d", arr[0]);
    for (int i = 1; i < n; i++)
    {
        printf(" %d", arr[i]);
    }
    printf("\n");
}

int partition_array(int *arr, int l, int r)
// 编程实现arr[l, r]分区:选定一个基准,左边比基准小,右边比基准大
// 返回基准所处位置
{
    // 请在这里补充代码,完成本关任务
    /********** Begin *********/
    // 基准元素
    int pivot = arr[l];
    // 左右两边的指针
    int i = l + 1;
    int j = r;
    // 将arr[l+1, r]分为两部分,左边比pivot小,右边比pivot大
    while (i <= j)
    {
        // 左边找到一个比pivot大的元素
        while (i <= r && arr[i] <= pivot)
        {
            i++;
        }
        // 右边找到一个比pivot小的元素
        while (j >= l + 1 && arr[j] >= pivot)
        {
            j--;
        }
        // 如果左边比pivot大,右边比pivot小,交换两个元素
        if (i < j)
        {
            swap(arr[i], arr[j]);
        }
    }
    // 将pivot放到正确的位置
    swap(arr[l], arr[j]);
    // 返回pivot所处位置
    return j;
    /********** End **********/
}

int *quick_sort(int *arr, int l, int r)
//  基于partition_array函数编程实现快速排序:自上而下的递归方法
//  函数参数:有序数组arr 初始l=0,r=n-1
//  函数返回值:返回从小到大排序后的数组
{
    // 请在这里补充代码,完成本关任务
    /********** Begin *********/
    if (l >= r)
    {
        return arr;
    }
    // 分区
    int pivot = partition_array(arr, l, r);
    // 左边排序
    quick_sort(arr, l, pivot - 1);
    // 右边排序
    quick_sort(arr, pivot + 1, r);

    return arr;

    /********** End **********/
}

int main(int argc, const char *argv[])
{
    int n;
    scanf("%d", &n);

    int *arr;
    arr = (int *)malloc(sizeof(int) * n);

    for (int i = 0; i < n; i++)
    {
        scanf("%d", &arr[i]);
    }

    arr = quick_sort(arr, 0, n - 1);

    print_array(arr, n);

    return 0;
}

  • 4
    点赞
  • 15
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
排序作业 选择题(每题2分,共22分)。 1.若表R在排序前已按键值递增顺序排列,则(   )算法的比较次数最少。 A.直接插入排序            B.快速排序     C.归并排序                D.选择排序 2.对各种内部排序方法来说,(   )。 A.快速排序时间性能最佳                             B.归并排序是稳定的排序方法 C.快速排序是一种选择排序                          D.堆排序所用的辅助空间比较大 3.  排序算法的稳定性是指(   )。 A.经过排序之后,能使值相同的数据保持原顺序中的相对位置不变。 B.经过排序之后,能使值相同的数据保持原顺序中的绝对位置不变。 C.排序算法的性能与被排序元素的数量关系不大 D.排序算法的性能与被排序元素的数量关系密切 4. 如下序列中,(   )序列是大顶堆。 A.  {4,5,3,2,1}               B.  {5,3,4,1,2}        C.  {1,2,3,4,5}               D.  {1,2,3,5,4} 5. 若将{3,2,5,4,1}排为升序,则实施快速排序一趟后的结果是(   )(其中,枢轴记录取首记录)。 A.  {1,2,3,4,5}                  B.  {1,2,4,5,3}        C.  {1,3,5,4,2}                  D.  {2,5,4,1,3} . 若将{1,2,3,4,5,6,7,9,8}排为升序,则(   )排序方法的“比较记录”次数最少。 A.  快速排序                   B.  简单选择排序     C.  直接插入排序               D.  冒泡排序 7. 若将{5,4,3,2,1}排为升序,则(   )排序方法的“移动记录”次数最多。 A.  快速排序                                B.  冒泡排序 C.  直接插入排序                       D.  简单选择排序 8. 用简单选择排序将顺序表{2,3,1 ,3′,2′}排为升序,实施排序1趟后结果是{1 ,3,2 ,3′,2′},则排序3趟后的结果是(   )。 A.  {1 ,2,3 ,3′,2′}                       B.  {1 ,2 ,2′,3 ,3′} C.  {1 ,2′,2 ,3 ,3′}                      D.  {1 ,2 ,2′,3′,3 } 9.下列排序算法中,(    )排序在某趟结束后不一定选出一个元素放到其最终的位置上。 A.选择             B.冒泡           C.归并           D.堆 10.下列排序算法中,稳定的排序算法是(  )。 A.堆排序                B.直接插入排序   C.快速排序              D.希尔排序 11.堆排序的时间复杂度是(    )。 A.O(n*n)                 B.O(n*log n)       C.O(n)                   D.O(log n) 填空题(每空4分,共4分)。 对n个元素进行归并排序,空间复杂度为         。 综合题(共24分)。 1. (共12分)有一组待排序的关键字如下: (54,38,96,23,15,72,60,45,83) 分别写出希尔排序(d=5)、快速排序、堆排序、归并排序第一趟升序排序后的结果(其中堆排序的第一趟指序列完成初始建堆、将堆顶元素置为最末位置后其余元素调整为堆的结果)(每个3分)。 希尔排序:   快速排序: 堆排序: 归并排序:  2. (共12分)已知数据序列为(12,5,9,20,6,31,24),对该项数据序列进行排序,分别写出直接插入排序、简单选择排序快速排序、堆排序、二路归并排序及基数排序第一趟升序排序结果(其中堆排序的第一趟指序列完成初始建堆、将堆顶元素置为最末位置后其余元素调整为堆的结果)(每个2分)。 直接插入排序: 简单选择排序快速排序: 堆排序: 二路归并排序: 基数排序:    
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值