算法 基于比较的排序

插入排序

void insert_sort(int *ary,int n)
{
	int temp;
        int i,j;
	for(i=1;i<n;i++)// 从第二个数开始
	{
		temp=ary[i];
		for(j=i;j>0&&temp<ary[j-1];j--)
		{
			ary[j]=ary[j-1];
		}
		ary[j]=temp;
	}
}

生活中可以用来模拟插入排序的事件,例如打牌中的将牌排序,十分形象具体

通常情况下插入排序O(N^2),基本有序(最好情况下)时是O(N),是稳定排序

折半插入排序可以在比较次数上进行优化,但移动次数未改变,复杂度仍然是O(N^2)

2-路插入排序

表插入排序

希尔SHELL排序

int shell_sort(int *ary,int size)
{
	int op=0;
	int temp;
	int incs[5]={1,5,19,41,109};
	for(int t=4;t>=0;t--)
	{
		int h=incs[t];
		for(int i=h;i<size;i++)
		{
			temp=ary[i];
			for(j=i;j>0&&temp<ary[j-h];j=j-h)
			{
				ary[j]=ary[j-h];
				op++;
			}
			ary[j]=temp;
			op++;
		}
	}
	return op;
]

SHELL排序是不稳定的排序,

通常情况下性能优于插入排序

快速排序

// 从左遍历版本,以结尾为主元,返回的轴位置为i+1,因为这里i是从-1开始移动的
int partition(int *ary,int left,int right)
{
	int i=left-1;
	int j=left;
	int pivot=ary[right];
	for(;j<right;j++)
	{
		if(ary[j]<=pivot)
		{
			i++;
			swap(i,j);
		}
	}
	swap(i+1,right);
	return i+1;
}
void quick_sort(int *ary,int left,int right)
{
	if(left<right)
	{
		int index=partition(ary,left,right);
		quick_sort(ary,left,index-1);
		quick_sort(ary,index+1,right);
	}
}

// HOARE版本,可以任意位置为主元,这里返回的轴位置是j+1,最后j在i前,可能j+1=i也可能j+2=i
void quicksort(int *ary,int left,int right)
{
     if(left<right){
     int i=left,j=right;
     int pivot=ary[left];
     while(i<=j){
                 while(ary[j]>pivot)j--;
                 while(ary[i]<pivot)i++;
               
                if(i<=j){
                        int temp=ary[i];
                        ary[i]=ary[j];
                        ary[j]=temp;
                        i++;j--;
                        }
     }
     if(left<j)
     quicksort(ary,left,j);
     if(i<right)
     quicksort(ary,i,right);
     }
}
// 替换版本,非交换版本,这里返回的轴位置是i
void quicksort(int *ary,int left,int right)
{
	if(left<right){
	int i=left;
	int j=right;
	int key=ary[i];
	while(i<j)
	{
		while(i<j&&ary[j]>=key)j--;
		ary[i]=ary[j];
		while(i<j&&ary[i]<=key)i++;
		ary[j]=ary[i];
	}
	ary[i]=key;
	if(left<i-1)
		quicksort(ary,left,i-1);// 这里可以用i-1,因为ary[i]已经在有序的位置上了
	if(i+1<right)
		quicksort(ary,i+1,right);
	}

}

快速排序基于分治法的排序算法,

时间复杂度为O(n*logn),基本有序的情况下(也就是最坏情况下)是O(n^2),但通常情况下性能是最佳的,常数因子较小

不稳定排序

为了避免基本有序的情况,通过引入随机化技术,使得在等概率的情况下获得期望性能,所作的操作只需要随机一个位置与每次作pivot的位置元素交换;

另外一种改进随机是三数取中划分,随机三个位置,然后取中位数为pivot

堆排序

void swap(int *a,int *b)
{
     int temp=*a;
     *a=*b;
     *b=temp;
 }
// 调整堆  siftdown
void heapify(int *ary,int i,int size)
{
	int left,right,max;
	while(i<size)
	{ 
        left=2*i+1;
        right=left+1;
		max=i;
		if(left<size&&ary[i]<ary[left])
			i=left;
		if(right<size&&ary[i]<ary[right])
			i=right;
		if(i!=max)
			swap(&ary[i],&ary[max]);
		else
			break;
		
	}
}
// 建堆 siftup
void buildHeap(int *ary,int size)
{
	for(int i=(size-2)/2;i>=0;i--)// 利用siftdown实现siftup,FOR 每个结点的父母结点 TO 根结点
	{
		heapify(ary,i,size);
	}
}

// 堆排序过程 ,先建堆,然后交换顶点与末尾,交换一次再调整一次,当前代码是大根堆,所以最后顺序是从小到大
 void heapSort(int *ary,int size)
{
	buildHeap(ary,size);
	for(int i=size-1;i>0;i--)
	{
		swap(&ary[0],&ary[i]);
		heapify(ary,0,i);
	}
}

堆排序的前身:树形选择排序,又称锦标赛排序(类似比赛分组树结构)

堆的定义是:一个完全二叉树,每个结点大于等于其两个孩子结点(大根堆)

堆排序的过程,首先建堆,然后将堆顶与末尾元素交换,紧接着调整堆使其继续保持定义,循环交换n次,形成最终有序排列

时间复杂度O(n*logn),其中调整堆的复杂度为O(logn),排序O(n),不稳定排序

堆排序的应用:

优先队列

归并排序

// 归并排序,不过new和delete写在子函数中,效率可能不高,可以直接在排序前申请O(n)的空间
void mergeArray(int *ary,int left,int mid,int right,int *temp)
{
	int i=left,j=mid+1,k=0;
	int temp[]=new int[right-left+1];
	while(i<mid&&j<right)
	{
		if(ary[i]<ary[j])
			temp[k++]=ary[i++];
		else
			temp[k++]=ary[j++];
	}
	while(i<=mid)
		temp[k++]=ary[i++];
	while(j<=right)
		temp[k++]=ary[j++];
	// 复制回原数组
	for(int i=0;i<k;i++)
	{
		ary[left+i]=temp[i];
	}
	// 考虑是否删除额外空间
	delete[] temp;
}
void mergeSort(int *ary,int left,int right,int *temp)
{
	int mid=((right-left)>>1)+left;
	if(left<right)
	{	
		mergeSort(ary,left,mid);//注意这里不是 mid-1,之前写错了
		mergeSort(ary,mid+1,right);
		mergeArray(ary,left,mid,right,temp);
	}
}

归并排序的时间复杂度最好最坏下均是O(n*logn),但空间复杂度是O(n)

是稳定排序

利用递归树可以清晰地分析归并排序的过程