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

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）基本实现：
      [b] hare算法：[/b]


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;
}
 [b]  两指针算法：     [/b]

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;
}

}