常用排序算法

打印输出数组函数：

void print(int a[],int n)
{
    for(int i=0;i<n;i++)
    {
        cout<<a[i]<<" ";
    }
    cout<<endl;
}

简单选择排序：

void sort(int a[],int n)
{
    for(int i=0;i<n;i++)
    {
        int key_num=i;
        for(int j=i+1;j<n;j++)
        {
            if(a[key_num] > a[j])
                key_num = j;   //选择最小元素位置；
        }
        if(key_num != i)
        {
            int temp = a[i];    a[i]=a[key_num];    a[key_num]=temp;
        }
    }
}

二元选择排序：

void sort(int a[],int n)
{
    for(int i=0;i<=n/2;i++)
    {
        int min=i,max=i;
        for(int j=i+1;j<n-i;j++)
        {
            if(a[max]<a[j])  //每次循环找到最大值；
            {   max = j; continue;   }
            
            if(a[min]>a[j])  //每次循环找到最小值；
                min = j;
        }
 
        //找到最小的数据交换
        int temp = a[i];   a[i] =a[min];   a[min] = temp;
        
        if (max ==i)
        {     //此时 a[i]已经被a[min]替换了
            temp = a[n-i-1];  a[n-i-1] = a[min];   a[min] = temp;
        }
        else
        {   //找到最大的数据交换
            temp = a[n-i-1];  a[n-i-1] = a[max];   a[max] = temp;
        }
    }
}

直接插入排序：

void sort(int a[],int n)         //时间复杂度：O(n^2)
{          
    for(int i=0;i<n;i++)
    {
        if(a[i]<a[i-1])
        {
            int j=i-1,x=a[i];
            a[i] = a[i-1];
            while(x < a[j])
            {
                if(--j < 0)  break;
                a[j+1] = a[j];
            }
            a[j+1] = x;
        }
    }
}

希尔排序：

void sort(int a[],int n)       //时间复杂度不固定;
{
    int dclk = int(n/2);      //定义增量；
    while(dclk >= 1)
    {
        for(int i=dclk;i<n;i++)
        {
            if(a[i] < a[i-dclk])
            {
                int j = i-dclk,x = a[i];
                a[i] = a[i-dclk];
                while(x < a[j])
                {
                    j -= dclk;
                    if(j<0) break;
                    a[j+dclk] = a[j];
                }
                a[j+dclk] = x;
            }
        }
        dclk = int(dclk/2);     //一步步缩小增量，直至为1；
    }
}

堆排序：

void heap_adjust(int a[],int p,int n)    //调整队列成为堆；
{
    int temp=a[p],child=2*p+1;        //child左子节点的位置；
    while(child<n)
    {
        if(child+1<n && a[child]<a[child+1])
            child++;
        if(a[p]<a[child])        //较大的子节点大于父节点；
        {
            a[p]=a[child];  p=child;    child=2*p+1;
        }
        else
            break;
        a[p]=temp;      //当前待调整的节点放到比其大的子节点上；
    }
}

void sort(int a[],int n)     //堆排序，最坏的情况下，时间复杂度也为 O
{
    for(int i=(n-1)/2;i>=0;i--)
    {
        heap_adjust(a,i,n);
    }
    for(int j=n-1;j>0;j--)
    {
        int temp=a[j];  a[j]=a[0];  a[0]=temp;
        heap_adjust(a,0,j);
    }
}

冒泡排序_1：

void sort(int a[],int n)
{
    int i=n-1;       //初始时，最后位置保持不变；
    while(i>0)
    {
        int pos=0;
        for(int j=0;j<i;j++)
        {
            if(a[j]>a[j+1])
            {
                pos=j;         //记录交换位置；
                int temp=a[j];
                a[j]=a[j+1];
                a[j+1]=temp;
            }
        }
        i=pos;     //为下一次排序做准备；
    }
}

冒泡排序_2：

void sort(int a[],int n)      //双向冒泡排序；
{
    int front=0,back=n-1;     //定义前后端位置；
    while(front<back)
    {
        for(int j=front;j<back;j++)
        {
            if(a[j]>a[j+1])
            {
                int temp=a[j];
                a[j]=a[j+1];
                a[j+1]=temp;
            }
        }back--;
        for(int j=back;j>front;j--)
        {
            if(a[j]<a[j-1])
            {
                int temp=a[j];
                a[j]=a[j-1];
                a[j-1]=temp;
            }
        }front++;
    }
}