【数据结构】实验2_排序算法 A排序算法_实验2-2 按长度排序-CSDN博客

本文链接：https://blog.csdn.net/m0_72629485/article/details/132940012

要求

不得使用与实验相关的STL
需使用类模版(template<class T>)
需定义排序类，封装各排序方法
排序数据需使用动态数组存储
排序类需提供以下操作：名次排序、及时终止的选择排序、及时终止的冒泡排序、插入排序

描述

用任意一种排序方式给出n个整数按升序排序后的结果

格式

输入

输入的第一行是一个整数 n(1<=n<=1000)，表示需排序的数的个数。接下来一行是 n 个整数，数的范围是 0 到 1000，每两个相邻数据间用一个空格分隔。

输出

一行排好序的序列

样例一

输入

5
5 3 4 2 1

输出

1 2 3 4 5

限制

1s, 1024KiB for each test case.

Source

Provided by cy

主要思想

原地重排（名次）：计算数组中元素的名次，将元素交换到索引为名次的位置
选择排序：在数组的前size长度中，选择最大的元素交换到数组的末尾
冒泡排序：在数组的前size长度中，相邻元素两两相比，每次都将当前最大的元素沉到数组末尾
插入排序：将数组中当前有序部分的后一个元素插入前面的有序部分中
及时终止的xx排序：若当前数组有序（数组中相邻元素，后>前），则不再进行相关主要操作，直接退出

思路分析

使用类模板，将各个排序写出来，进行封装

经典排序算法总结

名次排序

首先进行名次的计算：所有比它小的元素加上在他左边出现的与他相同的元素个数;
- 比较次数：n(n-1)/2
- 示例代码：

    template<class T>
    void rank(T a[],int n,int r[]){
        //给数组a[0:n-1]的n个元素排名次
        //结果在r[0:n-1]中返回
        for(int i=0;i<n;i++){
            r[i]=0;//初始化
        }
        //比较所有元素对
        for(int i=1;i<n;i++){
            for(int j=0;j<i;j++){
                if(a[j]<a[i]) r[i]++;//如果前面的元素小于本元素，名次+1
                else r[j]++;//说明前面的元素比本元素大，那么前面的元素名次+1
            }
        }
    }

利用附加数组u，将元素移到与其名次对应的位置，递增排序（计数排序（count sort))
- 元素移动次数：2n
- 比较次数：(n-1)n/2
- 动图展示：
- 示例代码：

template<class T>
void rearrange(T a[],int n,int r[]){
    //使用一个附加数组u，将元素排序
    T *u=new T [n];//创建附加数组
    //把a中元素移到u中正确位置
    for(int i=0;i<n;i++)
        u[r[i]]=a[i];
    //把u中元素移回a
    for(i=0;i<n;i++)
    a[i]=u[i];
    delete []u;
    
}

改进：无需数组u，原地重排数组元素
- 利用数组索引，检查是否与名次相同。若相同，检查下一个；若不同，将索引为i和r[i]的元素交换。把原来索引为i的元素移到按名次排列的位置，直到r[i]=i
- 分析：最少交换0次，最多交换2(n-1)次（包括名次交换）
- 代码实现

template<class T>
void rearrange(T a[],int n,int r[]){
    for(int i=0;i<n;i++){
        while(r[i]!=i){
            int t=r[i];
            swap(a[i],a[t]);//交换元素
            swap(r[i],r[t]);//交换名次
        }
    }
}

选择排序

查找最大元素，移到序列最后
及时终止的选择排序：在查找最大元素的同时检查序列是否有序，可以减少不必要的迭代。即直接将查找最大元素的循环语句与选择排序的函数合在一起。
- 利用bool值sort来标记是否有序，初始置为false
- 外层循环，控制排序的轮数。每一轮选择排序都会将最大的元素放到已排序部分的末尾，因此循环的终止条件是 !sort（即未完成排序）和 size>1（数组大小大于1）。
- 每一轮开始时将 sort 设为 true，假设当前轮次已经完成排序。并定义变量，用来记录当前轮次中最大元素的索引
- 内层循环，从第二个元素开始遍历待排序的部分。如果当前元素 a[i] 大于等于当前轮次中已记录的最大元素 a[indexMax]，则更新 indexMax。如果存在比已记录最大元素更小的元素，说明当前轮次还没有完成排序，将 sort 设为 false。
- 动图展示：

template<class T>
void selectionSort(T a[], int n) {
    bool sort = false;
    for (int size = n; !sort && (size > 1); size--) {
        int indexMax = 0;
        sort = true;
        for (int i = 1; i < size; i++) {
            if (a[indexMax] <= a[i])
                indexMax = i;
            else
                sort = false; // 无序
            swap(a[indexMax], a[size - 1]);
        }
    }
}

冒泡排序

每次冒泡依次比较相邻元素，并将相邻元素的较大元向右移动，每一次会把最大的换至最右，并重复这一操作。
及时终止：在一次冒泡过程中没有发生元素交换，说明可以提前终止
动图展示

template<class T>
bool bubble(T a[], int n) {
    bool swapped = false; // 目前为止未交换
    for (int i = 0; i < n - 1; i++) {//控制冒泡的轮数
        if (a[i] > a[i + 1]) {
            swap(a[i], a[i + 1]);
            swapped = true; // 进行了交换
        }
    }
    return swapped;
}

template<class T>
void bubbleSort(T a[], int n) {
    for (int i = n; i > 1 && bubble(a, i); i--);//控制排序轮数
}

插入排序

从第一个元素开始，该元素可以认为已经被排序；
取出下一个元素，在已经排序的元素序列中从后向前扫描；
如果该元素（已排序）大于新元素，将该元素移到下一位置；
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
将新元素插入到该位置后；
重复步骤2~5。

插入排序算法的时间复杂度为 O(n^2)，在最坏情况下需要进行 n(n-1)/2 次比较和交换操作
动图展示：

template<class T>
void insertSort(T a[],int n){
    for(int i=1;i<n;i++){//从第二个元素开始遍历待排序的部分
        T t=a[i];//存储当前待排序的元素值
        int j;//在已排序部分中逆序遍历，找到插入位置
        for(j=i-1;j>=0 && t<a[j];j--)//内层循环，找插入位置，终止条件有两个
            a[j+1]=a[j];
        a[j+1]=t;
    }
}

AC代码

#include<iostream>
using namespace std;
template<class T>
class Solution{
public:
    void swap(T &a,T &b);//引用传递
    void rankSort(T a[],int n);//名次排序
    void selectionSort(T a[],int n);//及时终止的选择排序
    bool bubble(T a[],int n);//冒泡
    void bubbleSort(T a[],int n);//及时终止的冒泡排序
    void insertSort(T a[],int n);//插入排序
};
//交换函数
template<class T>
void Solution<T>::swap(T &a,T &b){
    T t=a;
    a=b;
    b=t;
}
//名次排序
template<class T>
void Solution<T>::rankSort(T a[],int n){
    //计算名次
    int *r=new int[n];
    for(int i=0;i<n;i++)
        r[i]=0;
    for(int i=1;i<n;i++){
        for(int j=0;j<i;j++)
            if(a[j]<a[i]) r[i]++;
            else r[j]++;
    }
    //原地重排
    for(int i=0;i<n;i++){
        while(r[i]!=i){//名次不对应
            int t=r[i];
            swap(a[i],a[t]);
            swap(r[i],r[t]);
        }
    }
    delete[] r;
}
//及时终止的选择排序
template<class T>
void Solution<T>::selectionSort(T a[],int n){
    bool sorted=false;
    for(int size=0;!sorted && (size>1);size--){//控制排序轮数
        int indexMax=0;
        sorted=true;
        for(int i=0;i<size;i++){//排序
            if(a[indexMax]<=a[i]) indexMax=i;
            else sorted=false;//无序
        }
        swap(a[indexMax],a[size-1]);
    }
}
//及时终止的冒泡排序
template<class T>
bool Solution<T>::bubble(T a[],int n){
    bool swapped=false;//目前为交换
    for(int i=0;i<n;i++){
        if(a[i]>a[i+1]){
            swap(a[i],a[i+1]);
            swapped=true;//交换了
        }
    }
    return swapped;
}
template<class T>
void Solution<T>::bubbleSort(T a[],int n){
    for(int i=n;i>1 && bubble(a,i);i--);
}
//插入排序
template<class T>
void Solution<T>::insertSort(T a[],int n){
    for(int i=1;i<n;i++){//从第二个元素开始遍历未排序部分
        T t=a[i];//存储当前待排元素值
        int j;
        for(j=i-1;j>=0 && t<a[j];j--)//找插入位置
            a[j+1]=a[j];
        a[j+1]=t;
    }
}
int main(){
    int n;
    cin>>n;
    int *a=new int[n];
    for(int i=0;i<n;i++)
        cin>>a[i];
    Solution<int> solution;
    solution.rankSort(a,n);
    for(int i=0;i<n;i++){
        cout<<a[i]<<" ";
    }
    delete[] a;
    return 0;
}