插入排序、选择排序、合并排序几种排序比较

1、 插入排序，时间复杂度O(n^2)

一个数组A[0,...,n-1],将A[j]插入到子数组A[0,...,j-1]中，其中数组A[0,...,j-1]是排好序的（假如为非降序），把A[j]和A[j-1]->A[0]逐个进行比较，大的数往后移位，将A[j]插入适当的位置（找到最后一个比它大的，放在前面）。

递归法，为排序A[0,...,n-1],先排序A[0,...,n-2],然后把A[n-1]插入到已经排序的数组A[0,...,n-2]中去。如下：

 

#include<stdio.h>
#include<iostream.h>

//算法导论2.3-4
//将数number插入已经排好序（非降序）的数组中
void insert(int num[],int len,int number){
	int i=len-1;
	while(i>=0&&num[i]>number){
	   num[i+1]=num[i];
	   i--;
	}
	num[i+1]=number;
}
//递归程序
void insert_into(int num[],int n){

	if(n>1){
	   insert_into(num,n-1);
	} 
	   insert(num,n,num[n]);
    

	
}

int main(){
	int num1[8]={4,2,5,1,8,10,3,7};
	
	int len=8;
	insert_into(num1,len-1);
	for(int k=0;k<len;k++){
	   cout<<num1[k]<<endl;
	}
	return 0;
}

 

 2、选择排序，时间复杂度O(n^2)

首先找出A中最小的元素，并将其与A[0]互换，接着找A中次小元素，与A[1]互换，以此类推。并且仅需要在n-1个元素上运行。伪代码如下：

      for i<-1 to n-1 do//伪代码中下标从1开始

            min<-Find_min(A[i,...,n])//此函数找出A中从下标i到n的最小元素，时间复杂度O(n)

            min<->A[i]

      endfor

根据以上伪代码可知，选择排序的时间复杂度为O(n^2)

最佳和最坏情况下的运行时间都为Θ(n²)。因为这种直接选择排序，其关键字的比较次数与各元素原来的排列顺序无关。

3、合并排序（递归法），时间复杂度O(n㏒₂n)

分解：将n个元素分成各含n/2个元素的子序列

解决：用合并排序法对两个子序列进行递归排序

合并：合并两个已经排好序的子序列得到结果(merge函数)

 

#include<stdio.h>
#include<iostream.h>
#include <limits.h>

//算法导论p17

void merge(int num[],int p,int q,int r){//假设num[p..q],num[q+1...r]已经排好序，将其合并成一个已经排好序的数组
   int n1=q-p+1;
   int n2=r-q;
   int *left=new int[n1+1];
   int *right=new int[n2+1];

   for(int i=0;i<n1;i++){
      left[i]=num[p+i];

   }
   for(i=0;i<n2;i++){
      right[i]=num[q+1+i];

   }
   left[n1]=INT_MAX;//哨兵牌
   right[n2]=INT_MAX;
   int j=0,k=0;

   for(i=p;i<=r;i++){
	   if(left[j]>right[k]){
	      num[i]=right[k];
		  k++;
	   }
       else{
	      num[i]=left[j];
		  j++;
	   }
   }
   for(i=p;i<=r;i++){
      cout<<num[i]<<endl;
   }

}
void merge_sort(int num[],int p,int r){
	int q=0;
	if(p<r){
	   q=(p+r)/2;
       merge_sort(num,p,q);
       merge_sort(num,q+1,r);
       merge(num,p,q,r);

	}

}

int main(){
	int num[8]={2,4,5,7,1,2,3,6};	
    int p=0,r=7;
	int q=(p+r)/2;
	merge_sort(num,p,r);
    return 0;
}

 

 

merge函数是从头开始分别比较两个子序列的数的大小，将较小的数字存入num中，相应队列的指针往后移。为了避免在每个步骤中都要检查每个序列是否为空，增加一个哨兵牌，包含一个特殊的值，来简化代码。此函数中，用正无穷来作为哨兵值，这样每当露出一张值为无穷的哨兵牌，其不可能是两张中最小的一张，除非另外一个序列也露出哨兵牌。

merge函数的时间复杂度为O(n),n=r-p+1

而合并排序，将问题分为1/2->1/4->1/8，总共分了㏒₂n层，回推时每一层的代价是O(n)

4、合并排序的应用，求逆序对的个数，且算法的时间复杂度为O(n㏒₂n)

逆序对：如果有i<j时，A[i]>A[j],则(i,j)叫做一个逆序对

合并排序法求逆序对的个数，当求出逆序对数目后，数组也已经排好序了，如果不想让原数组发生变化，可以把原数组拷贝到另一个数组，对新数组操作就好。整个过程一边排序一边数，递归到最深的地方如果有一个数，那么返回0，如果有两个数，看做有两个元素的子数组，两个子数组都已经排好序，并且左边只有一个元素的子数组的逆序对是0，右边只有一个元素的子数组的逆序对是0，那么两个元素的子数组的逆序对的个数就是1,若这两个数逆序，否则是0对。所以，当递归进行到最后一步，也就是这样的：a[1]到a[n/2]已经排好序，并且逆序对的个数为Inv1，a[n/2+1]到a[n]已经排好序，并且逆序对的个数为Inv2，那么整个数组的逆序对总数就是Inv1+Inv2+最后一步归并过程中的逆序对数。那么在merge这一步的逆序对个数又是怎么计算的呢？若i是左边子数组的下标（i的范围是p到q），j是右边子数组的下标（j的范围是q+1到r），假设某对(i, j)，有a[i]>a[j]，那么a[i]到a[q]都大于a[j]，贡献的逆序对数为q-i+1。

 

#include<stdio.h>
#include<iostream.h>
#include <limits.h>

//算法导论p24 2-4d

int merge_num(int num[],int p,int q,int r){//假设num[p..q],num[q+1...r]已经排好序，将其合并成一个已经排好序的数组
   int n1=q-p+1;
   int n2=r-q;
   int *left=new int[n1+1];
   int *right=new int[n2+1];
   int n=0;//n表示逆序对数

   for(int i=0;i<n1;i++){
      left[i]=num[p+i];

   }
   for(i=0;i<n2;i++){
      right[i]=num[q+1+i];

   }
   left[n1]=INT_MAX;//32767
   right[n2]=INT_MAX;
   int j=0,k=0;

   for(i=p;i<=r;i++){
	   if(left[j]>right[k]){
	      num[i]=right[k];
		  k++;
		  n+=n1-j;//注意不可是q-j+1，因为q和j指的意义不同，一个是原来数组里的下标，一个是新数组里的下标
	   }
       else{
	      num[i]=left[j];
		  j++;
	   }
   }
  
   return n;
}

int merge_sort(int num[],int p,int r){
	int q=0;
	int total=0;
	if(p<r){
	   q=(p+r)/2;
	   total+=merge_sort(num,p,q);//之前的左半部
	   total+=merge_sort(num,q+1,r);//之前的右半部分
	   total+=merge_num(num,p,q,r);//这次合并时加上total

	}
	
	return total;
}

int main(){
	int num[8]={8,7,6,5,4,3,2,1};	
    int p=0,r=7;
	int q=(p+r)/2;
	//cout<<merge_num(num,p,q,r)<<endl;
    cout<<merge_sort(num,p,r)<<endl;
	for(int i=p;i<=r;i++){
      cout<<num[i]<<endl;
   }
    return 0;
}

 

此时，因为要记录每次递归的逆序对数，因此，递归函数merge_sort中total的写法需要注意。

5、折半查找(递归程序)，时间复杂度O(㏒₂n)

 

int binary_search(int num,int num_arr[],int start,int end){
	int mid=0;
    if(start>=end&&num_arr[start]!=num){//注意递归终止条件
		return 0;
	   
	}
	mid=(start+end)/2;
	   if(num==num_arr[mid]){
		   return mid;
	      
	   }
	   else if(num<num_arr[mid]){
	      binary_search(num,num_arr,start,mid);
	   }
	   else{
	      binary_search(num,num_arr,mid,end);
	   }
}