排序算法

唉。。

HW的实习弄的很烦躁啊。。。过两天有可能要去上海参加企鹅的笔试。。。

效率低下啊。。。

神烦。。。

一个简单的排序算法

for(i=0;i<length;i++)
{
	for(j=i+1;j<length;j++)
	{
		if(r[i]>r[j])
			swap(r[i],r[j]);
	}
}

这样做每次排序会将最小的值排到最前面，但是效率低。

1.冒泡排序

for(i=0;i<length;i++)
{
	for(j=length-1;j>=i;j--)
	{
		if(r[j]>j[j+1])
			swap(r[j],r[j+1]);
	}
}

每次排序会将最小的值拍到最前面。

冒泡排序优化：

flag=true;
for(i=0;i<length&&flag;i++)
{
	flag=false;
	for(j=length-1;j>=i;j--)
	{
		if(r[j]>j[j+1])
			swap(r[j],r[j+1]);
		flag=true;
	}
}

加入flag进行判定，如果排到一半即有序，就不需要继续进行排序了

时间复杂度：最好O(n)，最坏O(n^2)，平均O(n^2)。稳定

2.简单选择排序

for(i=0;i<length;i++)
{
	min=i;
	for(j=i+1;j<length;j++)
	{
		if(r[min]>r[j])
			min=j;
	}
	if(i!=min)
	{
		swap(r[min],r[i]);
	}
}

一次排序过程中，虽然比较了length-1次，但是只交换了1次。

时间复杂度：O(n^2)。稳定

3.直接插入排序

for(i=2;i<length;i++)
{
	if(r[i]<r[i-1])
	{
		r[0]=r[i];
		for(j=i-1;r[j]>r[0];j--)
		{
			r[j+1]=r[j];
		}
		r[j+1]=r[0];
	}
}

时间复杂度：最好O(n)，最坏O(n^2)，平均O(n^2)。稳定

同样的时间复杂度，但是比冒泡与简单选择性能好

4.快速排序

void improveqsort(int *list, int m, int n)
{
	int i,j,k;
	if(m<n)
	{
		k=list[m];i=m;j=n+1;
		while(i<j)
		{
			for(i=i+1;i<n;i++)
			{
				if(list[i]>k)
					break;
			}
			for(j=j-1;j>m;j--)
			{
				if(list[j]<k)
					break;
			}
			if(i<j)
				swap(list[i],list[j]);
		}
		swap(list[j],list[m]);
	
		improveqsort(list, m, j-1);
		improveqsort(list, i, n);
	}
}

时间复杂度：最好O(nlogn) 平均O(nlogn) 最坏O(n^2)  不稳定

最坏情况为序列有序情况，退化为冒泡排序