插入排序，冒泡排序和选择排序是基本的排序方法，平均情况下时间复杂度是O(n2)。
插入排序对于规模很小的元素序列（n<=25）很有效，最好情况下只需要n-1次比较，不需要交换操作。在平均情况和最差情况下，比较和交换都是O(n2)的。
改进的冒泡排序在最好情况下只需要一次冒泡过程，n-1次比较。
选择排序的比较操作与初始排列无关，比较次数总是O(n2)，最好情况下，不移动，最差情况移动不超过3(n-1)次。
三种基本排序方法只需要一个辅助元素，主要用于元素个数n<10K的情况。
归并排序的一个特性是性能与输入元素序列无关，时间复杂度总是O(nlgn)。主要缺点是直接执行需要O(n)的附加内存空间。另一个优势是稳定排序算法。
堆排序是一种高效的内部排序算法，平均情况时间复杂度为O(nlgn)，没有什么最坏情况会导致堆排序的运行明显变慢，基本不需要额外空间。但是堆排序不太可能提供比快速排序更好的平均性能，不稳定算法。
快速排序是最通用的高效内部排序算法，平均情况时间复杂度为O(nlgn)，所需要的额外内存是O(lgn)。不稳定算法，在元素序列有序是会退化，时间复杂度增加到O(n2)，空间复杂度增加到O(n)。可以用找三个元素中位数来避免。
希尔排序的时间复杂度介于基本排序算法和高效算法之间，代码简单，不需要什么额外内存，不稳定算法。对于中等规模(n<=1000)，希尔排序是一种很好的选择。
计数排序的时间复杂度为O(k+n)，当k=O(n)时，为O(n)。计数排序的下界优于O(nlgn)，因为它不是一个比较排序算法，计数排序是用来输入元素的实际值来确定它们在数组中的位置。计数排序的一个重要性质就是他是稳定的，它经常用作基数排序算法的一个子过程。
基数排序的运行时间为O(n)，这看上去要比快速排序的平均情况时间O(nlgn)更好一些。然而，在这两个时间中，隐含在O几号中的常数因子是不同的。对于要处理的n个关键字，尽管基数排序执行的遍数可能比快速排序要少，但每一遍所需的时间都要长得多。哪一个排序算法更好取决于底层机器的实现特性(例如，快速排序通常可以比基数排序更为有效地利用硬件缓存)，同时还取决于输入的数据。此外，利用计数排序作为中间稳定排序的技术排序不是原地排序，而很多O(nlgn)时间的比较排序算法则可以做到原地排序。当内存比较宝贵时，快速排序这样的原地排序更为可取。
1、冒泡排序
//-------------冒泡排序begin-----------------
template <class T>
void babbleSort(T a[], int n)
{
for (int i = 0; i < n; i++)
{
for (int j = n - 1; j > i; j--)
{
if (a[j] < a[j - 1])
{
T tmp = a[j];
a[j] = a[j - 1];
a[j - 1] = tmp;
}
}
}
}
//-------------冒泡排序end-----------------
2、插入排序
//-------------插入排序begin-----------------
template <class T>
void insertSort(T a[], int n)
{
for (int i = 1; i < n; i++)
{
T elem = a[i];
int j = 0;
for (j = i; j > 0; j--)
{
if (a[j - 1] < elem)
{
break;
}
a[j] = a[j - 1];
}
a[j] = elem;
}
}
//-------------插入排序end-----------------
3、选择排序
//-------------插入排序begin-----------------
template <class T>
void insertSort(T a[], int n)
{
for (int i = 1; i < n; i++)
{
T elem = a[i];
int j = 0;
for (j = i; j > 0; j--)
{
if (a[j - 1] < elem)
{
break;
}
a[j] = a[j - 1];
}
a[j] = elem;
}
}
//-------------插入排序end-----------------
4、归并排序
//-------------递归归并排序begin-----------------
template<class T>
void merge(T a[], int beg, int mid, int end)
{
T *tmp = new T[end - beg + 1];
int beg1 = beg;
int end1 = mid;
int beg2 = mid + 1;
int end2 = end;
int k = 0;
while(beg1 <= end1 && beg2 <= end2)
{
if (a[beg1] <= a[beg2])
{
tmp[k++] = a[beg1++];
}
else
{
tmp[k++] = a[beg2++];
}
}
while (beg2 <= end2)
{
tmp[k++] = a[beg2++];
}
while (beg1 <= end1)
{
tmp[k++] = a[beg1++];
}
memcpy(a + beg, tmp, (end - beg + 1) * sizeof(T));
delete []tmp;
}
template<class T>
void mergeSort(T a[], int beg, int end)
{
int mid = int((beg + end)/2);
if (beg < end)
{
mergeSort(a, beg, mid);
mergeSort(a, mid + 1, end);
merge(a, beg, mid, end);
}
}
//-------------递归归并排序end-----------------
//-------------非递归归并排序begin-----------------
template <class T>
void merge(T src[], T dst[], int beg, int mid, int end)
{
int beg1 = beg;
int end1 = mid;
int beg2 = mid + 1;
int end2 = end;
int k = beg;
while(beg1 <= end1 && beg2 <= end2)//选择两个序列中较小的
{
if (src[beg1] <= src[beg2])
{
dst[k++] = src[beg1++];
}
else
{
dst[k++] = src[beg2++];
}
}
while (beg2 <= end2)//复制两序列中剩余部分
{
dst[k++] = src[beg2++];
}
while (beg1 <= end1)
{
dst[k++] = src[beg1++];
}
}
template <class T>
void merge_pass(T src[], T dst[], int step, int len)
{
int i = 0;
//按照step划分子序列进行归并，step=2时 src划分为[X1 X2][X3 X4]......
for (i = 0; i <= len - 2 * step; i += 2 * step)
{
merge(src, dst, i, i + step - 1, i + 2 * step - 1);
}
//最后剩余不足两个子序列，但是足够一个子序列，进行归并
if (i + step < len)
{
merge(src, dst, i, i + step - 1, len - 1);
}
//将剩余的复制到尾部
else
{
for (int j = i; j < len; j++)
{
dst[j] = src[j];
}
}
}
template <class T>
void mergeSortUnrecursive(T a[], int len)
{
int step = 1;
T *tmp = new T[len];
while (step < len)
{
//交替使用a和tmp，进行偶数次归并保证最后将结果放在a中
merge_pass(a, tmp, step, len);
step *= 2;
merge_pass(tmp, a, step, len);
step *= 2;
}
}
//-------------非递归归并排序end-----------------
5、堆排序
//-------------堆排序begin-----------------
template <class T>
void maxHeapify(T a[], int i, int size)
{
//左子女
int left = 2 * i + 1;
T tmp = a[i];
while (left <= size)
{
//存在右子女并且大于左子女
if (left < size && a[left] < a[left+1])
left++;
//子女不大于当前值
if (tmp >= a[left])
break;
else
{
//子女向上移动
a[i] = a[left];
i = left;
left = 2 * i + 1;
}
}
//最开始的结点值保存到最终位置
a[i] = tmp;
}
template <class T>
void heapSort(T a[], int size)
{
//建立最大堆
for (int i = size/2 - 1; i>=0; i--)
maxHeapify(a, i, size);
//交换第一个和最后一个，然后调整为最大堆
for (int i = size - 1; i > 0; i--)
{
T tmp = a[0];
a[0] = a[i];
a[i] = tmp;
maxHeapify(a, 0, i - 1);
}
}
//-------------堆排序end-----------------
6、快速排序
//-------------快速排序(原始)begin-----------------
template <class T>
int partition(T a[], int low, int high)
{
int pos = low;
T posElem = a[low];
for (int i = low + 1; i <= high; i++)
{
//小于基准元素的交换到左侧
if (a[i] < posElem)
{
pos++;
if (pos != i)
{
T tmp = a[i];
a[i] = a[pos];
a[pos] = tmp;
}
}
}
a[low] = a[pos];
a[pos] = posElem;
return pos;
}
template <class T>
void quickSort(T a[], int low, int high)
{
if (low < high)
{
int pos = partition(a, low, high);
quickSort(a, low, pos - 1);
quickSort(a, pos + 1, high);
}
}
//-------------快速排序(原始)end-----------------
研究表明，序列长度为5到25是，采用直接插入排序比快速排序至少快10%，当排序序列小于某规模时直接使用插入排序
//-------------快速排序(小规模插入排序)begin-----------------
template <class T>
void quickSort_insert(T a[], int low, int high)
{
//小于一个规模直接使用插入排序
if (high - low <= 80)
{
insertSort(a, low, high);
}
else
{
int pos = partition(a, low, high);
quickSort_insert(a, low, pos - 1);
quickSort_insert(a, pos + 1, high);
}
}
//-------------快速排序(小规模插入排序)end-----------------
取基准对象是采用在序列左端low，右端high和中点位置mid=(low+high)/2中去中间值，并且交换到high位置。这样可以避免出现退化的情况。
研究表明，将三个元素的中间元素法和小规模终止两个改进措施结合起来，可以讲递归实现的快速排序效率提高20%到25%。
//-------------快速排序(小规模停止后插入排序+三者取中)begin-----------------
template <class T>
T &median3(T a[], int low, int high)
{
int mid = (low + high)/2;
int k = low;
//三者选最小为k
if (a[mid] < a[k])
k = mid;
if (a[high] < a[k])
k = high;
//最小值交换到low
if (k != low)
{
T tmp = a[k];
a[k] = a[low];
a[low] = tmp;
}
//mid为中间值，交换到high
if (mid != high && a[mid] < a[high])
{
T tmp = a[mid];
a[mid] = a[high];
a[high] = tmp;
}
return a[high];
}
template <class T>
int partition_median3(T a[], int low, int high)
{
int pos = low;
//去三者中值
T posElem = median3(a, low, high);
for (int i = low; i < high; i++)
{
if (a[i] < posElem)
{
pos++;
if (pos != i)
{
T tmp = a[i];
a[i] = a[pos];
a[pos] = tmp;
}
}
}
a[high] = a[pos];
a[pos] = posElem;
return pos;
}
template <class T>
void quickSortHybrid(T a[], int low, int high)
{
//小于某规模停止
if (high - low <=200)
return;
int pos = partition_median3(a, low, high);
quickSort(a, low, pos - 1);
quickSort(a, pos + 1, high);
}
template <class T>
void quickSort_insertHybrid(T a[], int low, int high)
{
quickSort(a, low, high);
//对基本有序的序列进行插入排序
insertSort(a, low, high);
}
//-------------快速排序(小规模停止后插入排序+三者取中)end-----------------
当待排序元素序列有大量重复排序码是，快速排序算法的效率将会降到非常之低，三路划分的中间部分为与基准元素等值的。
//-------------快速排序(三路划分)begin-----------------
template <class T>
void quickSort3Partition(T a[], int low, int high)
{
if (low >= high)
return ;
T posElem = a[high];
int i = low - 1, j = high, p = low - 1, q = high;
int k = 0;
while (true)
{
while (a[++i] < posElem && i < j);
while (a[--j] > posElem && i < j);
if (i >= j)
break;
swap(a[i], a[j]);
if (a[i] == posElem)
swap(a[i], a[++p]);
if (a[j] == posElem)
swap(a[j], a[--q]);
}
if (a[i] > a[high])
{
swap(a[i], a[high]);
k = high - 1;
}
else
k = high - 1;
//j--;
i++;
while (k >= q)
swap(a[k--], a[i++]);
for (k = low; k <= p;)
swap(a[k++], a[j--]);
for (int m = low ; m<=high; m++)
{
cout << a[m] << " ";
}cout <<"i=" << i << "j=" <<j << "p=" << p << "q=" << q << "k=" << k;
cout <<endl;
quickSort3Partition(a, low, j);
quickSort3Partition(a, i, high);
}
//-------------快速排序(三路划分)end-----------------
一般书上的快速排序法都是用递归实现的，递归是编译器自动用栈来实现的。当递归层次比较深时，需要占用比较大的进程栈空间，还有进程栈溢出的危险。很多时候将递归转化为非递归算法，更省时间和空间。其实原理很简单，即自己用栈来模拟递归的过程。每次从栈顶取出一部分做划分后，都把新的两部分的起始位置分别入栈。
//-------------快速排序(非递归)begin-----------------
template <class T>
void quickSortUnrecursive(T a[], int size)
{
int s = int(4 * log((double)size)/log(2.0));
int *stack = new int[s];
int top = 0;
T tmp;
int low, high, pivot, i, j;
//首先把整个数组入栈
stack[top++] = size - 1;
stack[top++] = 0;
while(top != 0)
{
//取出栈顶元素，进行划分
low = stack[--top];
high = stack[--top];
pivot = high;
//保证i之前的元素的不大于轴
i = low;
//j从前往后滑动
for (j = low; j < high; j++)
{
//如果碰到某个元素不大于轴，则与a[i]交换
if (a[j] <= a[pivot])
{
tmp = a[i];
a[i] = a[j];
a[j] = tmp;
i++;
}
}
//i为分界点，交换a[i]和轴
if (i != pivot)
{
tmp = a[i];
a[i] = a[pivot];
a[pivot] = tmp;
}
//判断小于轴的部分元素如果多于一个的话, 则入栈
if (i - low > 1)
{
stack[top++] = i - 1;
stack[top++] = low;
}
//判断大于轴的部分元素如果多于一个的话, 则入栈
if (high - i > 1)
{
stack[top++] = high;
stack[top++] = i + 1;
}
}
delete []stack;
}
//-------------快速排序(非递归)end-----------------
7、希尔排序
//-------------希尔排序begin-----------------
template <class T>
void shellSort(T a[], int low, int high)
{
int gap = high - low + 1;
T tmp;
do
{
//求下一增量
gap = gap / 3 + 1;
//各子序列交替处理
for (int i = low + gap; i <= high; i++)
{
//逆序，插入排序
if (a[i] < a[i - gap])
{
tmp = a[i];
int j = i - gap;
//找到插入位置
do
{
a[j + gap] = a[j];
j = j - gap;
} while (j > low && tmp < a[j]);
//插入元素
a[j + gap] = tmp;
}
}
} while (gap > 1);
}
//-------------希尔排序end-----------------
8、计数排序
//-------------计数排序begin-----------------
template <class T>
void countSort(T a[], int size, int k)
{
k++;
int *b = new int[size];
int *c = new int[k];
memset(c, 0, k * sizeof(int));
//c[i]包含等于a[i]的元素个数
for (int i = 0; i < size; i++)
{
c[a[i]]++;
}
//c[i]包含小于或等于i的元素个数
for (int i = 1; i < k; i++)
{
c[i] += c[i - 1];
}
//c[a[i]]即为a[i]的最终位置
for (int i = size - 1; i >= 0; i--)
{
b[c[a[i]] - 1] = a[i];
c[a[i]]--;
}
memcpy(a, b, size * sizeof(T));
delete []b;
delete []c;
}
//-------------计数排序end-----------------
9、基数排序
//-------------基数排序begin-----------------
int maxbit(int a[], int n)
{
int d = 1;
int radix = 10;
for (int i = 0; i < n; i++)
{
if (a[i] > radix)
{
radix *= 10;
d++;
}
}
return d;
}
void radixSort(int a[], int size)
{
int d = maxbit(a, size);
int *tmp = new int[size];
//计数器
int *count = new int[10];
int radix = 10;
int k = 0;
//进行d次排序
for (int i = 0; i < d; i++)
{
//每次分配前清空计数器
memset(count, 0, 10 * sizeof(int));
for (int j = 0; j < size; j++)
{
//统计每个桶中的记录数
k = (a[j] / radix) % 10;
count[k]++;
}
//将tmp中的位置依次分配给每个桶
for (int j = 1; j < 10; j++)
{
count[j] += count[j - 1];
}
//将所有桶中记录依次收集到tmp中
for (int j = size - 1; j >= 0; j--)
{
k = (a[j] / radix) % 10;
count[k]--;
tmp[count[k]] = a[j];
}
//将临时数组的内容复制到data中
memcpy(a, tmp, size * sizeof(int));
radix *= 10;
}
delete []tmp;
delete []count;
}
//-------------基数排序end-----------------
243
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
