基本排序算法的练习

最新推荐文章于 2022-02-25 23:02:56 发布

jedihy

最新推荐文章于 2022-02-25 23:02:56 发布

阅读量863

点赞数

文章标签： C 算法插入排序冒泡排序快速排序

本文链接：https://blog.csdn.net/jedihy/article/details/14222137

版权

插入排序：

思想：每一次插入使得子序列是排好序的序列，时间复杂度O(n^2)。

#include "iostream"
using namespace std;
int main(int argc, char *args[])
{
#define KLEN 10
    int k[KLEN]={1,5,7,2,4,8,2,9,3,6};
    for (int i=0;i <KLEN;i++)
    {
        cout<<k[i]<<endl;
    }
    cout<<"==========>"<<endl;
    for(int i = 1;i<KLEN;i++)
    {
        int tmp = k[i];
        int j = i -1;
        while(j >=0&&k[j]>tmp)
        {
            k[j+1] = k[j];
            --j;
        }
        k[j+1] = tmp;
    }
    for (int i =0;i<KLEN;i++)
    {
        cout<<k[i]<<endl;
    }
    
    return 0;
}

选择排序：

每次找出当前序列中的最值并放到何时的位置，时间复杂度O(n^2)。

#include "iostream"
using namespace std;
int main(int argc, char *args[])
{
#define KLEN 10
    int k[KLEN]={1,5,7,2,4,8,2,9,3,6};
    for (int i=0;i <KLEN;i++)
    {
        cout<<k[i]<<endl;
    }
    cout<<"==========>"<<endl;
    //算法开始
    for(int i = 0;i<KLEN-1;i++)
    {
        int tmp = k[i];
        int minindex=i;
        int mink = 999;
        for(int j=i;j<KLEN;++j){
            if(k[j] < mink){
                mink = k[j];
                minindex = j;
            }
        }
        k[minindex]=tmp;
        k[i]=mink;
    }
    //算法结束
    for (int i =0;i<KLEN;i++)
    {
        cout<<k[i]<<endl;
    }
    getchar();
    return 0;
}

冒泡排序：

每次判断两个相邻元素的大小，第一次遍历后，最值元素就到了正确的位置，第二次遍历次最值元素就到了正确位置，以此类推。时间复杂度O(n^2)。

#include "iostream"
using namespace std;
int main(int argc, char *args[])
{
#define KLEN 10
    int k[KLEN]={1,5,7,2,4,8,2,9,3,6};
    for (int i=0;i <KLEN;i++)
    {
        cout<<k[i]<<endl;
    }
    cout<<"==========>"<<endl;
    //算法开始
    for(int i = 1;i<KLEN;i++)
    {
        for(int j=i;j>0;--j){
            if(k[j-1] > k[j]){
                int tmp=k[j];
                k[j] = k[j-1];
                k[j-1] = tmp;
            }
        }
    }
    //算法结束
    for (int i =0;i<KLEN;i++)
    {
        cout<<k[i]<<endl;
    }
    getchar();
    return 0;
}

归并排序：（有哨兵版本的归并排序）

归并排序的思想是，每次都把序列二分，不断的递归，直到序列已经不可分，然和进行合并。合并的过程是对两个有序序列的合并（排序），最后整个序列合并完，就排序好了。程序实现分有哨兵版和无哨兵版，这是合并的时候程序设计的需要，时间复杂度O(nlogn)。

#include "iostream"
#include <windows.h>
#define KLEN 16
using namespace std;
void mergefinal(int k[],int p,int q,int r){
    int a[KLEN]={0};
    int L[KLEN]={0};
    int R[KLEN]={0};
    int sntl =0;
    for(sntl=0;sntl<q-p+1;sntl++)
        L[sntl]=k[p + sntl];
    L[sntl]=9999;
    for(sntl=0;sntl<q-p+1;sntl++)
        R[sntl]=k[q + 1 + sntl];
    R[sntl]=9999;
    int i = r - p + 1;
    int subarraylen = i;
    int j=0;
    int l=0,t=0;
    for(int j=p;j<=r;j++){
        if(L[l]<R[t])
        {
            k[j]=L[l];
            l++;
        }
        else
        {
            k[j]=R[t];
            t++;
        }
    }
}

void mergesort(int k[],int start,int end)
{
    cout<<"start="<<start<<" end="<<end<<endl;
    if(start < end){
        mergesort(k,start,(end+start)/2);
        mergesort(k,((end+start)/2)+1,end);
        cout<<"start="<<start<<"mid="<<(end+start)/2<<"end="<<end<<endl;
        mergefinal(k,start,(end+start)/2,end);
    }
}
int main(int argc, char *args[])
{
    int k[KLEN]={2,5,7,2,4,8,2,9,3,6,0,4,11,18,13,17};
    for (int i=0;i <KLEN;i++)
    {
        cout<<k[i]<<endl;
    }
    cout<<"==========>"<<endl;
    
    mergesort(k,0,KLEN-1);
    cout<<"==========>"<<endl;
    for (int i =0;i<KLEN;i++)
    {
        cout<<k[i]<<endl;
    }
    return 0;
}

归并排序：（无哨兵版本的归并排序）

#include "iostream"
#include <windows.h>
#define KLEN 16
using namespace std;
void mergefinal(int k[],int p,int q,int r){
    int a[KLEN]={0};
    int L[KLEN]={0};
    int R[KLEN]={0};
    int sntl =0,j=0,l=0,t=0;
    for(sntl=0;sntl<q-p+1;sntl++)
        L[sntl]=k[p + sntl];
    for(sntl=0;sntl<q-p+1;sntl++)
        R[sntl]=k[q + 1 + sntl];
    for(int j=p;j<=r;j++){
        if((l<q-p+1)&&(t<q-p+1))
            k[j]=(L[l]<R[t])?L[l++]:R[t++];
        else
            k[j]=(l >= q-p+1)?R[t++]:L[l++];//l>=q-p+1表示L[]里面的元素已经全部到新数组里面去了，这是只要把R[]里面的元素再放进去就是排好序的了
    }
}
void mergesort(int k[],int start,int end)
{
    cout<<"start="<<start<<" end="<<end<<endl;
    if(start < end){
        mergesort(k,start,(end+start)/2);
        mergesort(k,((end+start)/2)+1,end);
        mergefinal(k,start,(end+start)/2,end);
    }
}
int main(int argc, char *args[])
{
    int k[KLEN]={2,5,7,2,4,8,2,9,3,6,0,4,11,18,13,17};
    for (int i=0;i <KLEN;i++)
    {
        cout<<k[i]<<endl;
    }
    cout<<"==========>"<<endl;
    mergesort(k,0,KLEN-1);
    cout<<"==========>"<<endl;
    for (int i =0;i<KLEN;i++)
    {
        cout<<k[i]<<endl;
    }
    return 0;
}

快速排序：也是分治的思想，在一组数挑一个数，分出比这个数大的数，和比这个数小的数，（分数的过程可以用交换的方法，我这里用的是新开数组）然后递归这个过程。快排的平均时间复杂度是O(nlogn)。

#include <iostream>
#define LEN 8
using namespace std;

void quicksort(int k[],int p,int r){
    if(p<r){
        int L[LEN]={0},R[LEN]={0},A[LEN]={0};
        int key = k[p],l=0,t=0;
        for(int i=p+1;i<=r;i++){
            if(k[i]<key)
                L[l++]=k[i];
            else
                R[t++]=k[i];
        }
        for(int i=0;i<l;i++){
            k[p+i]=L[i];
        }
        k[p+l]=key;
        for(int i=0;i<t;i++){
            k[p+l+1+i]=R[i];
        }
    quicksort(k,p,p+l-1);
    quicksort(k,p+l+1,r);
    }
}
int main()
{
    int k[LEN]={3,6,7,5,2,1,8,4};
    for(int i=0;i<LEN;i++)
        cout<<k[i];
    cout<<"=============>"<<endl;
    quicksort(k,0,LEN-1);
    cout<<"=============>"<<endl;
    for(int i=0;i<LEN;i++)
        cout<<k[i];
    getchar();
    return 0;
}