面试经典算法1之交换排序

交换排序的典型代表有：

(1)  冒泡排序

(2)  快速排序

冒泡排序：每趟都是比较相邻的两个元素，如果逆序，则将两者交换。每趟都是从数组的第一个元素开始扫描。

冒泡排序代码：

bool BubbleSort(int A[],int n)
{
	if (A==NULL||n<=0)
	{
		printf("Parameters for function BubbleSort error!\n");
		return false;
	}

	bool flag = true;
	
	for (int i=0;i<n-1&&flag;i++)  //n-1趟即可
	{
		flag = false;
		for (int j=0;j<n-i-1;j++) //从大到小
		{
			if (A[j]<A[j+1])
			{
				int temp = A[j+1];
				A[j+1] = A[j];
				A[j] = temp;
				flag = true;
			}
		}	
	}
	return true;
}

注意事项：

(1) i,j变量的取值范围，i决定扫描的趟数，最多只需n-1次扫描，即可是数组有序。j取值范围，i的值表示已经有i个数排好序，而一共有n个数，所以还有n-i个数没有排好序，右因为j的下标是从0开始不是从1开始的，所以没排好序的是A[0]、A[1]....A[n-i-1]，因为下面是那A[j]与A[j+1]比较，所以j应小于n-i-1。

(2) flag标志变量的作用是当某一趟扫描中，若没有发生交换，说明所有数据已经有序了，则排序过程完成。

(3) 若真正面试时，不可忘记函数开始的那段代码，对输入参数检查。

算法效率分析：

最好情况：初始序列为正序序列，只需进行一次排序，在此过程中进行n-1次比较，不移动   数据。

最差情况：初始序列为逆序序列，需要进行n-1趟排序，需要进行内n(n-1)/2次比较，并且   移动数据，每次比较都必须移动记录三次来达到交换记录位置。因此总的时间复杂度为O(n2)。

冒泡排序是就地排序，是稳定的。 

快速排序：快速排序采用的是分治的思想。将待排序的数组划分为多个子数组，若每一个子数组排好了序，则整个数组就排好了序。对于每一个划分的子数组，采用如下思想排序：假设数组第一个元素为A[0]，我们所要做的是找到A[0]这个元素应该放的位置(假设为j)，也即使A[j]前面的元素都小于它A[0]，A[j]后面的元素都大于A[0].

快速排序代码：

//划分函数
int Partition(int A[],int L,int R) 
{
	int i,j;
	i = L;
	j = R;
	int pivot = A[0];
	while(i<j)
	{
		while(i<j&&A[j]>pivot)
		{
			j--;
		}
		if(i<j)
		{
			A[i] = A[j];
			i++;
		}
		while(i<j&&A[i]<pivot)
		{
			i++;
		}
		if(i<j)
		{
			A[j] = A[i];
			j--;
		}
	}
	A[i] = pivot;
	return i;
}

bool QuickSort(int A[],int L,int R)
{
	if(A==NULL||L>R||L<0||R<0)
	{
		printf("Paraments for function QuickSort Error!\n");
		return false;
	}
	
	int pivot = Partition(A,L,R);
	QuickSort(A,L,pivot-1);
	QucikSort(A,pivot+1,R);
	
	return true;
}

快速排序的时间复杂度为O(n*log 2 n)，它是一种不稳定的排序。