ACM--各种排序

/*简单选择排序*/
 void select_sort(SqList L)
 { Recode r;
r.comp =0;
r.move =0;
    int i,j,k;
    RedType t;
    for (i=1;i<L.length;i++)
    {   j=i;
       for (k=i+1;k<=L.length;k++)  
       { 
  if (L.r[j].key>L.r[k].key)
  {
r.comp++;
    j=k;          
  }//把无序区最小的挑出来
  }
       if (i!=j)
  {/*交换顺序 */
  //r.compex++;
  t=L.r[j];
  L.r[j]=L.r[i];
  L.r[i]=t;
  r.move =r.move +3;
  }
    }
 }






//直接插入排序
void Zhijie(SqList L)         
 { Recode r;
r.comp =0;
r.move =0;
// r.compex=0;
int j;
// r.compex++;
    for(int i=2;i<=L.length;++i)
{  // r.compex ++;
if(L.r[i].key<L.r[i-1].key)
{
L.r[0]=L.r[i];         //复制为哨兵
L.r[i]=L.r[i-1];
r.move=r.move +2;
for(j=i-2;L.r[0].key < L.r[j].key;--j)
{
L.r[j+1]=L.r[j];    //记录后移
r.move ++;
r.comp ++;
}
L.r[j+1]=L.r[0];        //插入到正确位置
r.move ++;
}
}
 } 
//希尔排序
void ShellInsert(SqList *L,int dk,Recode *r)
{ int i,j;
for(i=dk+1;i<=L->length ;++i)
{ r->comp ++;
if(L->r[i].key<L->r[i-1].key)
{ L->r[0]=L->r[i];         //暂存
r->move ++;
for(j=i-dk;j>0&&(L->r[0].key < L->r[j].key);j-=dk)
{ L->r[j+dk]=L->r[j];    //记录后移
r->move ++;
r->comp ++;
}
L->r[j+dk]=L->r[0];        //插入到正确位置
r->move ++;
}
}
}
void ShellSort(SqList L,int dlta[],int t)    
{ //按增量序列dlta[0..t-1]对顺序表L作希尔排序。
Recode r;
r.comp =0;
r.move =0;
int k;
for(k=0;k<t;++k)
  ShellInsert(&L,dlta[k],&r);//一趟增量为dlta[k]的插入排序
}
//冒泡排序法
void Maopao(SqList L)
{ Recode r;
r.comp =0;
r.move =0;
int i,j;
    RedType t;
for(i=1;i<L.length;i++)
for(j=1;j<=L.length-i;j++)
{ r.comp++;
if(L.r[j].key>L.r[j+1].key)
{  r.move =r.move +3;
t=L.r[j];
L.r[j]=L.r[j+1];
              L.r[j+1]=t;
}
}
}
//快速排序法
int Partition(SqList *L,int low,int high,Recode *r)
{
int pivotkey;
L->r[0]=L->r[low];       //用子表的第一个记录作枢轴记录
pivotkey=L->r[low].key;   //枢轴记录关键字
r->move =r->move +2;
while(low<high)         //从表的两端交替的向中间扫描
{

while(low<high&&L->r[high].key >=pivotkey){ --high; r->comp ++;}
L->r[low]=L->r[high]; //将比枢轴记录小的记录移到低端
        while(low<high&&L->r[low].key <=pivotkey) {++low; r->comp++;}
L->r[high]=L->r[low]; //将比枢轴记录大的记录移到高端
r->move =r->move+2;
}
L->r [low]=L->r [0];              //枢轴记录到位
r->move ++;
return low;                      //返回枢轴位置
}
void QSort(SqList *L,int low,int high,Recode *r)
{ int pivotloc;
if(low<high)           //长度大于1
{
//r.compex++;
pivotloc=Partition(L,low,high,r);       //将L->r[low..high]一分为二
QSort(L,low,pivotloc-1,r);          //对低子表递归排序，pivotloc是枢轴位置
QSort(L,pivotloc+1,high,r);        //对高子表递归排序
}
}
void QuickSort(SqList L)         
{ Recode r;
r.comp =0;
r.move =0;
QSort(&L,1,L.length,&r);
}

 /*堆排序*/


 //堆调整算法
void HeapAdjust (HeapType &L, int s, int m)
{   // 已知 H.r[s..m]中记录的关键字除 H.r[s] 之外
    //均满足堆的特征，本函数自上而下调整 H.r[s]
    //的关键字，使 H.r[s..m] 也成为一个大顶堆
Recode r;
RedType rc;
// r.compex=0;
// r.compex++;
     rc = L.r[s];    // 暂存 H.r[s] 
     for (int  j=2*s; j<=m; j*=2 ) { // j 初值指向左孩子自上而下的筛选过程;
r.move++;
     // 自上而下的筛选过程
      if ( j<m && L.r[j].key<L.r[j+1].key )  ++j;  
  r.comp++;
             // 左/右“子树根”之间先进行相互比较
             // 令 j 指示关键字较小记录的位置
      if ( rc.key>= L.r[j].key )  break; 
           // 再作“根”和“子树根”之间的比较，
           // 若“>=”成立，则说明已找到 rc 的插
           // 入位置 s ，不需要继续往下调整


      L.r[s] = L.r[j];   s = j;    r.move++;
        // 否则记录上移，尚需继续往下调整
}
 L.r[s] = rc;  // 将调整前的堆顶记录插入到 s  (注意插入的位置为s j=2*s)
 r.move++;
} // HeapAdjust


void HeapSort ( HeapType &L ) {
Recode r;
r.comp =0;
r.move =0;
RedType t;
  // 对顺序表L 进行堆排序
for (int i=L.length/2;   i>0;   --i )
{
r.comp++;
HeapAdjust ( L, i, L.length );    // 建小顶堆
}
for ( i=L.length; i>1; --i ) {
r.comp++;
// L.r[1]←→L.r[i];
if (i!=1)
  {/*交换顺序 */
  //r.compex++;
    t=L.r[1];
  L.r[1]=L.r[i];
  L.r[i]=t;
  r.move =r.move +3;
  }
 // 将堆顶记录和当前未经排序子序列
 //  H.r[1..i]中最后一个记录相互交换
     HeapAdjust(L, 1, i-1);  // 对 L.r[1] 进行筛选
} // HeapSort
void BInsertSort(SqList &L) {  
  // 对顺序表L作折半插入排序。
  Recode r;
  r.comp =0;
  r.move =0;
  //r.compex=0;
  int i,j,high,low,m;
  for (i=2; i<=L.length; ++i) {


    L.r[0] = L.r[i];       // 将L.r[i]暂存到L.r[0]
    low = 1;   high = i-1;
    while (low<=high) {
r.move =r.move+1;
// 在r[low..high]中折半查找有序插入的位置
      m = (low+high)/2;                            // 折半
      if (L.r[0].key<L.r[m].key)
 {
 high = m-1;  // 插入点在低半区
 r.comp=r.comp +1;
 }
      else  {
 low = m+1;                             // 插入点在高半区
 r.comp=r.comp +1;
 }
    }
    for (j=i-1; j>=high+1; --j) 
{
L.r[j+1] = L.r[j];  // 记录后移
r.move =r.move+1;


}
    L.r[high+1] = L.r[0];    // 插入
  }
} // BInsertSort