2021-09-15

「已注销」

于 2021-09-15 22:20:51 发布

阅读量78

点赞数 1

文章标签： c语言 c++

本文链接：https://blog.csdn.net/m0_55824630/article/details/120316252

版权

本文介绍了四种常见的排序算法——插入排序、冒泡排序、选择排序和希尔排序的C/C++实现，包括升序输出、交换次数统计及稳定性的分析。示例代码详细展示了每种排序方法的步骤，并提供了输入输出示例，帮助读者理解和应用这些排序算法。

摘要由CSDN通过智能技术生成

001排序（利用C或C++）

1. 插入排序（C）

编写一个程序，升序输出。并输出各计算步骤的数组。
方法：将开头元素视作已排序，执行下述处理，直至未排序部分消失：
1.取出未排序部分的开头元素赋给变量v。
2.在已排序部分，将所有比v大的元素向后移动一个单位。
3.将已取出的元素v插入空位。

输入示例：
6
5 2 4 6 1 3
输出示例：
5 2 4 6 1 3
2 5 4 6 1 3
2 4 5 6 1 3
2 4 5 6 1 3
1 2 4 5 6 3
1 2 3 4 5 6

#include <stdio.h>
/*按顺序输出数组元素*/
void trace(int A[],int N){
    int i;
    for(i=0;i<N;i++){
        if(i>0)printf(" ");
        printf("%d",A[i]);
    }
    printf("\n");
}
/*插入排序*/
void insertionSort(int A[],int N){
    int j,i,v;
    for(i=1;i<N;i++){
        v=A[i];
        j=i-1;
        while (j>=0&&A[j]>v) {
            A[j+1]=A[j];
            j--;
        }
        A[j+1]=v;
        trace(A,N);
    }
}
int main()
{
    int N,i;
    int A[100];
    scanf("%d",&N);
    for(i=0;i<N;i++)scanf("%d",&A[i]);
    trace(A,N);
    insertionSort(A,N);
    return 0;
}

2. 冒泡排序（C++）

编写一个程序，升序输出。并报告冒泡排序执行元素交换次数。
方法：重复执行下述处理，直到数组中不包含顺序相反的相邻元素：从数组末尾开始依次比较相邻两个元素，如果大小相反则交换位置。

输入示例：
5
5 3 2 4 1
输出示例：
1 2 3 4 5
8

#include <iostream>
using namespace std;
int bubbleSort(int A[],int N){
    int sw=0;
    bool flag=1;
    for(int i=0;flag;i++){
        flag=0;
        for(int j=N-1;j>=i+1;j--){
            if(A[j]<A[j-1]) //交换相邻元素
            {
                swap(A[j],A[j-1]);
                flag=1;
                sw++;
            }
        }
    }
    return sw;
}
int main()
{
    int A[100],N,sw;
    cin>>N;
    for(int i=0;i<N;i++)
        cin>>A[i];
    sw=bubbleSort(A,N);
    for(int i=0;i<N;i++){
        if(i)cout<<" ";
        cout<<A[i];
    }
    cout<<endl;
    cout<<sw<<endl;
    return 0;
}

3. 选择排序（C）

编写一个程序，升序输出。并报告执行元素交换次数。
方法：重复执行N-1次下述处理：
1.找出未排序部分的最小值的位置minj。
2.将minj位置的元素与未排序部分的起始元素交换。

输入示例：
6
5 6 4 2 1 3
输出示例：
1 2 3 4 5 6
4

#include <stdio.h>
/*选择排序法*/
int selectionSort(int A[],int N){
    int i,j,t,sw=0,minj;
    for(i=0;i<N-1;i++){
        minj=i;
        for(j=i;j<N;j++)
            if(A[j]<A[minj])
                minj=j;
        t=A[i];
        A[i]=A[minj];
        A[minj]=t;
        if(i!=minj)
            sw++;
    }
    return sw;
}
int main()
{
    int A[100],N,i,sw;
    scanf("%d",&N);
    for(i=0;i<N;i++)
        scanf("%d",&A[i]);
    sw=selectionSort(A,N);
    for(i=0;i<N;i++){
        if(i>0)
            printf(" ");
        printf("%d",A[i]);
    }
    printf("\n");
    printf("%d\n",sw);
    return 0;
}

4. 稳定排序（C++）

要求：输入：在第1行输入扑克牌张数，第2行输入N张扑克牌的数据，每张牌由代表花色和数字的2个字符组成，相邻扑克牌之间用1个空格隔开；输出：在第1行按顺序输出经冒泡排序法排序后的扑克牌，相邻扑克牌之间用1个空格隔开，第2行输出该输出经选择排序法排序后的扑克牌，相邻扑克牌之间用1个空格隔开，在第4行输出该输出是否稳定。

输入示例：
5
H4 C9 S4 D2 C3
输出示例：
D2 C3 H4 S4 C9
Stable
D2 C3 S4 H4 C9
Not stable

#include <iostream>
using namespace std;

struct Card{
    char suit,value;
};

void bubble(struct Card A[],int N){
    for(int i=0;i<N;i++){
        for(int j=N-1;j>=i;j--){
            if(A[j].value<A[j-1].value){
                Card t=A[j];
                A[j]=A[j-1];
                A[j-1]=t;
            }
        }
    }
}

void selection(struct Card A[],int N){
    for(int i=0;i<N;i++){
        int minj=i;
        for(int j=i;j<N;j++){
            if(A[j].value<A[minj].value)
                minj=j;
        }
        Card t=A[i];
        A[i]=A[minj];
        A[minj]=t;
    }
}

void print(struct Card A[],int N){
    for(int i=0;i<N;i++){
        if(i>0)
            cout<<" ";
        cout<<A[i].suit<<A[i].value;
    }
    cout<<endl;
}

//比较冒泡排序和选择排序的结果
bool isStable(struct Card C1[],struct Card C2[],int N){
    for(int i=0;i<N;i++){
        if(C1[i].suit!=C2[i].suit)
            return false;
    }
    return true;
}
int main()
{
    Card C1[100],C2[100];
    int N;
    cin>>N;
    for(int i=0;i<N;i++){
        cin>>C1[i].suit>>C1[i].value;
    }
    for(int i=0;i<N;i++)
        C2[i]=C1[i];
    bubble(C1,N);
    selection(C2,N);
    print(C1,N);
    cout<<"Stable"<<endl;
    print(C2,N);
    if(isStable(C1,C2,N)){
        cout<<"Stable"<<endl;
    }
    else{
        cout<<"Not stable"<<endl;
    }
    return 0;
}

5. 希尔排序法（C++）

要求：输入：第1行输入整数n，接下来n行输入n个整数A_i (i=0，1，…，n-1）；输出：第1行输出整数吗，第2行输出m个整数G_i（i=0，1，…，m-1），用空格隔开，第3行在使用G的程序执行完毕后输出cnt的值，接下来n行输出排序完毕的A_i(i=0，1，…，n-1）。

输出示例：
5
5
1
4
3
2
输出示例：
2
4 1
3
1
2
3
4
5

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

long long cnt;
int l;
int A[1000000];
int n;
vector<int>G;

//指定了间隔g的插入排序
void insertionSort(int A[],int n,int g){
    for(int i=g;i<n;i++){
        int v=A[i];
        int j=i-g;
        while (j>=0&&A[j]>v) {
            A[j+g]=A[j];
            j-=g;
            cnt++;
        }
        A[j+g]=v;
    }
}

void shellSort(int A[],int n){
    //生成数列G={1,4,13,40,121,364,1093,...}
    for(int h=1;;){
        if(h>n)break;
        G.push_back(h);
        h=3*h+1;
    }
    for(int i=G.size()-1;i>=0;i--){//按逆序指定G[i]=g
        insertionSort(A,n,G[i]);
    }
}

int main()
{
    cin>>n;
    //使用速度更快的scanf函数进行输入
    for(int i=0;i<n;i++)
        scanf("%d",&A[i]);
    cnt=0;
    shellSort(A,n);
    cout<<G.size()<<endl;
    for(int i=G.size()-1;i>=0;i--){
        printf("%d",G[i]);
        if(i)
            printf(" ");
    }
    printf("\n");
    printf("%d\n",cnt);
    for(int i=0;i<n;i++)
        printf("%d\n",A[i]);
    return 0;
}