常用排序算法

常用排序算法

1.冒泡排序（Bubble Sort）

平均时间复杂度	最好时间复杂度	最坏时间复杂度	空间复杂度	稳定性
n^2	n	n^2	O(1)	稳定

#define swap(a,b) {typeof(a) t=a;a=b;b=t;} //下同
void bubble(int* arr,size_t len)
{
	bool flag = true;
	for(int i=len-1;i>0 && flag;i--)
	{
		flag = false;
		for(int j=0;j<i;j++)
		{
			if(arr[i] < arr[j])
			{
				swap(arr[j],arr[j+1]);
				flag = true;
			}
		}
	}
}

2.选择排序（Selection Sort）

平均时间复杂度	最好时间复杂度	最坏时间复杂度	空间复杂度	稳定性
n^2	n^2	n^2	O(1)	不稳定

void sel(int* arr,size_t len)
{
	for(int i=0;i<len-1;i++)
	{
		int min = i;
		for(int j=i+1; j<len; j++)
		{
			if(arr[j]<arr[min]) min = j;
		}
		if(min != i) swap(arr[min],arr[i]);
	}
}

3.插入排序（Insertion Sort）

平均时间复杂度	最好时间复杂度	最坏时间复杂度	空间复杂度	稳定性
n^2	n	n^2	O(1)	稳定

void insert(int* arr,size_t len)
{
	for(int i=1,j=0;i<len;i++)
	{
		int val = arr[i];
		for(j = i;j>0 && arr[j-1] > val;j--) arr[j] = arr[j-1];
		if(j != i) arr[j] = val;
	}
}

4.希尔排序（Shell Sort）

平均时间复杂度	最好时间复杂度	最坏时间复杂度	空间复杂度	稳定性
n^1.3	n	n^2	O(1)	不稳定

void shell(int* arr,int size)
{
	int i,j,temp,step;
	for(step = size/2;step > 0;step /= 2)
	{
		for(i = step;i < size;i++)
		{
			temp = arr[i];
			for(j = i-step;j >= 0 && temp < arr[j];j -= step)
			{
				arr[j+step] = arr[j]; 
			}
			arr[j+step] = temp;
		}
	}
}

5.堆排序（Heap Sort）

平均时间复杂度	最好时间复杂度	最坏时间复杂度	空间复杂度	稳定性
nlog2n	nlog2n	nlog2n	O(1)	不稳定

void create_heap(int* arr,int root,size_t len)
{
	if(root>=len)return;
	int left = root*2+1,right = root*2+2;
	create_heap(arr,left,len);
	create_heap(arr,right,len);
	if(right<len && arr[right] > arr[left]) swap(arr[right],arr[left]);
	if(left<len && arr[left]>arr[root]) swap(arr[left],arr[root]);
}

void heap(int* arr,size_t len)
{
	create_heap(arr,0,len);
	for(int i=len-1;i>=0;i--)
	{
		swap(arr[0],arr[i]);
		create_heap(arr,0,i);
	}
}

6.快速排序（Quick Sort）

平均时间复杂度	最好时间复杂度	最坏时间复杂度	空间复杂度	稳定性
nlog2n	nlog2n	n^2	O(n)或者O(log2n)	不稳定

void quick(int* arr,int left,int right)
{
	if(left >= right) return;
	int p = (left+right)/2;
	int tmp = arr[p];
	int l = left,r = right;
	while(l < r)
	{
		while(l<p && arr[l] <= tmp) l++;
		if(l < p)
		{
			arr[p] = arr[l];
			p = l;
		}
		while(r>p && arr[r] >= tmp) r--;
		if(r>p)
		{
			arr[p] = arr[r];
			p = r;
		}
	}
	arr[p] = tmp;
	if(p-left>1) quick(arr,left,p-1);
	if(right-p>1) quick(arr,p+1,right);
}

7.归并排序（Merge Sort）

平均时间复杂度	最好时间复杂度	最坏时间复杂度	空间复杂度	稳定性
nlog2n	nlog2n	nlog2n	O(n)	稳定

void merge(int* arr,int* tmp,int l,int p,int r)
{
	if(arr[p] <= arr[p+1]) return;
	int i= l,j = p+1,k = l;
	while(i<=p && j<=r)
	{
		if(arr[i]<arr[j]) tmp[k++] = arr[i++];
		else tmp[k++] = arr[j++];
	}
	while(i<=p)tmp[k++] = arr[i++];
	while(j<=r)tmp[k++] = arr[j++];
	while(l<=r)arr[l] = tmp[l++];
}

void merge2(int* arr,int* tmp,int l,int r)
{
	if( l>= r)return;
	int p = (l+r)/2;
	merge2(arr,tmp,l,p);
	merge2(arr,tmp,p+1,r);
	merge(arr,tmp,l,p,r);
}

void merge3(int* arr,size_t len)
{
	int* tmp = malloc(sizeof(int)*len);
	merge2(arr,tmp,0,len-1);
	free(tmp);
}