常见的排序方法 c++

#include<stdio.h>
#include<iostream>
#include<string.h>
using namespace std;

class sort_scf
{
public:
    int a[20];
    void maopao1(int a[],int len)
    {
        for(int i=0; i<len; i++)
        {
            for(int j=0; j<len-1-i; j++)
            {
                if(a[j]>a[j+1])
                {
                    swap_my(a[j],a[j+1]);
                }
            }
        }
    }
    void maopao2(int a[],int len)
    {
        int flag=true;
        for(int i=0; i<len&&flag; i++)
        {
            flag=false;
            for(int  j=0; j<len-i-1; j++)
            {
                if(a[j]>a[j+1])
                {
                    swap_my(a[j],a[j+1]);
                    flag=true;
                }
            }
        }
    }
    void maopao3(int a[],int len)
    {

        int pos=0;
        int k=len-1;
        int flag;
        for(int i=0; i<len; i++)
        {
            flag=0;
            for(int j=0; j<k; j++)
            {
                if(a[j]>a[j+1])
                {
                    swap_my(a[j],a[j+1]);
                    flag=1;
                    pos=j;
                }
            }
            k=pos;
            if(flag==0)
                return ;
        }
    }
    void jiandan_select(int a[],int len)
    {
        for(int i=0; i<len-1; i++)
        {
            int index=i;
            for(int j=i+1; j<len; j++)
            {
                if(a[j]<a[index])
                {
                    index=j;
                }
            }
            swap_my(a[index],a[i]);
        }
    }
    void charu_sort(int a[],int len)
    {
        for(int i=1; i<len; i++)
        {
            int j;
            for( j=i-1; j>=0; j--)
            {
                if(a[j]<a[i])
                    break;
            }
            if(j!=i-1)
            {
                j++;
                int temp=a[i];
                int k;
                for( k=i; k>j; k--)
                {
                    a[k]=a[k-1];
                }
                a[j]=temp;
            }
        }
    }
    void zheban_charu_sort(int a[],int len)
    {
        for(int i=1; i<len; i++)
        {
            int left=0;
            int right=i-1;
            int temp=a[i];
            while(left<=right)
            {
                int mid=(left+right)/2;
                if(a[mid]<temp)
                {
                    left=mid+1;
                }
                else
                {
                    right=mid-1;
                }
            }
            for(int j=i; j>left; j--)
                a[j]=a[j-1];
            a[left]=temp;
        }
    }
    void shell_sort(int a[],int len)
    {
        cout<<"希尔排序"<<endl;
        for(int gap=len/2; gap>=1; gap/=2)
        {
            for(int i=gap; i<len; i++)
            {
                for(int j=i-gap; j>=0; j-=gap)
                {
                    if(a[j]>a[j+gap])
                        swap_my(a[j],a[j+gap]);
                }
            }
        }
    }
    int quick_solve(int a[],int left,int right)
    {
        int i=0;
        int j=left+1;
        int temp=a[left];
        while(left<right)
        {

            while(left<right&&a[right]>=temp)
                right--;
            if(left<right)
                swap_my(a[left],a[right]);
            while(left<right&&a[left]<=temp)
                left++;
            if(left<right)
                swap_my(a[left],a[right]);
        }

        return left;
    }
    void quick_sort(int a[],int len)
    {
        quick(a,0,len-1);
    }
    void quick(int a[],int left,int right)
    {
        if(left<right)
        {
            int target=quick_solve(a,left,right);
            quick(a,left,target-1);
            quick(a,target+1,right);
        }
    }
    void merge_solve(int a[],int left,int mid,int right)
    {
        int temp[1000];
        memset(temp,0,sizeof(temp));
        int i=left;
        int j=mid+1;
        int k=0;
        while(i<=mid&&j<=right)
        {
            if(a[i]<a[j])
                temp[k++]=a[i++];
            else temp[k++]=a[j++];
        }
        while(i<=mid)
            temp[k++]=a[i++];
        while(j<=right)
            temp[k++]=a[j++];

        for(int i=0; i<k; i++)
            a[i+left]=temp[i];
    }
    void merge_(int a[],int left,int right)
    {
        if(left<right)
        {
            int mid=(left+right)/2;
            merge_(a,left,mid);
            merge_(a,mid+1,right);
            merge_solve(a,left,mid,right);
        }
    }
    void merge_sort(int a[],int len)
    {
        merge_(a,0,len-1);
    }
    void head_build(int a[],int index,int maxx)
    {
        int left=index*2+1;
        int right=left+1;
        int maxx_index=index;
        if(left<maxx&&a[left]>a[maxx_index])
            maxx_index=left;
        if(right<maxx&&a[right]>a[maxx_index])
            maxx_index=right;

        if(maxx_index!=index)
        {
            swap_my(a[index],a[maxx_index]);
            head_build(a,maxx_index,maxx);
        }
    }
    void head_sort(int a[],int len)
    {

        for(int i=len/2-1;i>=0;i--)
            head_build(a,i,len);
        for(int i=len-1;i>=1;i--)
        {
            swap_my(a[0],a[i]);
            head_build(a,0,i);
        }
    }

private:
    void swap_my(int &a,int &b)
    {
        a=a^b;
        b=a^b;
        a=a^b;
    }

};



int  main()
{
    sort_scf solve;
    int ans[20]= {1,2,7,4,8,9,6,3,5,0};
    int b[20];
    memcpy(solve.a,ans,sizeof(int)*20);
    for(int i=0; i<10; i++)
        cout<<solve.a[i]<<" ";
    cout<<endl<<"排序后"<<endl;
//    solve.maopao1(solve.a,10);
//    solve.maopao2(solve.a,10);
    //solve.maopao3(solve.a,10);
    //solve.jiandan_select(solve.a,10);
    //solve.charu_sort(solve.a,10);
    //solve.zheban_charu_sort(solve.a,10);
    // solve.shell_sort(solve.a,10);
//    solve.quick_sort(solve.a,10);
    //solve.merge_sort(solve.a,10);
    solve.head_sort(solve.a,10);
    for(int i=0; i<10; i++)
        cout<<solve.a[i]<<" ";
    cout<<endl;

}