排序算法-1

排序算法

1. 冒泡排序

冒泡排序的每次结果把序列中最小元素放到了排序的最终位置，这样最多n-1次冒泡就能把所有元素排好序。

	//冒泡排序 从小到大排列
void BubbleSort(Elemtype A[],int n)
{
	for(int i=0;i<n-1;i++)		//从(0-n-2)有n-1次，最后一次完成两个排列
	{
		flag=false;
		for(int j=n-1;j>i;j--)
			if(A[j-1]>A[j]){		//从小到大排序，如果前面的比后面的大交换顺序
				swap(A[j-1],A[j]);
				falg=true;  	//设置标志 发生了交换
			}
		if(!falg)			//本次循环从后到前都没有发生交换，说明是有序的退出循环
			return;	
	}
}
	

空间复杂度O(1),最好情况下时间复杂度O(n)，当初始序列为逆序时为最坏情况，移动次数 n(n-1)/2
,移动次数 3n(n-1)/2。则最坏情况下的时间复杂度为 O(n²),平均时间复杂度为 O(n²)。稳定的

2.快速排序

基于分治法实现的，每次找到一个pivot作为枢纽，将L[1…k-1]中所有元素都小于pivot,L[k+1…n]的元素大于pivot此时pivot放到了最终的位置上L[k]。
每一趟都完成一个pivot，即使一个元素位于最终的位置上。

void QuickSort(Elemtype A[],int low,int high)
{
	if(low<high)
	{
		//Partition() 方法为划分操作
		int pivotpos = Partition(A,low,high);	//划分
		QuickSort(A,low,pivotpos-1);	//依次对两个子表中的元素进行递归排序
		QuickSort(A,pivotpos+1,high);	//
	}
}

int Partition(Elemtype A[],int low,int high)
{
	Elemtype pivot=A[low];
	while(low<high)		//low==high跳出循环
	{
		//从后往前找到一个比privot小的元素
		while(low<high&&A[high]>=pivot)  high--;
		A[low]=A[high];   //将比枢纽小的放到左端
		//从前往后找一个比privot大的元素
		while(low<high&&A[low]<=pivot)  low++;
		A[high]=A[low];		//将比枢纽大的放到右端
	}
	A[low] = pivot;
	return low;
}

空间效率：借助一个队规工作栈保存每层递归调用的必要信息，最好情况下为 O(log₂ⁿ)，最坏情况下为
O(n)，平均情况下O(log₂ⁿ)。 时间效率：快速排序的运行时间与划分是否对称有关。最好情况 O(nlog₂ⁿ)，最坏情况 O(n²)。这是所有内部排序算法中平均效率最优的排序算法。也是不稳定的。
每趟结束都有一个元素位于最终位置