排序算法的代码

冒泡，快速，插入，希尔，选择，堆

#include <iostream>

using namespace std;

///除快速排序由于需要传参递归等问题还未解决，其他五种排序皆已整理成类

class Sort
{
private:
    int *a;
    int n;

public:
    Sort();
    ~Sort();
    void bubbleSort();
    //void Quick_Sort(int *arr,int begin_,int end_);
    void insertsort();
    void shellsort();
    void selectSort();
    void heapsort();
};

Sort::Sort()
{
    int v;
    cin>>v;
    a=new int[100];
    n=v;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
    }
}

Sort::~Sort()
{
    for(int i=1;i<=n;i++)
    {
        cout<<a[i]<<'\0';
    }
    delete[] a;
}

void Sort::bubbleSort()
{
    for(int i=1;i<n;i++)
    {
        for(int j=1;j<n-i+1;j++)
        {
            if(a[j]>a[j+1])
            {
                a[0]=a[j];
                a[j]=a[j+1];
                a[j+1]=a[0];
            }
        }
    }
}

void Quick_Sort(int *arr,int begin_,int end_)///快速排序(无问题)
{

    if(begin_>end_)
        return;

    int tmp=arr[begin_];///基数

    int i =begin_;///哨兵
    int j =end_;

    while(i != j)
    {
        while(arr[j] >= tmp && j > i)///比较中
            j--;
        while(arr[i] <= tmp && j > i)
            i++;

        if(j > i)///哨兵交换
        {
            int t=arr[i];
            arr[i]=arr[j];
            arr[j]=t;
        }
    }

    arr[begin_]=arr[i];///移动基数
    arr[i]=tmp;

    Quick_Sort(arr,begin_,i-1);///递归迭代
    Quick_Sort(arr,i+1,end_);
}

void Sort::insertsort()///插入排序(无问题)
{
    int i,j;
    for(i=2;i<=n;i++)
    {
        a[0]=a[i];
        j=i-1;
        while(a[0]<a[j])
        {
            a[j+1]=a[j];
            j--;
        }
        a[j+1]=a[0];
    }
}

void Sort::shellsort()///希尔排序——以插入排序为基础
{
    int i,j,d;
    for(d=n/2;d>=1;d=d/2)///外循环用来计算间隔
    {
        for(i=d+1;i<=n;i++)
        {
            j=i-d;
            a[0]=a[i];
            while(j>0&&a[0]<a[j])
            {
                a[j+d]=a[j];
                j=j-d;
            }
            a[j+d]=a[0];
        }

    }

}

void Sort::selectSort()///简单选择排序(已测试，无问题)
{
    for(int i=1;i<=n-1;i++)
    {
        int index=i;
        for(int j=i+1;j<=n;j++)
        {
            //cout<<a[j];
            if(a[index]>a[j])///找到最小数据
            {
                index=j;
            }
        }
        //cout<<endl;
        if(index!=i)
        {
            a[0]=a[i];
            a[i]=a[index];
            a[index]=a[0];
        }
    }
}

void sift(int a[],int k,int end_)///堆调整函数
{
    int i,j;
    i=k,j=2*i;///i是根节点，j是左孩子，j+1是右孩子
    while(j<=end_)
    {
        if(j<end_&&a[j]<a[j+1])///有右孩子且右孩子较大
        {
            j++;///选出左右孩子中的较大者
        }
        
        if(a[i]<a[j])
        {
            //exchange(a[i],a[j]);
            a[0]=a[i];
            a[i]=a[j];
            a[j]=a[0];
        }
        i=j;
        j=2*i;
    }
}

void Sort::heapsort()///(已测试，无问题)
{
    int k;
    for(k=n/2;k>=1;k--)///n/2是最后一个节点的根节点
    {
        sift(a,k,n);///由下而上创建大根堆
    }
    
    for(k=1;k<n;k++)
    {
        ///移走栈顶元素
        a[0]=a[1];
        a[1]=a[n-k+1];
        a[n-k+1]=a[0];
        
        sift(a,1,n-k);///由上而下调整大根堆
    }
}

int main()
{
    Sort p;
    p.heapsort();

    return 0;
}