数据结构(C语言描述)读书笔记之排序

     直接插入排序:

    基本思想:把数组A[n]的前k个元素看成是已排序的，k从1开始增加，不断的把k+1位置的元素插入到前k个元素里面。

     void InsertSort(struct ElemType A[],int n)

     {

          struct ElemType x;

          int i,j;

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

          {

               x=A[i];

               for(j=i-1;j>=0;j--)

                    if(x.stn<A[j].stn)

                         A[j+1]=A[j];

                    else

                         break;

               A[j+1]=x;

          }

     }

     

     选择排序:

     基本思想:每次从待排序的区间中选择出具有最小排序码的原色，把该元素与该区间的第一个元素交换位置。

     void SelectSort(struct ElemType A[],int n)

     {

          struct ElemType x;

          int i,j,k;

          for(i=1;i<n-1;i++)

          {

               k=i-1;

               for(j=i;j<=n-1;j++)

               {

                    if(A[j].stn<A[k].stn) k=j;

               }

               if(k!=i-1)

               {

                    x=A[i-1];A[i-1]=A[k];A[k]=x;

               }

          }

     }

     堆排序:

     基本思想:包括两个阶段:构成初始堆和堆排序。构成初始堆主要是通过调用一次"筛"运算完成的，它主要是从n/2位置开始到跟节点，不断的下降到合适的位置，满足堆性质的要求。在堆排序的过程中，主要是把A[0]与A[n-1]交换，A[n-1]就是最大的数，然后在前n-2元素中运行"筛"运算.

     void Sift(struct ElemType A[],int n,int i)

     {

          struct ElemType x=A[i];

          int j=2*i+1;

          while(j<=n-1){

               if(j<n-1&&A[j].stn<A[j+1].stn)j++;

               if(x.stn<A[j].stn){

                    A[i]=A[j];

                    i=j;j=2*i+1;

               }

               else break;

          }

          A[i]=x;

     }

     void HeapSort(struct ElemType A[],int n)

     {

          struct ElemType x;

          int i;

          for(i=n/2-1;i>=0;i--)Sift(A,n,i);//建立初始堆

          for(i=1;i<n-1;i++){

               x=A[0];A[0]=A[n-1];A[n-i]=x;

               Sift(A,n-i,0);

          }

     }

     冒泡排序:

     基本思想:通过相邻元素之间的比较和交换使排序码较小的元素从底部移向顶部.

     void BubbleSort(struct ElemType A[],int n)

     {

          struct ElemType x;

          int i,j,flag;

          for(i=1;i<=n-i;j++){

               flag=0;

               for(j=n-1;j>=i;j--)

                    if(A[j].stn<A[j-1].stn){

                         x=A[j];A[j]=A[j-1];A[j-1]=x;

                         flag=1;

                    }

               if(flag==0) return;

          }

     }

     快速排序:

     基本思想:对冒泡排序进行改进，它记录的比较和交换是从两端向中间进行的，排序码较大的记录一次就能够交换到后面的单元，排序码较小的记录一次就能够交换到前面单元。

     void QuickSort(struct ElemType A[],int s,int t)

     {

          int i=s,j=t+1;

          struct ElemType x=A[s];

          do{

               do i++;while(A[i].stn<x.stn);

               do j--;while(A[j].stn>x.stn);

               if(i<j)

                    struct ElemType temp=A[i];

                    A[i]=A[j];A[j]=temp;

               }

               while(i<j);

           A[s]=A[j];A[j]=x;

           if(s<j-1)QuickSort(A,s,j-1);

           if(j+1<t)QuickSort(A,j+1,t);

     }

     归并排序:

     基本思想:它是将两个或多个有序表合并成一个有序表的过程。

     //把A数组中两个相邻的有序表A[s]-A[m]和A[m+1]-A[t]归并为R数组中对应位置上的一个有序表R[s]-R[t]

     void TwoMerge(struct ElemType A[],struct ElemType R[],int s,int m,int t)

     {

          int i,j,k;

          i=s;j=m+1;k=s;

          while(i<=m&&j<=t)

               if(A[i].stn<=A[j].stn){

                    R[k]=A[i];i++;k++;

               }

               else{

                    R[k]=A[j];j++;k++;

               }

          while(i<=m){

               R[k]=A[i];i++;k++;

          }

          while(j<=t){

               R[k}=A[j];j++;k++;

          }

     }

     //把数组A[n]中每个长度为len的有序表两两归并到数组R[n]中

     void MergePass(struct ElemType A[],struct ElemType R[],int n,int len)

     {

          int i,p=0;

          while(p+2*len-1<=n-1){

               TwoMerge(A,R,p,p+len-1,p+2*len-1);

               p+=2*len;

           }

          if(p+len-1<n-1)TwoMerge(A,R,p,p+len-1,n-1);

          else for(i=p;i<=n-1;i++) R[i]=A[i];

     }

     //采用归并排序的方法对数组A中的n个记录进行排序

     void MergeSort(struct ElemType A[],int n)

     {

          struct ElemType* R=malloc(n*sizeof(struct ElemType));

          int len=1;

          while(len<n){

               MergePass(A,R,n,len);

               len*=2;

               MergePass(R,A,n,len);

               len*=2;

          }

          free(R);

     }