排序算法总结

排序算法汇总

---

    排序算法有冒泡排序、选择排序、插入排序、归并排序和快速排序。最近写了一下，在这里做一下总结。

    冒泡排序是最简单的排序算法之一，重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素已经排序完成。

void bubbleSort(int A[],int L)//A为数组头指针，L为数组长度
{
	for(int i = 0;i < L-1;i++)
	{
		for(int j = 0;j < L-1;j++)
		{
			if(A[j] > A[j+1])
			{
				int tmp = A[j];
				A[j] = A[j+1];
				A[j+1] = tmp;
			}
		}
	}
}

    选择排序是指，对一个序列A中的元素A[0]~A[L-1]，令i 从0到L-1枚举，进行L趟操作，每趟从待排序部分[i,L-1]中选择最小的元素，令其与待排序部分的第一个元素A[i]进行交换，这样元素元素A[i]就会与当前有序区间[0,i-1]形成新的有序区间[0,i]，于是在L趟操作后，所有元素都会是有序的。算法的复杂度为$O(n^2)$。

void selectSort(int A[],int L)
{
	for(int i = 0;i < L;i++)
	{
		int k = i;
		for(int j = i;j < L;j++)
		{
			if(A[j] < A[k])
			{
				k = j;
			}
		}
		int tmp = A[i];
		A[i] = A[k];
		A[k] = tmp;
	}
}

    插入排序中最简单的一类是是直接插入排序，直接插入排序是指，对序列A的L个元素A[0]至A[L-1]，令i从1到L-1枚举，进行L-1趟操作。假设某一趟时，序列A的前i个元素A[0]至A[i-1]已经有序，而范围[i,L-1]还未有序，那么该趟从范围[0,i-1]中寻找某个位置j，是的将A[i]插入位置j后（此时A[j]到A[i-1]会后移一位至A[j+1]~A[i]），范围[0,i]有序。

void insertSort(int A[],int L)
{
	for(int i = 1;i < l;i++)
	{
		int j = i,tmp = A[i];
		
		while(j > 0 && A[j-L] > tmp)
		{
			A[j] = A[j-1];
			j--;
		}
		A[j] = tmp;
	}
}

    归并排序是一种基于“归并”思想的排序方法，其中，2-路归并排序是一种比较有代表性的归并排序算法。其原理是，将序列两两分组，将序列归并为n/2个组，组内单独排序；然后将这些组再两两归并，生成n/4个组，组内再单独排序；以此类推，知道剩下一个组为止。归并排序的时间复杂度为O(nlogn)。

void merge(int A[],int l1,int r1,int l2,int r2)
{
	int i = l1,j = l2,k = 0;
	int tmp[1010];
	while(i <= r1 && j <= r2)
	{
		if(A[i] < A[j])
		{
			tmp[k] = A[i];
			i++;
		}
		else
		{
			tmp[k] = A[j];
			j++;
		}
		k++;
	}
	while(i<=r1)tmp[k++] = A[i++];
	while(j<=r2)tmp[k++] = A[j++];

	for(int ii = l1;ii < l1 + k;ii++)
	{
		A[ii] = tmp[ii-l1];
	}
}

void mergeSort(int A[],int l,int r)
{
	if(l < r)
	{
		int mid = (l+r)/2;
		mergeSort(A,l,mid);
		mergeSort(A,mid+1,r);
		merge(A,l,mid,mid+1,r);
	}
}

    快速排序是排序算法中时间复杂度为O(nlogn)的一种算法，其实现需要先解决这样一个问题，对一个序列A[0]、A[1]、… 、A[L-1]，调整序列中元素的位置，使得A[0]（原序列的A[0]）的左侧所以元素都不超过A[0]、右侧所有元素都大于A[0]。例如对序列{5,3,9,6,4,1}来说，可以调整序列中元素的位置，形成序列{3,1,4,5,9,6}，这样就让A[0]=5左侧的所有元素都不超过它、右侧所有元素都大于它。

int partition(int A[],int left,int right)
{
	int tmp = A[left];
	while(left < right)
	{
		while(left < right && A[right] > tmp)right--;
		a[left] = a[right];
		while(left < right && A[left] <= tmp)left++;
		A[right] = A[left];
	}
	A[left] = tmp;
	return left;
}
void quickSort(int A[],int left,int right)
{
	if(left < right)
	{
		int pos = partition(A,left,right);
		quickSort(A,left,pos - 1);
		quickSort(A,pos + 1,right);
	}
}