经典排序算法-快速排序（挖坑法、前后指针法）、基数排序

快速排序在实际应用中是比较表现好的排序算法。快速排序我用两种方法实现它。

第一种为方法，形象的称为：挖坑法

基本思路：1、寻找pos位，然后将其分为两段数组，然后对这两段数组递归排序；

                    2、指定一个基数temp（三数取中法），定义两个指针begin一个指向起始位置，end一个指向最后一个元素的位置。begin寻找比基数（temp）大的数字，找到 后将begin的数据赋给end，begin成为一个坑，然后end寻找比基数（temp）小的数字，找到将end的数据赋给begin，end成为一个新坑，循环这个过程，直到begin指针与end指针相遇，然后将temp的数据返回给那个坑，然后进行递归操作。



 代码实现为：

int PastSort1(int *arr, int left, int right) //挖坑法
{
int begin = left;
int end = right;
int temp = arr[mid(arr,left,right)];
while (begin < end)
{
while (begin < end && arr[begin] <= temp)
begin++;
if (begin < end)
arr[end] = arr[begin];//begin成为新坑
while (begin < end && arr[end] >= temp)
end--;
if (begin < end)
arr[begin] = arr[end]; //end成为新坑
}

arr[begin] = temp; //将temp填补进去
return begin;
}

void QuickSort(int *arr,int left,int right)
{
if (arr == NULL || left > right)
return;

int pos = PastSort1(arr, left, right);

QuickSort(arr, left, pos - 1);
QuickSort(arr, pos + 1, right);
}前后指针法：
定义两个指针，一前一后，前面指针找比基数小的数，后面指针找比基数大的数，前面的指针找到后，将前后指针所指向的数据交换，当前面的指针遍历完整个数组时，将基数值与后指针的后一个位置的数据进行交换，然后以后指针的后一个位置作为分界，然后将数组分开，进行递归排序。

代码实现：
int PastSort2(int* arr, int left, int right) //前后指针法
{
int cur = left; //找小
int ptr = left-1;//找大
int temp = arr[mid(arr, left, right)];
while (cur < right)
{
if (arr[cur] < temp)
{
swap(arr[cur], arr[++ptr]);
}
cur++;
}
swap(arr[++ptr], arr[right]);
return ptr;
}

void QuickSort(int *arr,int left,int right)
{
if (arr == NULL || left > right)
return;

int pos = PastSort2(arr, left, right);

QuickSort(arr, left, pos - 1);
QuickSort(arr, pos + 1, right);
}


基数排序：
基本原理是：











代码实现为：

int getbit(int* arr,int size) //获得最大位数
{
int bits = 1;
int rang = 10;
for (int i = 0; i < size; ++i)
{
while (arr[i] >= rang)
{
++bits;
rang *= 10;
}
}
return bits;
}

void BucketSort(int* arr, int size)
{
int bits = getbit(arr, size);
int radix = 1;
int count[10];
for (int bit = 1; bit <= bits;bit++) //循环最大位数次
{
memset(count, 0, sizeof(int)* 10);
for (int i = 0; i < size; ++i)//统计数字位数的数量
{
int index = (arr[i] / radix) % 10;
count[index]++;
}

for (int j = 1; j < 10; j++) //固定数值排序的位置
{
count[j] = count[j] + count[j - 1];
}
int *str = new int[size];
memset(str, 0, sizeof(int)*size);
for (int i = size-1; i >=0; i--)//按照固定的位置将数据写入辅助数组
{
int index = (arr[i] / radix) % 10;
str[count[index]-1] = arr[i];
count[index]--;
}
radix = radix * 10;
for (int i = 0; i < size; i++) //将辅助数组中的数拷贝回原数组
{
arr[i] = str[i];
}
delete[] str;
}
}前面我用了三篇文章来写几种常见的排序方法，我用一个图简单分析一下他们的最好最坏平均时间复杂度，以及空间复杂度，与稳定性分析。