排序算法总结

插入排序

void InsertSort(int r[].int n)

{

         for(i=2;i<=n;++i)

         {

                   r[0]=r[i];

                   for(j=i-1;r[0]<r[j];--j)

                            r[j+1]=r[j];

                   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];

                  }

         }

}

 

 

冒泡排序

void BubbleSort(int r[],int n)

{

         exchange=n;//exchange记载每次记录交换的位置

         while(exchange!=0)

         {

                //bound位置的记录是无序区的最后一个记录

                 bound=exchange;exchange=0;

                 for(j=1;j<bound;j++)

                           if(r[j]>r[j+1])

                           {

                                    r[j]<-->r[j+1];

                                    exchange=j;

                           }

        }

}

 

 

快速排序

 

int Partition(int r[],int first,int end)

{

         i=first;j=end;

         while(i<j)

         {

                 while(i<j&&r[i]<=r[j])

                           --j;

                 if(i<j)

                 {

                         r[i]<-->r[j];

                         i++;

                }

 

                while(i<j&&r[i]<=r[j])

                         ++i;

                If(i<j)

                        {

                                 r[i]<-->r[j];

                                 --j;

                        }

        }

        return i;

}

void QuickSort(int r[],int first,int end)

{

         if(first<end)

         {

                   pivot=Partition(r,first,end);

                   QuickSort(r,first,pivot-1);

                   QuickSort(r,pivot+1,end);

        }

}

 

选择排序

 

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];

          }

}

 

归并排序

int Merge(int r[],int r1[],int s,int m,int t)

{

        //一次归并算法

         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)

{

         i=1;

         while(i<=n-2h+1)

         {

                 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);

        else

                 for(k=i;k<=n;k++)

                         r1[k]=r[k];

}

归并排序非递归算法

void MergeSort(int r[],int r1[],int n)

{

         h=1;

         while(h<n)

         {

                 MergePass(r,r1,n,h);

                 h=2*h;

                 MergePass(r1,r,n,h);

                 h=2*h;

        }

}

归并排序递归算法

void MergeSort2(int r[],int r1,int s,int t)

{

         if(s==t) r1[s]=r[s];

         else

                   {

                        m=(s+t)/2;

                        MergeSort2(r,r1,s,m);

                        MergeSort2(r,r1,m+1,t);

                        Merge(r,r1,s,m,t);

                }

}

 

 

堆排序

 

void Sift(int r[],int k,int m)

{

         i=k;j=2*i;

         while(j<m)

                {

                    if(j<m&&r[j]<r[j+1])

                          j++;

                   if(r[i]>r[j])

                         break;

                 else

                        {

                         r[i]<-->r[j];

                         i=j;

                         j=2*I;

                        }

                }

}

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);

        }

}