排序之快排加冒泡数次数

数据结构实验之排序二:交换排序
Time Limit: 1000 ms Memory Limit: 65536 KiB

Problem Description
冒泡排序和快速排序都是基于”交换”进行的排序方法,你的任务是对题目给定的N个(长整型范围内的)整数从小到大排序,输出用冒泡和快排对这N个数排序分别需要进行的数据交换次数。

Input
连续多组输入数据,每组数据第一行给出正整数N(N ≤ 10^5),随后给出N个整数,数字间以空格分隔。

Output
输出数据占一行,代表冒泡排序和快速排序进行排序分别需要的交换次数,数字间以1个空格分隔,行末不得有多余空格。

Sample Input
8
49 38 65 97 76 13 27 49
Sample Output
15 9
Hint
注意:数据相等时不做交换

Source
xam

#include<stdio.h>
#include<stdlib.h>
int a[100001],b[100001];
int sum;
int sum1;
void arrange(int a[],int left,int right)
{
    int x=a[left],i=left,j=right;
    if(i>=j)return ;
    while(i<j)
    {
        while(i<j&&a[j]>=x)j--;
        if(i!=j)sum++;//当比较到i=j的时候是归位的时候,这时候并没有发生交换
        a[i]=a[j];
        while(i<j&&a[i]<=x)i++;
        if(i!=j)sum++;
        a[j]=a[i];
    }
    a[i]=x;
    arrange(a,left,i-1);
    arrange(a,i+1,right);
}
void arrange2(int b[],int n)
{
    for(int i=n; i>=1; i--)//要对n个数进行归位
    {
        for(int j=1; j<i; j++)//从最顶上往下归位,到倒数第二个的时候就不用比较倒数第一个了;
        {
            if(b[j]>b[j+1])
            {
                int t=b[j+1];
                b[j+1]=b[j];
                b[j]=t;
                sum1++;
            }
        }
    }
}
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        sum=0;
          sum1=0;
        for(int i=1; i<=n; i++)
        {
            scanf("%d",&a[i]);
        }
        for(int i=1;i<=n;i++)
        {
            b[i]=a[i];
        }
        arrange(a,1,n);
        arrange2(b,n);
        printf("%d %d\n",sum1,sum);
    }
    return 0;
}
<think>好的,用户想了解快速排序冒泡排序和选择排序的定义及原理,还有它们的实现。我需要先回忆这三种算法的基本概念和步骤,然后组织成清晰的中文回答。同时,按照系统级指令,行内学公式要用$...$,独立公式用$$...$$,并且语法正确。还要生成相关问题,引用已有的资料。 首先,快速排序。它的核心是分治法,选一个基准元素,将组分成两部分,比基准小的放左边,大的放右边,然后递归处理子组。时间复杂度平均是$O(n \log n)$,最差$O(n^2)$。需要给出原理说明和Python代码示例。引用中的信息提到快速排序在大规模据上更高效,这点可以引用[^1]。 然后是冒泡排序。它通过相邻元素的比较和交换,每一轮把最大的元素“冒泡”到最后。时间复杂度是$O(n^2)$。用户提供的引用[^2]里有冒泡排序的详细步骤和代码,可以参考,并指出它适合小规模据。 接下来是选择排序。每次从未排序部分选最小元素,放到已排序末尾。时间复杂度同样是$O(n^2)$,但交换次数冒泡少。这里需要自己组织原理说明,因为没有现成的引用。 在代码实现部分,要确保语法正确。比如冒泡排序的双重循环,选择排序的min_index查找。注意用户提供的示例代码里冒泡排序用了while循环,但通常用for循环更直观,可能需要调整。 最后生成相关问题,可以围绕性能比较、优化方法、应用场景展开。比如快速排序的优化、冒泡排序的适用情况、选择排序的优缺点等。 检查是否需要添学公式。例如,快速排序的分治步骤可以用学表达式描述,比如分区的过程。冒泡排序的每一趟比较次数可以用公式表示。但用户提供的引用中没有学公式,可能需要自行补充,但要注意系统指令的要求,行内公式用$...$。 确保所有引用正确标注,比如在快速排序部分提到效率时引用,冒泡排序的步骤引用。 现在开始组织内容,分点讲解每个算法,包括原理、时间复杂度和实现代码。保持语言简洁明了,结构清晰。</think>### 快速排序冒泡排序与选择排序的定义及原理 #### 1. **快速排序** - **原理**:基于分治法(Divide and Conquer)。选择一个基准元素(如第一个元素),将组分为两部分:小于基准的放左边,大于基准的放右边。递归地对左右子组重复此过程,直到排序完成。 - **学描述**:设组为$A$,基准为$p$,分区后满足$A_{\text{left}} \leq p \leq A_{\text{right}}$。 - **时间复杂度**:平均$O(n \log n)$,最差$O(n^2)$(如组已有序时)。 - **代码实现**: ```python def quick_sort(arr): if len(arr) <= 1: return arr pivot = arr[0] left = [x for x in arr[1:] if x <= pivot] right = [x for x in arr[1:] if x > pivot] return quick_sort(left) + [pivot] + quick_sort(right) ``` > **关键点**:分治思想与递归实现。 --- #### 2. **冒泡排序** - **原理**:通过相邻元素的**比较与交换**,每一轮将最大的元素“冒泡”到未排序部分的末尾。 - **学描述**:第$i$趟排序需比较$n-i-1$次相邻元素。 - **时间复杂度**:固定$O(n^2)$,适用于小规模据。 - **代码实现**: ```python def bubble_sort(lst): n = len(lst) for i in range(n): for j in range(n-i-1): if lst[j] > lst[j+1]: lst[j], lst[j+1] = lst[j+1], lst[j] return lst ``` > **特点**:简单但效率低,适合教学或小据集[^2]。 --- #### 3. **选择排序** - **原理**:每次从未排序部分选择**最小元素**,将其与未排序部分的起始位置交换,逐步构建有序序列。 - **学描述**:第$i$趟排序需比较$n-i$次元素。 - **时间复杂度**:$O(n^2)$,但交换次数少于冒泡排序。 - **代码实现**: ```python def selection_sort(arr): n = len(arr) for i in range(n): min_idx = i for j in range(i+1, n): if arr[j] < arr[min_idx]: min_idx = j arr[i], arr[min_idx] = arr[min_idx], arr[i] return arr ``` > **特点**:减少交换次数,但时间复杂度仍较高。 --- ### 对比总结 | 算法 | 时间复杂度(平均) | 稳定性 | 适用场景 | |------------|--------------------|--------|------------------| | 快速排序 | $O(n \log n)$ | 不稳定 | 大规模据 | | 冒泡排序 | $O(n^2)$ | 稳定 | 小规模或部分有序 | | 选择排序 | $O(n^2)$ | 不稳定 | 简单场景 | ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值