1. 直接选择排序
任何情况下的时间复杂度都是 O(n^2)， 最差的一种排序，每次都必须遍历玩整个子数组，选出最小的那个，空间复杂度为O（1），无需额外空间。直接选择排序的关键在于，每次从右侧子数组中，选出最小的，放到子数组第一个，然后缩小子数组范围，再次选择、交换。
#include <iostream>
using namespace std;
void selectionSort(int* a, int begin, int end)
{
if (begin >= end) return;
int min = a[begin];
for (int i = begin; i < end; i++)
{
if (a[i] < min)
{
// 不使用第三个数交换两个整型。
a[i] = a[i] ^ a[begin];
a[begin] = a[i] ^ a[begin];
a[i] = a[i] ^ a[begin];
min = a[begin];
}
}
selectionSort(a, ++begin, end);
}
int main()
{
int n[7] = { 10, 10, 20, 1, 3, 8, 22 };
selectionSort(n, 0, 7);
}2. 直接插入排序
直接插入排序的平均复杂度为O（n^2），在最好的情况下，即基本有序时，复杂度为O（n）.直接插入排序的关键在于，与直接选择相反，直接插入的操作序列是左侧的已排好序列，每次把右侧第一个值拿出来插到左侧已排好序列中。
int* insertionSort(int* A, int n) {
for(int i = 1; i < n; i++)
for(int j = i; j > 0; j--)
if(A[j] < A[j - 1]) swap(A[j], A[j - 1]);
return A;
}3. 希尔排序
希尔排序是直接插入排序的改良版，gap不再是1，而是动态变化，从n/2开始，每次除以2，直到1。利用了插入排序在基本有序的前提下效率最高的特点。
void shell_sort(int a[], int n)
{
for (int gap = n / 2; gap > 0; gap /= 2) // gap 从 n / 2 .. 1
{
// 下面是插入排序
for (int i = gap; i < n; i++) // 遍历一遍
{// 步长不再是直接插入时的1，而是gap
// 前gap个([0] .. [gap - 1])是不需要检测的，因为是每组的第一个,所以i从gap开始
for (int j = i; j >= gap; j -= gap) // 注意这里 j-=gap
{
if (a[j] < a[j - gap]) swap(a[j - gap], a[j]);
else break;
}
}
}
}4. 直接交换（冒泡排序）
冒泡排序的平均时间复杂度为O(n^2)，在最好情况下，即基本有序时，复杂度为O（n）。冒泡排序的关键是，每次冒泡上来一个当前子序列中的最大值（升序排列的话）。冒泡排序可以优化，比如下面，用exchange标记，如果某次冒泡没有交换，说明当时的子序列已经有序。
#include <iostream>
using namespace std;
void exchangeSort(int* n, int s)
{
// 优化冒泡排序
bool isexchange = false;
for (int i = 0; i < s; i++)
{
isexchange = false;
for(int j = 0; j < s - i - 1; j++)
{
if (n[j + 1] < n[j])
{
isexchange = true;
n[j + 1] ^= n[j];
n[j] ^= n[j + 1];
n[j + 1] ^= n[j];
}
}
if (isexchange == false) return;
}
}
int main()
{
int n[7] = { 10, 10, 20, 1, 3, 8, 22 };
exchangeSort(n, sizeof(n)/ sizeof(int));
}5.快速排序（加强版交换排序）
关键字：pivot 轴,partition() (划分)
快排有两种实现，分别应用于数组和单向链表，快排的关键是partition函数的实现
http://www.cnblogs.com/TenosDoIt/p/3665038.html
1. 定轴实现
对数组进行快排时使用这个方法。
快排采用了
分治策略，平均时间复杂度为O（nlogn）。快排的关键在于选择基准，把子序列从左右两端，（如果是升序的话）左边找比基准大的，右边找比基准小的，交换两者，直到左右指针相遇。一个while嵌套两个查找while。快排在最坏情况下（逆序），复杂度为O（n^2）
partition 函数：
// 划分函数，返回pivot的最终位置
int partition(int a[], int begin, int end)
{
// 选第一个作pivot即可
int pivot = a[begin];
int l = begin, r = end;
while (l < r)
{
// 从右往左找小的
while (l < r && a[r] >= pivot) --r;
a[l] = a[r];// 找到后把它放到低位，a[l]上肯定要么是a[begin]要么是大于pivot的，所以可以覆盖（提示：考虑下面这个循环退出的条件）
while (l < r && a[l] <= pivot) ++l;
a[r] = a[l];// 找到后把它放到高位，a[r]上肯定是小于pivot的，可以覆盖
}
// 此时 l 应该等于 r，这个是一个空位，可以覆盖，把pivot放到这里，左边的小于pivot，右边的大于pivot
a[l] = pivot;
return l;
}
快排的另一种实现是挖坑实现
2. 挖坑法
对链表进行快排时使用这个方法
// 划分函数，返回pivot的最终位置
int partition(int a[], int begin, int end)
{
int pivot = a[begin]; //选第一个作pivot
int low = begin; // 比pivot小的最后一个元素的下标
for (int i = begin + 1; i <= end; i++) // 比pivot小的放在左边
if (a[i] < pivot)
swap(a[i], a[++low]);//将此数与比pivot小的最后一个元素的下一个（比pivot大）交换
swap(a[begin], a[low]); // 将最后一个比pivot小的元素交换到头部
return low;
}void quicksort(int a[], int begin, int end)
{
if (begin < end)
{
int pivot = partition(a, begin, end); // 使得总体有序，找到pivot的最终位置，
quicksort(a, begin, pivot - 1); // 使得左侧有序
quicksort(a, pivot + 1, end); // 使得右侧有序
}
}6. 归并排序
关键字：merge,() mergesort()
归并排序有两个函数，一个是用来合并两个已经排好的数组，并放到临时数组里，比较容易
// 将 begin .. end 排好序后放回a数组的 begin .. end 原位置
// a[]的begin .. mid 与 mid + 1 .. end 子数组分别是两个已经排好序的数组
// 需要借用一个辅助存储空间 temp, 这也是归并排序空间复杂度为O(n)的原因所在
void merge(int a[], int begin, int mid, int end, int temp[])
{
int l = begin, r = mid + 1;
int k = 0;
while (l <= mid && r <= end) // 当两个子数组都没用完时
temp[k++] = (a[l] < a[r] ? a[l++] : a[r++]);
while (l <= mid) // 当第一个没有用完时，用完它
temp[k++] = a[l++];
while (r <= end) // 当第二个没有用完时，用完它
temp[k++] = a[r++];
// 将temp中的内容拷贝回 a[]的begin, end位置
for (int i = begin; i <= end; i++)
a[i] = temp[i - begin];
}// 主调函数
void mergesort(int a[], int begin, int end, int temp[])
{
if (begin < end)
{
int mid = (begin + end) >> 1; // 取中点
mergesort(a, begin, mid, temp); // 另左边有序,临时数组temp可以多次使用
mergesort(a, mid + 1, end, temp); // 另右边有序
merge(a, begin, mid, end, temp); // 合并左右两个有序子数组
}
}快排与归并排序的对比
1. 快排和归并排序都应用了分治的思想。快排是交换排序的一种。
2. 快排最坏复杂度为 O(n^2), 与pivot选取有关，会退化为冒泡排序，归并排序最坏也是O（n^2）
3. 归并排序需要另外的O(n)存储空间；快排不需要，直接对原数组操作。
4. 快排每次保证整体有序，即pivot左侧一定都小于pivot，pivot右侧一定都大于pivot，然后分别处理左侧和右侧，使之整体有序，直到只剩一个元素；
归并排序每次保证局部有序，划分到最底部，然后从低开始向上merge合并，从而使整体有序。
5. 归并排序稳定，快排不稳定。
7. 堆排序
堆排序是一种选择排序，关键是下调算法。堆排序的第一步是将近似堆(原数组)转化为最大堆（从最后一个非叶节点开始调用下调算法），然后每次删除根（将根与最后一个节点交换），再使用下调，调整为新的堆，再删除根。。。直到子堆大小为1。
// 下调算法
// begin 代表了子堆根，从此开始下调
// end 代表了子堆最后一个节点
void heap_adjust(int a[], int begin, int end)
{
for (int i = begin * 2 + 1; i <= end; i = i * 2 + 1)
{
int next = i + 1;
if (next <= end && a[next] > a[i]) i++; // 如果自己的兄弟比自己大，则应该让兄弟和爸爸交换
if (a[begin] > a[i]) break; // 已经满足了堆次序性
swap(a[begin], a[i]);
begin = i; // 以此节点为根继续下调
}
}
// 先得把无序数组建立为一个大根堆(升序的话)
// 使用下调建堆(从最后一个非叶节点开始，重复利用下调），这样就可以
// 把建堆和调堆两个过程用一个函数 heap_adjust 进行
void heap_sort(int a[], int n)
{
// 先用建堆算法，建立最大堆，从最后一个非叶节点开始调用下调算法
for (int i = n - 1; i >= 0; i--)
heap_adjust(a, i, n - 1);
// 每次把堆根和最后一个元素交换，然后再用下调算法调堆
for (int i = 0; i < n; i++)
{
swap(a[n - i - 1], a[0]);
heap_adjust(a, 0, n - i - 2);
}
}8. 桶排序
桶排序非常快，但是空间消耗大。
8.1 计数排序 counting sort
基本思路是用一个数组记录每个值出现的次数，数组的下标才是值，数组的值是次数，输出的时候从0开始到max，有几个输出几个。
#include <iostream>
#include <algorithm>
using namespace std;
void countingsort(int a[], int n)
{
if (n == 0) return;
// 1. 先找最大值
int max = a[0];
for (int i = 0; i < n; i++)
max = (max < a[i] ? a[i]: max);
// 2. 做桶
int * bucket = new int[max + 1];
memset(bucket, 0, sizeof(int)*(max + 1));
for (int i = 0; i < n; i++)
bucket[a[i]] ++;
int k = 0;
for (int i = 0; i < max + 1; i++)
{
int n = bucket[i];
while (n-- > 0)
a[k++] = i;
}
delete[] bucket;
}
int main()
{
int a[] = { 1,7,3,5,2,4,6 };
const int len = sizeof(a) / sizeof(int);
countingsort(a, len);
for (int i = 0; i < len; i++)
cout << a[i] << endl;
}8.2 基数排序是从各位开始装桶。
7645
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
