排序算法
写一写，顺便复习了~其实这是之前写好的，今天搬回来。。
一直都听说的是八大排序算法，简单选择排序，快速排序，希尔排序，堆排序，冒泡排序，直接插入排序，归并排序和基数排序，其中前四种为不稳定排序（即相等的两个数排序后的前后位置改变），后四种为稳定排序（即相等的两个数排序后的前后位置不改变）。无奈本人还很水，暂时也只涉及到除了堆排序和基数排序的其他六种排序，所以也就只总结这六个暂时我比较常用的排序算法（其实想总结也很长时间了，奈何拖延症正盛）。
1、冒泡排序（Bubble Sort）。
就从这个最先接触的也是最简单的排序算法开始好了。
冒泡排序，也叫“起泡排序”，顾名思义，小的气泡轻，一个一个的冒上来，放在第一个。
如图，每次和相邻的数值进行比较，假设数组a[i]>a[i+1]，我们就交换a[i]和a[i+1],然后继续往后执行。
代码实现:
#include <iostream>
#include <cstdio>
using namespace std;
int a[1000];
void BubbleSort(int num)
{
for(int i=0; i<num-1; i++)
{
for(int j=0; j<num-i-1; j++)
{
if(a[j] > a[j+1])
{
int temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
}
void Print(int num)
{
for(int i=0; i<num; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
int main()
{
int n;
scanf("%d", &n);
for(int i=0; i<n; i++)
{
scanf("%d", &a[i]);
}
BubbleSort(n);
Print(n);
return 0;
}普通冒泡的时间复杂度是O(n^2)，但是还看见了一种优化了的冒泡，时间复杂度可以变成O(n)，暂时先不管这个了。。
2、快速排序（Quick Sort）
快速排序，简称快排，和冒泡排序同属于交换排序。快排的平均时间复杂度为O(nlogn)，是很快的排序算法，也很常用，但是是不稳定的。
基本的算法思想如图，即设置一个标记pivotkey = a[i] (也就是最开始的位置空出来)，并从两头开始进行比较，如果a[i] > a[j] 我们就把a[j] 放在a[i]的位置上，空出a[j]的位置，让 j 向前移动一位，继续比较。两边比较交换方式都相同，最后 i==j 时放入pivotkey的值，结束排序。
代码如下：
#include <iostream>
#include <cstdio>
using namespace std;
int a[1000];
void Swap(int *b, int *c)
{
int temp = *b;
*b = *c;
*c = temp;
}
void Print(int num)
{
for(int i=0; i<num; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
int Partition(int low, int high)
{
int privotkey = a[low];
while(low < high)
{
while(low < high && a[high] >= privotkey)
high--;
Swap(&a[low], &a[high]);
while(low < high && a[low] <= privotkey)
low++;
Swap(&a[low], &a[high]);
}
return low;
}
void QuickSort(int low, int high)
{
if(low < high)
{
int number = Partition(low, high);
QuickSort(low, number-1);
QuickSort(number+1, high);
}
}
int main()
{
int n;
scanf("%d", &n);
for(int i=0; i<n; i++)
{
scanf("%d", &a[i]);
}
QuickSort(0, n-1);
Print(n);
return 0;
}3、简单选择排序（Select Sort）
简单选择排序，就是在数组中找出最小的和第一个数交换，次小的和第二个数交换（从小到大排序）或者在数组中找出最大的与第一个交换，次大的和第二个数交换（从大到小排序）。
代码如下：
#include <iostream>
#include <cstdio>
using namespace std;
int a[1000];
void Swap(int *b, int *c)
{
int temp = *b;
*b = *c;
*c = temp;
}
void Print(int num)
{
for(int i=0; i<num; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
int FindMin(int i, int n)
{
int k = i;
for(int j=k; j<n; j++)
{
if(a[k] > a[j])
k = j;
}
return k;
}
void SelectSort(int n)
{
int key;
for(int i=0; i<n; i++)
{
key = FindMin(i, n);
if(key != i)
{
int temp = a[i];
a[i] = a[key];
a[key] = temp;
}
}
}
int main()
{
int n;
scanf("%d", &n);
for(int i=0; i<n; i++)
{
scanf("%d", &a[i]);
}
SelectSort(n);
Print(n);
return 0;
}
4、直接插入排序（straight insertion sort）
直接插入排序是把有序表内的元素，把它插入到有序表中，使有序表仍然有序。
ORZ，没有找到图片。。。
下标 0 1 2 3 4 5 6 7
数组值 （49） 38 65 97 76 13 27 49
i=1 （38 49） 65 97 76 13 27 49
i=2 （38 49 65） 97 76 13 27 49
i=3 （38 49 65 97） 76 13 27 49
i=4 （38 49 65 76 97） 13 27 49
i=5 （13 38 49 65 76 97） 27 49
i=6 （13 27 38 49 65 76 97） 49
i=7 （13 27 38 49 49 65 76 97）
终于码完了简易流程图，也是醉了。从数组的第二个数字开始比较，插入有序表内~
代码实现：
#include <iostream>
#include <cstdio>
using namespace std;
int a[1000];
void Print(int num)
{
for(int i=0; i<num; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
void InsertSort(int n)
{
for(int i=1; i<n; i++) //从数组的第二个数字开始
{
if(a[i] < a[i-1]) //和该数的前一个元素进行比较
{
int j = i-1; //j为有序表中的最后一个元素的下标
int x = a[i]; //x为要放到有序表中的数字
a[i] = a[i-1];
while(x < a[j]) //如果有序表中的数字都比x小，就把有序表的数字依次往后移动一个
{
a[j+1] = a[j];
j--;
}
a[j+1] = x; //当x>=a[j]时，while循环结束，x最后放在数组下标为j+1处
}
}
}
int main()
{
int n;
scanf("%d", &n);
for(int i=0; i<n; i++)
{
scanf("%d", &a[i]);
}
InsertSort(n);
Print(n);
return 0;
}5、希尔排序（Shell Sort）
希尔排序和直接插入排序一样同属于插入排序，也称缩小增量排序。希尔排序是把记录按下标的一定增量分组，对每一组分别使用直接插入排序，然后缩小增量，再次排序，直至增量为1，算法终止，排序结束。
一般取数字个数的一半为初次增量，之后一次减少一半，直至到1。
代码实现：
#include <iostream>
#include <cstdio>
using namespace std;
int a[1000];
void Print(int num)
{
for(int i=0; i<num; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
void ShellInsertSort(int n, int m)
{
for(int i=m; i<n; i++)
{
if(a[i] < a[i-m])
{
int j = i-m;
int x = a[i];
a[i] = a[i-m];
while(x < a[j])
{
a[j+m] = a[j];
j -= m;
}
a[j+m] = x;
}
}
}
void ShellSort(int n)
{
int m = n/2; //m为增量
while(m >= 1)
{
ShellInsertSort(n, m);
m = m/2;
}
}
int main()
{
int n;
scanf("%d", &n);
for(int i=0; i<n; i++)
{
scanf("%d", &a[i]);
}
ShellSort(n);
Print(n);
return 0;
}6、归并排序
归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即
先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
归并过程为：比较a[i]和a[j]的大小，若a[i]≤a[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1；否则将第二个有序表中的元素a[j]复制到r[k]中，并令j和
k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。归并排序的算法我们通常用递归实现，先把待排序
区间[s,t]以中点二分，接着把左边子区间排序，再把右边子区间排序，最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。（这么专业，来自百度）
代码实现：
#include <iostream>
#include <cstdio>
using namespace std;
int x[1000];
int y[1000];
void Merge(int low, int mid, int high)
{
int i, j, k;
int t;
i = low;
j = mid+1;
for(k=low; i<=mid&&j<=high; k++)
{
if(x[i] <= x[j])
y[k] = x[i++];
else
y[k] = x[j++];
}
while(i <= mid)
{
y[k++] = x[i++];
}
while(j <= high)
{
y[k++] = x[j++];
}
for (t=low; t<=high; t++)
{
x[t] = y[t];
}
}
void MSort(int low, int high) /* 定义归并排序函数，递归方式 */
{
int mid;
if(low < high)
{
mid = (low+high)/2;
MSort(low, mid); /* 递归调用，将子序列x[low~mid]归并为有序序列 */
MSort(mid+1, high); /* 递归调用，将子序列x[mid+1~high]归并为有序序列 */
Merge(low,mid,high); /* 将子序列x[low~mid]和x[mid+1~high]进行归并 */
}
}
void Print(int n)
{
for(int i=1; i<=n; i++)
printf("%d ", x[i]);
printf("\n");
}
int main()
{
int n;
scanf("%d", &n);
for(int i=1; i<=n; i++)
{
scanf("%d", &x[i]);
}
MSort(1, n);
Print(n);
return 0;
}写到这里，我目前所用到的排序就都写完了，至于堆排序和基数排序以后用到再说吧。
然后补充一下在C++中的排序函数，sort() 以及 qsort() 还有 stable_sort()。
1.sort()函数
sort() 函数包含于头文件 algorithm 中，一般情况下采用快速排序，有时会有插入排序，堆排序等等。可以借鉴这个博客，有关sort()函数内部的分析
（链接在此http://blog.sina.cn/dpool/blog/s/blog_9d987af501014zlj.html）
sort()函数的内部包含两个或者三个参数（一般为两个），即开始位置和排序的结束位置（即开始位置加上待排序元素个数），想要降序排序时，可以自定义cmp函数，并把 函数放进 sort() 的第三个参数即可。
代码实现：
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
int a[1000];
bool cmp_down(const int x, const int y)
{
return x > y;
}
void Print(int n)
{
for(int i=0; i<n; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
int main()
{
int n;
scanf("%d", &n);
for(int i=0; i<n; i++)
{
scanf("%d", &a[i]);
}
sort(a, a+n); //升序
Print(n);
sort(a, a+n, cmp_down); //降序
Print(n);
return 0;
}2.qsort()函数
qsort() 函数包含于头文件 stdlib.h中，快排。函数包含四个参数：带排序数组首地址，数组中待排序元素数量，各元素的占用空间大小，指向函数的指针（即用于确定 排序的顺序）
代码实现：
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
using namespace std;
int a[1000];
int cmp(const void *a, const void *b)
{
return *(int *)a - *(int *)b;
}
void Print(int n)
{
for(int i=0; i<n; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
int main()
{
int n;
scanf("%d", &n);
for(int i=0; i<n; i++)
{
scanf("%d", &a[i]);
}
qsort(a, n, sizeof(int), cmp);
Print(n);
return 0;
}3.stable_sort()函数
实现方法基本和sort()函数相同，只是碰到相同的数字不进行交换。
好啦~就酱紫了，如果有什么问题，欢迎指正~
搬家完成~哈哈
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
