排序技术

排序技术
一、排序的基本概念
1. 排序：给定一组记录的集合{r1, r2, ……, rn}，其相应的关键码分别为{k1, k2, ……, kn}，排序是将这些记录排列成顺序为{rs1, rs2, ……, rsn}的一个序列，使得相应的关键码满足ks1≤ks2≤……≤ksn（称为升序）或ks1≥ks2≥……≥ksn（称为降序）。
正序：待排序序列中的记录已按关键码排好序。
逆序（反序）：待排序序列中记录的排列顺序与排好序的顺序正好相反。
趟：在排序过程中，将待排序的记录序列扫描一遍称为一趟。
通常，一次排序过程需要进行多趟扫描才能完成
2. 排序的分类-根据排序过程中所进行的基本操作分：
1. 基于比较：基本操作——关键码的比较和记录的移动，其最差时间下限已经被证明为O（nlog2n）。
2. 不基于比较：根据关键码的分布特征。比如，桶式排序，基数排序（多关键字排序）
基于比较的内排序
1. 插入排序
2. 交换排序
3. 选择排序
4. 归并排序
不基于比较的内排序
分配排序
桶式排序
基数排序
二、插入排序
1.插入排序的主要操作是插入，
其基本思想是：
每次将一个待排序的记录按其关键码的大小插入到一个已经排好序的有序序列中，直到全部记录排好序为止。
插入类排序方法有以下两种：
直接插入排序
希尔排序
2.直接插入排序

void  insertSort (int  r[ ], int n){	
   for (i=2; i<=n; i++)   { 
       r[0]=r[i]; j=i-1;
       while (r[0]<r[j])       {  
           r[j+1]=r[j];	
	 j=j-1;	
        }
       r[j+1]=r[0];	
    }
}

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

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];           
	     j=i-d;                
	     while (j>0 && r[0]<r[j])
	     { 
          		r[j+d]=r[j]; 
	          j=j-d;          
	      }
	      r[j+d]=r[0]; 
	}
  }
}

三、交换排序
1. 交换排序的主要操作是交换，其主要思想是：在待排序列中选两个记录，将它们的关键码相比较，如果反序（即排列顺序与排序后的次序正好相反），则交换它们的存储位置。
交换类排序的两种方法
冒泡排序
快速排序
2. 起泡排序
基本思想：两两比较相邻记录的关键码，如果反序则交换，直到没有反序的记录为止。

void BubbleSort(int r[ ], int n)
{	
    exchange=n; 	
    while (exchange) 
    {
        bound=exchange; 
        exchange=0；  
        for (j=1; j<bound; j++)
            if (r[j]>r[j+1]) {
                r[j]←→r[j+1]；
	      exchange=j； 
            }
     }
 }

void BubbleSort(int r[ ], int n)
{	
    change=true; bound=n;
    while (change) 
    {
        change=false;
          
        for (j=1; j<bound; j++)
            if (r[j]>r[j+1]) {
                r[j]←→r[j+1]；
	      bound=j；
	      change=true
            }
     }
 }

3.快速排序
首先选一个轴值（即比较的基准），
通过一趟排序将待排序记录分割成独立的两部分，
前一部分记录的关键码均小于或等于轴值，
后一部分记录的关键码均大于或等于轴值，
然后分别对这两部分重复上述方法，直到整个序列有序。

void QuickSort(int first,int last)//快速排序(递归算法)
	{
		if(first>=last)	return;//区间长度为1，递归结束
		else
		{
			int pivot=Partition(first,last);//一次划分
			QuickSort(first,pivot-1);//对左侧子序列进行快速排序
			QuickSort(pivot+1,last);//对右侧子序列进行快速排序
		}
	}

四、选择排序

1. 选择排序的主要操作是选择，其主要思想是：每趟排序在当前待排序序列中选出关键码最小的记录，添加到有序序列中。
2. 简单选择排序
   堆排序
   3.简单选择排序
   基本思想：第i 趟在n-i+1（i=1,2,…,n-1）个记录中选取关键码最小的记录作为有序序列中的第i个记录。

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

4.堆排序
（1）堆是具有下列性质的完全二叉树：每个结点的值都小于或等于其左右孩子结点的值（称为小根堆），或每个结点的值都大于或等于其左右孩子结点的值（称为大根堆）。
（2）首先将待排序的记录序列构造成一个堆(大顶堆)，
此时，选出了堆中所有记录的最大者，然后将它从堆中移走，
并将剩余的记录再调整成堆，
这样又找出了次大的记录，以此类推，直到堆中只有一个记录。
（3）堆调整

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;   //将筛选记录移到正确位置
}

（4）堆排序算法
①创建堆
② 重复进行以下工作
输出堆顶 r[1]
调整工作(1…n-i, 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);               //重建堆
    }
}

五、归并排序
1.归并：将两个或两个以上的有序序列合并成一个有序序列的过程。
归并排序的主要操作是归并，其主要思想是：将若干有序序列逐步归并，最终得到一个有序序列。
2.二路归并排序
基本思想：
将一个具有n个待排序记录的序列看成是n个长度为1的有序序列，
然后进行两两归并，
得到n/2个长度为2的有序序列，
再进行两两归并，得到n/4个长度为4的有序序列，
……，
直至得到一个长度为n的有序序列为止。

void 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++];             //后一个子序列
} 

3.一趟归并排序算法

void  MergePass (int  r[ ], int  r1[ ], int  n, int  h)
{
     i=1;		//第一个子序列的第一个元素
     while (i≤n-2h+1)                //情况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);   //情况2
      else for (k=i; k<=n; k++)    //情况3
                 r1[k]=r[k];
}

六、分配排序
1.基于分配和收集
基本思想
先将数据分配到不同的桶中
再将桶中的数据收集到一起
两种方法
桶式排序(单关键字排序)
链式基数排序（多关键字排序）
特点
排序过程无须比较关键字，而是通过“分配”和“收集”过程来实现排序
它们的时间复杂度可达到线性阶：O(n)。
2.桶式排序
假设待排序的记录的值在0~m-1之间
设置m个桶，
依次扫描待排序的记录，R[1]，…，R[n-1]，把关键字等于k的记录全都装入到 第k个箱子里(分配)，
然后按序号依次将各非空的箱子首尾连接起来(收集)。

void collect( head *list, Node *&first,int m){			//收集算法
	int i=0,j;
	while(list[i].first==NULL) 	i++;
	if(i>m) return;
	first=list[i].first;
	while(i<=m)	{
		j=i+1;
		while(list[j].first==NULL)	j++;
		if(j>m) return;
		list[i].rear->next=list[j].first;
		i=j;
	}
}

int  main(){				//桶式排序算法
	Node *s,*first;	head *list;
	int m;cin>>m;
	list=new head[m];
	for (int i=0;i<=m;i++)	{
		list[i].first=NULL;	list[i].rear=NULL;}
	int n;
	cin>>n;
	first=NULL;
	for( i=0;i<n;i++)
	{	s=new Node;	cin>>s->data;	s->next=first;	first=s;	}
	distribute(first,n,list);
	collect(list,first,m);
	Node *p=first;
	while(p){
		cout<<p->data<<"\t";	p=p->next;	}
	cout<<endl;
	return 0;
}

3.基数排序
基数排序是典型的LSD排序方法，利用“分配”和“收集”两种运算对单关键码进行排序。
基本思想
从关键字的最“低位”开始，将关键字分配到r(基数）个堆（桶）中；
按桶的编号将关键字收集起来；
然后，以“次低位”将关键字又分配到r个桶中；再收集，……，重复直到“最高位”为止，这时，以按关键字有序。

void distribute(Node *first, int n, head *list,int d){		//基数排序的分配算法
	Node *p,*q;	p=first;	int data, s,t;
	while(p)	{
		data=p->data;
		s=pow(10,d);t=s/10;data=data%s;data=data/t;
		q=p->next;
		if(	list[data].first)
		{list[data].rear->next=p;	list[data].rear=p;}
		else
			list[data].first=list[data].rear=p;
		list[data].rear->next=NULL;
		p=q;
	}
void collect( head *list, Node *&first,int m){				//收集算法
	int i=0,j;
	while(list[i].first==NULL) 	i++;
	if(i>m) return;
	first=list[i].first;
	while(i<=m)	{
		j=i+1;
		while(list[j].first==NULL)	j++;
		if(j>m) return;
		list[i].rear->next=list[j].first;
		i=j;
	}
}
······
int d;
	cout<<"Please input the size of a data:";
	cin>>d;
	for(i=1;i<=d;i++) //处理每一“位”（个位、十位...）
	{
		distribute(first,n,list ,i);
		collect(list,first,m);
		for (int i=0;i<=m;i++)
		{
			list[i].first=NULL;	
			list[i].rear=NULL;	
		}
	}