排序技术 (细节待补充)

Posted 2022-06-09 钟钟终

排序的分类：

待排序的所有记录是否全部被放在内存中，分为内排序和外排序：
内排序：待排序的所有记录全部被放在内存中
外排序：由于待排序记录的个数太多，不能同时放置在内存中，需要将一部分记录放置在内存中，一部分放置在外存，整个排序过程需要在内外存之间多次交换才可得到结果。

排序方法是否建立在关键码比较的基础上，分为基于比较的排序和不基于比较的排序：
基于比较的排序：插入排序、交换排序、选择排序、归并排序
不基于比较的排序：根据待排序的特点所排序的其他方法。通常美哦与大量的关键码的比较和移动

稳定性和不稳定性：相同关键码的相对次序不变。

#include <bits/stdc++.h>

using namespace std;
const int N=1e4+5;
class Sort

public:
    Sort(int a[],int n);
    ~Sort();
    void ins_();
    void shell_();
    void bubble_();
    void quick_(int fs,int ls);
    void select_();
    void heap_();
    void merge_(int fs,int ls);
    void display(string s);
    void shuff()    random_shuffle(data,data+n);
private:
    int part_(int fs,int ls);
    void sift(int k,int ls);
    void mg(int fs1,int ls1,int ls2);
    int* data;
    int n;      //n表示长度
;
Sort::Sort(int a[],int n_)

    data=new int[n_];
    for(int i=0;i<n_;i++)
        data[i]=a[i];
    n=n_;

Sort::~Sort()

    delete[] data;

void Sort::display(string s)

    cout<<"打乱顺序后 "<<s<<endl;
    for(int i=0;i<n;i++)
        cout<<data[i]<<" ";
    cout<<endl;

void Sort::ins_() //插入排序

    for(int i=1;i<n;i++)
    
        int tmp=data[i];
        int j;
        for(j=i-1;j>=0&&data[j]>tmp;j--)
            data[j+1]=data[j];
        
        data[j+1]=tmp;
    

void Sort::shell_()  //改进插入排序，希尔排序

    for(int d=n/2;d>=1;d--)
    
        for(int i=d;i<n;i++)
        
            int tmp=data[i],j;
            for(j=i-d;j>=0&&tmp<data[j];j-=d)
                data[j+d]=data[j];
            data[j+d]=tmp;
        
    

void Sort::bubble_()

    int exchange=n-1,tmp,bound;
    while(exchange!=0)
    
        bound=exchange;
        exchange=0;
        for(int i=0;i<bound;i++)
        
            if(data[i]>data[i+1])
            
                tmp=data[i],data[i]=data[i+1],data[i+1]=tmp;
                exchange=i;
            
        
    

int Sort::part_(int fs,int ls)

    int i=fs,j=ls,tmp;
    while(i<j)
    
        while(i<j&&data[i]<=data[j]) j--;
        if(i<j)
        
            int tmp=data[i];
            data[i]=data[j],data[j]=tmp;
            i++;
        
        while(i<j&&data[i]<=data[j]) i++;
        if(i<j)
        
            int tmp=data[i];
            data[i]=data[j],data[j]=tmp;
            j--;
        
    
    return i;

void Sort::quick_(int fs,int ls)  //快速排序

    if(fs>=ls) return;
    else
    
        int pivot=part_(fs,ls);
        quick_(fs,pivot-1);
        quick_(pivot+1,ls);
    

void Sort::select_()   //选择排序

    for(int i=0;i<n;i++)
    
        int j,index=i,tmp;
        for(j=i+1;j<n;j++)
            if(data[j]<data[index])
                index=j;
        if(index!=i)
            tmp=data[i],data[i]=data[index],data[index]=tmp;
    

void Sort::sift(int k,int ls)

    int i=k,tmp,j;
    j=2*i+1;        //左孩子
    while(j<=ls)
    
        if(j<ls&&data[j]<data[j+1])  //一个小细节
            j++;
        if(data[i]>data[j])
            break;
        else
        
            tmp=data[i],data[i]=data[j],data[j]=tmp;
            i=j;j=2*i+1;
        
    

void Sort::heap_()

    int tmp;
    for(int i=n/2;i>=0;i--)
        sift(i,n-1);
    for(int i=1;i<n;i++)
        tmp=data[0];data[0]=data[n-i];data[n-i]=tmp;
        sift(0,n-i-1);
    

void Sort::mg(int fs1,int ls1,int ls2)

    int* tmp=new int[n];
    int i=fs1,j=ls1+1,k=fs1;
    while(i<=ls1&&j<=ls2)
    
        if(data[i]<data[j])
            tmp[k++]=data[i++];
        else
            tmp[k++]=data[j++];
    
    while(i<=ls1)
        tmp[k++]=data[i++];
    while(j<=ls2)
        tmp[k++]=data[j++];
    for(int i=fs1;i<=ls2;i++)
        data[i]=tmp[i];
    delete[] tmp;

void Sort::merge_(int fs,int ls)

    if(ls==fs)  return;
    int mid=ls+fs>>1;
    merge_(fs,mid);
    merge_(mid+1,ls);
    mg(fs,mid,ls);

int main()

/* 测试样例：
5
5 4 3 2 1
*/
    int n,a[N];
    cin>>n;
    for(int i=0;i<n;i++)
        cin>>a[i];
    Sort st=Sort(a,n);
    st.ins_();
    st.display("插入排序结果如下:");
    st.shuff();
    st.display("排列如下---------------：");

    st.shell_();
    st.display("希尔排序结果如下:");
    st.shuff();
    st.display("排列如下---------------：");

    st.bubble_();
    st.display("冒泡排序结果如下:");
    st.shuff();
    st.display("排列如下----------------：");

    st.quick_(0,n-1);
    st.display("快速排序结果如下:");
    st.shuff();
    st.display("排列如下----------------：");
    st.select_();
    st.display("选择排序结果如下:");
    st.select_();
    st.display("排列如下----------------：");
    st.heap_();
    st.display("堆排序结果如下:");
    st.shuff();
    st.display("排列如下----------------：");
    st.merge_(0,n-1);
    st.display("二路归并排序结果如下:");

    return 0;