交换排序——冒泡排序和快速排序

1. 冒泡排序

（1）算法思想：将序列中的第一个元素和第二个元素相比较，如前者大于后者，则交换，否则不交换；再将第二个元素和第三个元素比较，若前者大于后者，则交换两个元素的位置，否则不交换，依次进行，直到最后一个元素，经过如此一轮，则n个元素中最大的一个被放在了最后。此后，再进行相同的过程。

（2）基本实现：

void BubbleSort(DataType* arr, int sz)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < sz - 1; i++)
	{
		bool change = false;
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (arr[j]>arr[j + 1])
			{
				swap(arr[j], arr[j + 1]);
				change = true;
			}
		}
	}
}

（3）算法性能：

                      时间复杂度：O（n^2);

                      空间复杂度：O (1);

                       稳定性：稳定

2. 快速排序

（1）算法思想：快速排序的平均时间性能最快。任选序列中的一个数据元素（通常选取第一个数据元素或者最后一个数据元素）作为枢轴，用它和所有剩余数据元素进行比较，将所有较它小的元素排在它前面，将所有比它大的元素排在它后面，经过一趟排序后，可按此元素所在位置为界，将序列划分为两个部分，再重复此过程。

（2）基本实现：

       hare算法：

size_t Pation1(DataType *arr, int left, int right)
{
	int begin = left;
	int end = right - 1;
	int key = arr[end];
	while (begin<end)
	{
		while (begin < end&&arr[begin] <= key)
		{
			begin++;
		}
		swap(arr[begin], arr[end]);
		while (begin<end&&arr[end]>=key)
		{
			end--;
		}
		swap(arr[end], arr[begin]);
    }
	return begin;
}

      挖坑算法：

size_t Pation2(DataType* arr, int left, int right)
{
	int begin = left;
	int end = right-1 ;
	int key = arr[end];
	while (begin < end)
	{
		while (begin < end&&arr[begin] <= key)
			begin++;
		if (begin < end)
			arr[end] = arr[begin];
		while (begin < end&& arr[end] >= key)
			end--;
		if (begin < end)
			arr[begin] = arr[end];

       arr[begin] = key;
	 }
	return begin;
}

   两指针算法：     

size_t Pation3(DataType* arr, int left, int right)
{
	int sz = right - left;
	int cur = 0;
	int pre = cur - 1;
        int index=right-1;
	int key = arr[index];
	if (index != right - 1)
	{
		swap(arr[index], arr[right - 1]);
	}
	while (cur < sz)
	{
		if (arr[cur] <= key&&++pre != cur)
		{
			swap(arr[pre], arr[right - 1]);
		}
		cur++;
	}
	if (++pre != right)
	{
		swap(arr[++pre], arr[sz - 1]);
	}
	return pre;
}

 

（3）算法性能：

 

 

                      时间复杂度：O（n logn);

                      空间复杂度：O (logn);

                       稳定性：不稳定

在上面取枢轴的过程中，以最后一个元素为基准，这样在一般情况情况下是适用的，但是对于有序的序列来说，效率就比较低了，此时我们可以利用三数取中法来选取枢轴。

int GetMidData(DataType* arr, int left, int right)
{
	int mid = left + ((right - left) >> 1);
	if (arr[left]<arr[right - 1])
	{
		if (arr[left] > arr[mid])
			return left;
		else if (arr[right - 1] < arr[mid])
			return right - 1;
		else
			return mid;
	}
	else
	{
		if (arr[left] < arr[mid])
			return left;
		else if (arr[right - 1]>arr[mid])
			return right - 1;
		else
			return mid;
	}

}