7种排序算法的实现及分析总结

本文介绍了7种排序算法及其实现方式，算是自己对排序算法的总结梳理（参照小甲鱼的数据结构及算法教程）。

1、7中排序算法

2、稳定排序和不稳定排序

    稳定排序算法会依照相等的关键（换言之就是值）维持纪录的相对次序。也就是一个排序算法是稳定的，就是当有两个有相等关键的纪录R和S，且在原本的串行中R出现在S之前，在排序过的串行中R也将会是在S之前。

3、内排序和外排序

    内排序是在待排序数组内排序，不需要申请额外数组；而外排序必须申请额外的数组作为缓冲区存放中间结果

4、算法复杂度

    包括时间复杂度和空间复杂度

    前三种排序算法属于简单排序，也是内排序，在数据量较小时性能较好，其中以一般情况下以直接插入排序性能最优（有文献指出，当待排序数组长度小于7时，直接排序性能优于快速排序）。后四种排序方法在数据量较大时看情况使用，其中快速排序是综合性能最好的排序算法。

5、实现代码

#include <stdio.h>
#include <stdlib.h>
#define SIZE 10

void printArray(int arr[],int n)
{
	int i=0;
	for(i=0;i<n;i++)
		printf("%d ",arr[i]);
	printf("\n");
}

//BUBBLE SORT
void bubbleSort(int *a, int n)
{
	int i=0, j=0;
	int temp =0;
	int flag =1;
	for (i=0;i<n-1 && flag ;i++)  //这是改进后的冒泡排序算法
	{
		flag =0;
		for(j=n-1;j>i ;j--)
		{
			if(a[j]<a[j-1])
			{
				temp = a[j-1];
				a[j-1] = a[j];
				a[j] = temp;
				flag =1;
			}
		}
	}
}

//SEL SORT
void selSort(int a[], int n)
{
	int i=0,j=0,temp=0;
	int min=0;
	for(i=0;i<n;i++)
	{
		min = i;
		for(j=i+1;j<n;j++)
		{
			if(a[min]>a[j])
				min=j;
		}
		if(min != i)
		{
			temp = a[i];
			a[i] = a[min];
			a[min] = temp;
		}
	}
}

//INSERT SORT  直接插入排序是小规模排序中性能最好的
void insertSort(int *a , int n)
{
	int i=0,j=0,temp=0;
	//for(i=1;i<n;i++)
	//{
	//	for(j=i-1;j>=0;j--)
	//	{
	//		if(a[i]<a[j])
	//		{
	//			temp = a[i];
	//			a[i] = a[j];
	//			a[j] = temp;
	//			i--;
	//		}
	//		else 
	//			break;
	//	}
		printArray(a,10);
	//}
	for(i=1;i<n;i++)
	{
		if(a[i]<a[i-1])
		{
			temp = a[i];
			for(j=i-1;a[j]>temp;j--)
				a[j+1]=a[j];
			a[j+1] = temp;
		}
	}
}

//SHELL SORT
void shellSort(int a[],int n)
{
	int i,j,temp;
	int gap=n/2;
	while(gap>=1)
	{
		for(i=gap;i<n;i+=gap)
		{
			if(a[i]<a[i-gap])
			{
				temp = a[i];
				for(j=i-gap;a[j]>temp;j-=gap)
					a[j+gap]=a[j];
				a[j+gap] = temp;
			}
		}
		gap = gap/2;
	}
}

//HEAP SORT
void swap(int k[], int i, int j) //位运算实现的交换，不能交换两个相等的变量
{
	k[i] ^= k[j];
	k[j] ^= k[i];
	k[i] ^= k[j];
}
void heapAdjust(int k[], int s, int n)
{
	int i;
	int temp = k[s];
	for(i=2*s; i<=n; i*=2)
	{
		if(i<n && k[i]<k[i+1])
			i++;
		if(temp >= k[i])
		{
			break;
		}
		k[s] = k[i];
		s = i;
	}
	k[s]=temp; 
}
void heapSort(int a[], int n) //从数组的第1个元素开始排序，第0个元素不参与排序
{
	int i;
	for(i=n/2;i>0;i--)
	{
		heapAdjust(a,i,n);
	}

	for(i=n;i>1;i--)
	{
		swap(a,1,i);
 		heapAdjust(a,1,i-1);
	}
}

//MERGE SORT
void merge(int *l, int l_size, int *r, int r_size)
{
	int lp=0,rp=0,k=0,m=0;
	int temp[SIZE]={0};
	while(lp<l_size && rp<r_size)
	{
		if(l[lp]<r[rp])
			temp[k++] = l[lp++];
		else
			temp[k++] = r[rp++];
	}
	while(lp<l_size)
		temp[k++] = l[lp++];
	while(rp<r_size)
		temp[k++] = r[rp++];

	for(m=0;m<(l_size+r_size);m++)
		l[m] = temp[m];
	
}
void mergeSort_recursive(int k[], int n) //递归实现
{
	int *lList = k;
	int lList_size = n/2;
	int *rList = k+n/2;
	int rList_size = n-lList_size;

	if(n>2)
	{
		mergeSort_recursive(lList,lList_size);
		mergeSort_recursive(rList,rList_size);
	}
	merge(lList,lList_size,rList,rList_size);
}
void mergeSort_iterate (int k[], int n)  //迭代实现
{
	int i=0,l_min=0,l_max=0,r_min=0,r_max=0,next=0;
	int *temp = (int *)malloc(n*sizeof(int));
	if(temp == NULL)
	{
		printf("Malloc Fail!\n");
		exit(0);
	}
	for (i=1; i<n; i*=2) //步长
	{
		for(l_min=0;;)
		{
			r_min = l_max = l_min+i;// r_max - i = r_min = l_max = l_min + i
			r_max = r_min+i;
			if(l_max >= n)
				break;
			if(r_max > n)
				r_max = n;
			
			next = 0;
			while(l_min<l_max && r_min<r_max)
			{
				temp[next++] = (k[l_min]<k[r_min])? k[l_min++] : k[r_min++];
			}
			while(l_min<l_max)  //如果左边有剩余，右边一定r_min=r_max，这是将左边的剩余移到右边的尾部
				k[--r_min] = k[--l_max];
			while(next>0)
				k[--r_min] = temp[--next]; 
			printArray(k,n);
			l_min = r_min+2*i;
			if(l_min >= n)
				break;
		}
	}
	free(temp);
	temp = NULL;
}

//QUICK SORT
int position(int k[], int low, int high)
{
	int point = 0;
	/*********三点法优化point*************/
	int m=low + (high-low)/2;
	if(k[low] > k[high])
		swap(k,low,high);
	if(k[m] > k[high])
		swap(k,m,high);
	if(k[m] < k[low])
		swap(k,m,low);
	/**************************************/

	point = k[low];
	while(low < high)
	{
		while(low < high && k[high] >= point)
			high--;
		k[low] = k[high];  //没有必要交换，直接覆盖就可以了
		while(low < high && k[low] <= point)
			low++;
		k[high] = k[low];
	}
	k[low] = point;
	
	return low;
}
void qSort(int k[], int low, int high)
{
	int point;
	while(low<high)
	{
		point = position(k, low, high);
		if(point-low < high-point) //代码优化，形成尾递归
		{
			qSort(k,low,point-1);
			low = point + 1;
		}
		else
		{
			qSort(k,point+1,high);
			high = point - 1;
		}
	}
}
void quickSort(int k[], int n)
{
	qSort(k,0,n-1);
}

int main()
{
	int arr[10] = {0,3,2,5,11,54,2,24,9,7};
	printf("The raw array is: ");
	printArray(arr,10);
	//sort
	//heapSort(arr,9);
	quickSort(arr,10);
	printf("The sorted array is: ");
	printArray(arr,10);
	return 0;
}