排序小结sort

排序小结

成都创新互联专业为企业提供麦积网站建设、麦积做网站、麦积网站设计、麦积网站制作等企业网站建设、网页设计与制作、麦积企业网站模板建站服务，10多年麦积做网站经验，不只是建网站，更提供有价值的思路和整体网络服务。

排序算法是基础之基础。在这里小结一下。方便自己查阅和学习。

1.冒泡排序(BubbleSort)

思想：比较相邻的两个元素，如果前面的元素大于后面的元素，交换之。

思路：采用双层循环。外循环控制要处理多少趟。里面循环用来做元素的交换操作。注意上下界。

稳定性：稳定

时间复杂度：O(n2)

void bubbleSort(int a[], int size)
{
	int tmp;
	for (int i = 0; i < size; i++)
	{	//每一趟都会把最大的元素放入最右边的位置
		//最右边的位置会一点点往左移动
		for (int j = 0; j < size - i - 1; j++)
		{
			if (a[j] > a[j + 1])
			{
				tmp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = tmp;
			}
		}
	}
}

2.快速排序(quickSort)

思想：找到第一个元素的最终位置，然后对数组进行分割，对左边的进行快排，对右边的进行快排。

思路：采用递归，需要一个辅助函数findPos()来找到某一个元素的最终位置。

稳定性：不稳定

时间复杂度：有时O(nlogn),最坏情况是已经排好序，这样时间复杂度为O(n2)

伪算法

/*

 * 快速排序（伪算法） 2016-08-14 11:01:34

 * 1.先找到第一个元素的最终位置

 * 2.对第一个元素的最终位置之前的元素，进行快速排序。

 * 3.对第一个元素的最终位置之后的元素，进行快速排序。

 *

*/

int findPos(int a[],int low,int high)
{	
	int val = a[low];
	while(low < high)
	{
		//因为val取的是最前面的值，所以先从后往前遍历比较
		while(low < high && a[high] >= val)
			high--;
		a[low] = a[high];//将后面较小值赋值给前面已经做好备份的位置上
		//然后从前往后遍历比较
		while(low < high && a[low] <= val)
			low++;
		a[high] = a[low];//将前面较大值赋值给后面已经做好备份的位置上
	}
	a[low] = val;
	return low;
}

void quickSort(int a[],int low,int high)
{
	if(low < high)
	{
		int pos = findPos(a,low,high);
		quickSort(a,low,pos-1);
		quickSort(a,pos+1,high);
	}
}

3.直接插入排序(insertSort)也叫选择插入排序

思想：将第i个元素插入到前面i-1个已排好序的记录中。直到所有的元素都排一次。

思路：见伪算法

稳定性：稳定

时间复杂度：O(n2)

伪算法

/*

* 插入排序（伪算法） 2016-08-14 12:23:09

* 1. 将相邻的两个元素比较，如果前面的数大于后面的数，则交换。

*    直到找到前面的数小于后面的，就把这个值插入到这个位置。

* 2. 循环1，直到所有的元素都有序排列。

*

*/

void insertSort(int a[], int size)
{
	int i, j, tmp;
	for (i = 0; i < size; i++)
	{
		tmp = a[i];
		for (j = i - 1; j >= 0 && a[j] > tmp; j--)
		{
			a[j+1] = a[j];
		}
		a[j + 1] = tmp;
	}
}

4.选择排序(selectSort)

思想：每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在待序列的起始位置。 

思路：见伪算法

稳定性：不稳定

时间复杂度：O(n2)

伪算法

/*

* 选择排序（伪算法） 2016-08-14 13:08:50

* 1. 工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在待序列的起始位置。 

* 2. 循环1，直到全部待排序的数据元素排完。

*

*/

void selectSort(int a[], int size)
{
	int currentSmallIndex;//记录待排序队列中最小元素的下标
	int tmp;//记录最小元素的大小
	for (int i = 0; i < size; i++)
	{
		tmp = a[i];
		currentSmallIndex = i;
		for (int j = i + 1; j < size; j++)
		{
			if (a[j] < tmp)
			{
				currentSmallIndex = j;
				tmp = a[j];
			}
		}
		a[currentSmallIndex] = a[i];
		a[i] = tmp;
	}
}

5.归并排序(mergeSort)

思想：将数组递归分成2半，知道数组的长度为1，然后将分成2半的数组合并。

思路：需要使用辅助函数merge()来合并

稳定性：稳定

时间复杂度：O(n2)

伪算法

/*

1.将数组分成左右两半

2.递归1，直道只剩1个元素的时候，然后合并。

 */

void merge(int a[], int start, int end)
{
	int mid = (start + end) / 2;
	int left, right;
	int * temp = new int[end - start + 1];

	int k = 0;//临时数组的下标
	left = start;
	right = mid + 1;

	while (left <= mid && right <= end)
	{
		while ((left <= mid && right <= end) && (a[left] < a[right]))
			temp[k++] = a[left++];

		while ((left <= mid && right <= end) && (a[right] < a[left]))
			temp[k++] = a[right++];
	}

	while (left <= mid)
		temp[k++] = a[left++];

	while (right <= end)
		temp[k++] = a[right++];

	//将临时数组中的元素，找到原数组的位置，按位赋值过去。
	//这里需要注意原数组的起始位置是start，而不是0
	for (int i = start, k = 0; i <= end; i++, k++)
		a[i] = temp[k];

	delete[] temp;
}

void mergeSort(int a[], int start, int end)
{
	if (start < end)
	{
		int mid = (start + end) / 2;
		mergeSort(a, start, mid);	//左数组合并排序
		mergeSort(a, mid + 1, end);	//右数组合并排序
		merge(a, start, end);		//整体排序
	}
}

排序总结未完待续。

2016-08-14 16:11:27