第八章 排序

1.插入类排序（直接插入排序、希尔排序）

直接插入排序 ：

  思想：在插入第L（L>1）个记录时，前面的L-个记录已经排好序

void InsertSort(int r[],int n)
{
    for(int i=2;i<=n;i++)
    {
        r[0]=r[i];
        int j;
        for( j=i-1;r[0]<r[j];j--)
            r[j+1]=r[j];//r[j+1的值已经在r[0]中保存，可以覆盖
        r[j+1]=r[0];
    }
}

希尔排序：

 思想：将整个待排序序列记录分割成若干个子序列，在子序列内 分别进行插入排序，待整个序列中的记录基本有序时，对全体记录进行直接插入排序。

void Shellsort(int r[],int n){
  for (d=n/2; d>=1; d=d/2){
     for (i=d+1; i<=n; i++) {
         r[0]=r[i];
         for (j=i-d; j>0 && r[0]<r[j]； j=j-d)
         { 
                  r[j+d]=r[j]; 
                
          }
          r[j+d]=r[0]; 
    }
  }
}

 2.交换排序（冒泡排序、快速排序）

冒泡排序：

void BubleSort(int a[],int n)
{
    int exchange=n;
    while(exchange!=0)
    {
        int bound=exchange;exchange=0;///exchange=0是序列中的元素不再交换时，退出循环
        for(int i=1;i<bound;i++)
        {
            if(a[i]>a[i+1])
            {
                swap(a[i],a[i+1]);
                exchange=i;
            }
        }
    }
}

快速排序：

思想：首先选择一个轴值，将待排序记录划分为独立的两部分，左侧记录的关键码均小于或等于轴值，右侧记录的关键码均大于或等于轴值然后分别对这两部分重复上述操作，

直到整个序列有序。

int Partition(int r[],int first,int end)
{
    int i=first,j=end;
    while(i<j)
    {
        while(i<j&&r[i]<=r[j]) j--;///右侧扫描
        if(i<j)
        {
            swap(r[i],r[j]);
            i++;
        }
        while(i<j&&r[i]<=r[j]) i++;///左侧扫描
        if(i<j)
        {
            swap(r[i],r[j]);
            j--;
        }
    }
    return i;
}
void QuickSort(int r[],int first,int end)
{
    if(first<=end)
    {

        int pivot=Partition(r,first,end);///找到 
        QuickSort(r,first,pivot-1);
        QuickSort(r,pivot+1,end);
    }
}

3.选择排序（简单选择排序、堆排序）

简单选择排序：

void  selectSort ( int  r[ ], int n)
{   
    for ( i=1; i<n; i++) 
    {  
        index=i;         
        for (j=i+1; j<=n; j++) 
           if  (r[j]<r[index])  index=j;
        if (index!=i)   r[i]<==>r[index];      
    }
} 

堆排序：

思想：首先将待排序序列构造成大顶堆，然后移走堆顶，将剩余元素再调整为大顶堆，再取堆顶直到序列中只有一个元素。

 堆调整：

void sift ( int r[ ], int k, int m )
{//要筛选结点的编号为k，堆中最后一个结点的编号为m 
    i=k;  j=2*i;  temp=r[i];  //将筛选记录暂存
    while (j<=m ) {          //筛选还没有进行到叶子
       if (j<m && r[j]<r[j+1]) j++;  //左右孩子中取较大者
        if (temp>r[j]) break; 
        else {
             r[i]=r[j];   i=j;   j=2*i;
        }
     }
     r[i]=temp;   //将筛选记录移到正确位置
}

将一个无序序列建成一个堆：

堆排序算法：

void  HeapSort ( int  r[], int n)
{
    for (i=n/2; i>=1; i--)      //初建堆
       sift(r, i, n) ;     
    for (i=1; i<n; i++ )
    {
       r[1]←→r[n-i+1];        //移走堆顶
       sift(r, 1, n-i);               //重建堆
    }
}

测试代码：

#include<bits/stdc++.h>
using namespace std;
int a[1000];
void sift ( int r[ ], int k, int m )///此处依然是大顶堆
{//要筛选结点的编号为k，堆中最后一个结点的编号为m
    int i=k;
    int j=2*i,temp=r[i];  //将筛选记录暂存
    while (j<=m ) {          //筛选还没有进行到叶子
       if (j<m && r[j]<r[j+1]) j++;  //左右孩子中取较大者
        if (temp>r[j]) break;
        else {
             r[i]=r[j];   i=j;   j=2*i;
        }
     }
     r[i]=temp;   //将筛选记录移到正确位置
}
void  HeapSort ( int  r[], int n)
{
    for (int i=n/2; i>=1; i--)      //初建堆
       sift(r, i, n) ;
    for (int i=1; i<n; i++ )
    {
       swap(r[1],r[n-i+1]);        //移走堆顶，放在序列的后面
       sift(r, 1, n-i);               //重建堆
    }
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
    }
    HeapSort(a,n);
    for(int i=1;i<=n;i++)
    {
        printf("%d ",a[i]);
    }

    return 0;
}

 

 4.归并排序

直接上代码：

#include<bits/stdc++.h>
using namespace std;
int r[100],r1[100],n;
void Merge(int r[],int r1[],int s,int m,int t)
{
    int i=s,j=m+1,k=s;
    while(i<=m&&j<=t)
    {
        if(r[i]<r[j]) r1[k++]=r[i++];
        else r1[k++]=r[j++];
    }
    if(i<=m) while(i<=m)
             {
                r1[k++]=r[i++];
             }
    else  while(j<=t)
          {
             r1[k++]=r[j++];
          }

}
void MergePass(int r[],int r1[],int n,int h)
{
    int i=1;
    while(i<=n-2*h+1)///待归并记录至少有两个长度为h的子序列
    {
        Merge(r,r1,i,i+h-1,i+2*h-1);
        i+=2*h;
    }
    if(i<n-h+1) Merge(r,r1,i,i+h-1,n);///待归并序列中有一个长度小于h
    else for(int k=i;k<=n;k++)///待归并序列中只剩一个子序列
         r1[k]=r[k];
}
void MergeSort(int r[],int r1[],int n)
{
    int h=1;
    while(h<n)
    {
        MergePass(r,r1,n,h);
        h=2*h;
        MergePass(r1,r,n,h);
        h=2*h;
    }
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&r[i]);
    }
    MergeSort(r,r1,n);
    for(int i=1;i<=n;i++)
    {
        printf("%d ",r[i]);
    }
    printf("\n");
    return 0;
}

 

 4.分配排序

思想：先将数据分配到不同的桶中，再将桶中的数据收集在一起。