基础排序:单元,冒泡,分治排序的C++实现与讨论

一.为什么需要学习排序？

上学的时候学习排序是为了考试，是为了不挂科，在实际问题中，排序就显得不是那么重要了。特别是当使用c++ STL时，排序就是非常简单的事情了。

但为什么还需要学习排序呢？我个人感觉是为了理解细想，培养能力的一个必不可少的过程，像标题所提示的3个排序算法一样，特别是其中的分治算法对解决一切其他很多问题有深远的影响。

二.排序的用处.

排序是为了什么，在我接触的问题中，第一是为了显示，在游戏中必不可少，第二是为了多次查找。

比如说一个散列的数组需要查找一次，那么就直接遍历吧。最悲剧的情况，复杂度为O(n).

如果需要查找多次的话，那么排序后查找肯定要好的多。比如我们下面提到的分治排序，算法复杂度为O(n*ln(n))，如果再使用2分查找的话，复杂度为
O(ln(n)).如果有n个数，要使用K次查找的话，那么总的复杂度为O(n*ln(n) +
K*ln(n))。使用直接遍历的话，那么复杂度为O(K * n).

从上面可以看出，当n或者K大于一个数的时候，排序后查找肯定速度要快得多。

三.实现排序

1.单元排序

int SelectionSort(int* arr, const int length)
{
assert(arr != NULL);
assert(length > 0);

int Cnt = 0;	// 计算交换次数

int len = length;
int MinIndex = 0;
int MinValue = 0;
for (int i = 0; i < len; ++i)
{
MinIndex = i;
MinValue = arr[i];
for (int j = i+1; j < len; ++j)	// 从第一个数的后面开始循环
{
if (arr[j] < MinValue)		// 比最下的值小
{
MinValue = arr[j];
MinIndex = j;
}
}
if ( MinValue != arr[i])
{
swap(&arr[i], &arr[MinIndex]);
++Cnt;
}
}
return Cnt;
}

讨论:

(1).每次排序完都把最小的排在前面，越到后面需要循环比较的次数越少;

(2).返回交换的次数,为了方便跟冒泡排序法比较;

(3).算法复杂度 O(n^2)

2.冒泡排序

int BubbleSort(int* arr, const int length)
{
int Cnt = 0;	// 计算交换次数
//for (int i = 0; i < length; ++i)		// 最直接版本
//{
//	for (int j = i; j < length; ++j)
//	{
//		if (arr[i] > arr[j])
//		{
//			swap(&arr[i], &arr[j]);
//			++Cnt;
//		}
//	}
//}
for (int i = 0, j = i; j < length; j++)	// 稍为改进版本，效果一样，
{
if (arr[i] > arr[j])
{
swap(&arr[i], &arr[j]);
++Cnt;
}
if (j == length-1)	// 到最后,重置
{
++i;
j = i;
}
}
return Cnt;
}

讨论:

(1).每次完都把最小的放在前面

(2).返回交换的次数,为了方便跟选择排序法比较

(3).算法复杂度O(n^2)

3.分治排序

int Merge(int* arr, const int start, const int mid, const int end)
{
int len = end-start+1;				// 计算长度
int* newArr = new int[len];
for (int x = start; x <= end; ++x)	// 把原数组[start, end] 赋值到新数组
{
newArr[x-start] = arr[x];
}
int _mid = mid - start;		// 新数组中间的值
int len1 = _mid+1;			// 前半段的长度
int i, j;
i = 0;						// 前半段的索引
j = _mid+1;					// 后半段的索引
int index = start;		// arr数组的索引
while ((index-start+1) <= len)		// 赋值没完 ,进行 len 次循环
{
if (i < len1 && j < len)		// 合并2个数组
{
if (newArr[i] < newArr[j])
{
arr[index++] = newArr[i++];
}
else
{
arr[index++] = newArr[j++];
}
}
else if (i == len1 && j <= len )		// 如果有一个比较完了，把另一个数组元素依次放入后面
{
arr[index++] = newArr[j++];
}
else if (j == len && i <= len1)
{
arr[index++] = newArr[i++];
}
}
delete[] newArr;
return index;
}
void DiviedMergeSort(int *arr, const int start, const int end)
{
if ((end-start) <= 1)					// 如果只有2个或者更少的元素
{
if (arr[start] > arr[end])			// 比较大小
{
swap(&arr[start], &arr[end]);	// 交换
}
}
else if (start < end)					// 如果有2个以上的元素，并且数组下标合法
{
int mid = (start + end) / 2;		// 计算中间的元素,如果是3个元素的话，前2个为一组，后2个为一组
DiviedMergeSort(arr, start, mid);	// 递归前面的一组
DiviedMergeSort(arr, mid+1, end);	// 递归后面的一组

Merge(arr, start, mid, end);		// 把分开的合并
}
}

讨论:

(1).把一个大的问题分成相同类型小的问题处理后，在组合起来

(2).大部分的交换都变成2个元素之间的交换，大大减少的循环的次数

(3).算法复杂度 O(n*ln(n))

附加上交换的代码：

void swap(int* p1, int* p2)
{
int temp;
temp = *p1;
*p1 = *p2;
*p2 = temp;
}

四.总结：

1.单元排序和冒泡排序的比较：

(1).算法复杂度都一样。

(2).冒泡排序的交换次数远远大于选择排序，所以不建议使用冒泡排序，我也很少看到有人使用冒泡排序。除了教科书上，因为最直接。

2.分治排序提高了很高的效率，但是实现起来也相对困难，不是那么直接。这也许就是对我这种执着的人有很大的魅力。有时候为了提高一点效率，硬是付出了很多的时间。哈哈~~~

3.关于分治排序的合并算法，当我写出后，去网上看看其他人写的，发现就我用了一个循环实现，有点感慨，也许N人都不把代码放出来，或者搜索引擎没搜到，反正至少满足了我一点荣誉感，对于程序原来说，也许就够了。

4.我不赞成使用自己写的排序，包括我自己写的我也不会使用，只是为了研究一个问题，得到一种思维，甚至可以说得到一点满足感。如果需要在问题中使用到算法，我绝不犹豫的把现有的问题映射到已经写好的算法中
，比如说使用c++ STL。既安全，有省事，何乐而不为呢？

PS：因水平有限，不免有什么不妥之处，请各大看官不吝赐教，谢谢~