（1）基本思想：
每一趟从待排序的数据元素中选出最小（或最大）的一个元素
顺序放在待排序的数列的最前
直到全部待排序的数据元素排完。
（2）排序过程：
【示例】：
初 始 关键字 [49 38 65 97 76 13 27 49]
第一趟排序后 13［38 65 97 76 49 27 49］
第二趟排序后 13 27［65 97 76 49 38 49］
第三趟排序后 13 27 38 [97 76 49 65 49]
第四趟排序后 13 27 38 49 [76 97 65 49]
第五趟排序后 13 27 38 49 49 [97 65 76]
第六趟排序后 13 27 38 49 49 65 [97 76]
第七趟排序后 13 27 38 49 49 65 76 [97]
最后排序结果 13 27 38 49 49 65 76 97
//选择排序
#include<cstdio>
using namespace std;
const int maxn = 100005;
int a[maxn],n,cnt;
int main()
{
scanf("%d",&n);
for(int i = 1;i <= n;i++)
scanf("%d",&a[i]);
for(int i = 1;i <= n;i++)
{
cnt = i;
for(int j = i + 1;j <= n;j++)
if(a[j] < a[cnt])
cnt = j;
if(cnt != i)
{
int tmp = a[i];
a[i] = a[cnt];
a[cnt] = tmp;
}
}
for(int i = 1;i <= n;i++)
printf("%d ",a[i]);
return 0;
}
二、冒泡排序
（1）基本思想：
以n个人站队为例
从第1个开始，依次比较相邻的两个是否逆序对(高在前，矮在后)
若逆序就交换这两人，即第1个和第2个比，若逆序就交换两人，接着第2个和第3个比，若逆序就交换两人，接着第3个和第4个比，若逆序就交换两人，……
直到n-1和n比较，经过一轮比较后，则把最高的人排到最后，即将最高的人像冒泡一样逐步冒到相应的位置。
原n个人的排序问题，转换为n-1个人的排序问题。
第二轮从第1个开始，依次比较相邻的两个人是否逆序对，若逆序就交换两人，直到n-2和n-1比较。
如此，进行n-1轮后，队列为有序的队列。
（2）排序过程
例如有6个元素需要排序：
6 5 3 4 1 2
1.第一趟排序
2.第二趟排序
3.第三趟排序
4.第四趟排序
5.第五趟排序
#include<cstdio> #include<algorithm> using namespace std; const int maxn = 100005; int n,a[maxn]; int main() { scanf("%d",&n); for(int i = 0;i < n;i++) scanf("%d",&a[i]); for(int i = n-1;i >= 1;i--) { for(int j = 0;j < i;j++) { if(a[j] > a[j + 1]) swap(a[j],a[j + 1]); } } for(int i = 0;i < n;i++) printf("%d ",a[i]); return 0; }
冒泡的优化
对于有些数据，我们发现，不一定要n-1次才能排完。
例如1 5 2 3 4 6，我们发现只需一趟排序就可以将整个序列排完
于是，我们可以设置一个布尔变量，判断是否有进行交换，如果没有交换，说明已经排序完成，进而减少几趟排序。
#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn = 100005;
int n,a[maxn];
bool opt;
int main()
{
scanf("%d",&n);
for(int i = 0;i < n;i++)
scanf("%d",&a[i]);
for(int i = n - 1;i >= 1;i--)
{
opt = true;
for(int j = 0;j < i;j++)
{
if(a[j] >= a[j + 1])
{
swap(a[j],a[j + 1]);
opt = false;
}
}
if(opt == true)
break;
}
for(int i = 0;i < n;i++)
printf("%d ",a[i]);
return 0;
}
三、插入排序
（1）基本思想：
回忆一下打牌时抓牌的情景，为了方便打牌，抓牌时一般一边抓牌一边按花色和大小插入恰当的位置，当抓完所有的牌时，手中的牌便是有序的，这排序方法即插入排序。
当读入一个元素时，在已经排序好的序列中，搜寻它正确的位置，再放入读入的元素。
但不该忽略一个重要的问题：在插入这个元素前，应当先将将它后面的所有元素后移一位，以保证插入位置的原元素不被覆盖。
（2）排序过程：
例如:设n=8，数组a中8个元素是: 36,25,48,12,65,43,20,58，执行插入排序程序后，其数据变动情况：
第0步:[36] 25 48 12 65 43 20 58
第1步:[25 36] 48 12 65 43 20 58
第2步:[25 36 48] 12 65 43 20 58
第3步:[12 25 36 48] 65 43 20 58
第4步:[12 25 36 48 65] 43 20 58
第5步:[12 25 36 43 48 65] 20 58
第6步:[12 20 25 36 43 48 65] 58
第7步:[12 20 25 36 43 48 58 65]
#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn = 10005;
int n,a[maxn];
int main()
{
int i,j,k;
scanf("%d",&n);
for(i = 0; i < n; i++)
scanf("%d",&a[i]);
for(i = 0; i < n; i++)
{
for(j = i - 1; j >= 0; j--)
if(a[j] < a[i])
break;
if(j != i - 1)
{
int tmp = a[i];
for(k = i - 1;k > j;k--)
a[k + 1] = a[k];
a[k + 1] = tmp;
}
}
for(int i = 0;i < n;i++)
printf("%d ",a[i]);
return 0;
}
四、桶排序
（1）基本思想：
桶排序的思想是若待排序的值在一个明显有限范围内(整型)时，可设计有限个有序桶，待排序的值装入对应的桶（当然也可以装入若干个值），桶号就是待排序的值，顺序输出各桶的值，将得到有序的序列。
#include<cstdio>
#include<algorithm>
using namespace std;
int b[101],n,k;
int main()
{
scanf("%d",&n);
for(int i = 1;i <= n;i++)
{
scanf("%d",&k);
b[k]++;
}
for(int i = 0;i <= 100;i++)
while(b[i])
{
printf("%d ",i);
b[i]--;
}
return 0;
}
五、快速排序
（1）基本思想：
通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
（2）排序过程：
假设待排序的序列为{a[L],a[L+1],a[L+2],……,a[R]}，首先任意选取一个记录（通常可选中间一个记作为枢轴或支点），然后重新排列其余记录，将所有关键字小于它的记录都放在左子序列中，所有关键字大于它的记录都放在右子序列中。由此可以将该“支点”记录所在的位置mid作分界线，将序列分割成两个子序列和。这个过程称作一趟快速排序（或一次划分）。
一趟快速排序的具体做法是：附设两个指针i和j，它们的初值分别为L和R，设枢轴记录取mid，则首先从j所指位置起向前搜索找到第一个关键字小于的mid的记录，然后从i所指位置起向后搜索，找到第一个关键字大于mid的记录，将它们互相交换，重复这两步直至i>j为止。
快速排序的时间的复杂性是O(nlog2n)，速度快,但它是不稳定的排序方法。就平均时间而言，快速排序是目前被认为是最好的一种内部排序方法
由以上讨论可知，从时间上看，快速排序的平均性能优于前面讨论过的各种排序方法，但快速排序需一个栈空间来实现递归。若每一趟排序都将记录序列均匀地分割成长度相接近的两个子序列，则栈的最大深度为log(n+1)。
void qsort(int l,int r)
{
int i,j,mid,p;
i = l;
j = r;
mmid = a[(l + r)/2];
do
{
while(a[i] < mid)
i++;
while(a[j] > mid)
j--;
if(i <= j)
{
swap(a[i],a[j]);
i++;
j--;
}
}
while(i <= j);
if(l < j)
qsort(l,j);
if(i < r)
qsort(i,r);
}
六、归并排序
（1）基本思想：
归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。
将已有序的子序列合并，得到完全有序的序列；
即先使每个子序列有序，再使子序列段间有序。
若将两个有序表合并成一个有序表，称为二路归并。
（2）排序过程：
例如有8个数据需要排序：10 4 6 3 8 2 5 7
归并排序主要分两大步：分解、合并。
合并过程为：比较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<cstdio>
#define ll long long
using namespace std;
const int maxn=5e5+5;
int a[maxn],r[maxn],n;
ll ans=0;
void msort(int s,int t)
{
if(s==t)
return;
int mid=s+t>>1;
msort(s,mid),msort(mid+1,t);
int i=s,j=mid+1,k=s;
while(i<=mid&&j<=t)
if(a[i]<=a[j])
r[k++]=a[i++];
else
r[k++]=a[j++],ans+=(ll)mid-i+1;
while(i<=mid)
r[k]=a[i],k++,i++;
while(j<=t)
r[k]=a[j],k++,j++;
for(int i=s;i<=t;i++)
a[i]=r[i];
}
inline int read()
{
char ch=getchar();
int sum=0,k=1;
while(ch<'0'||ch>'9')
{
if(ch=='-')
k=-1;
ch=getchar();
}
while(ch>='0'&&ch<='9')
sum=sum*10+(ch^48),ch=getchar();
return sum*k;
}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
a[i]=read();
msort(1,n);
printf("%lld
",ans);
return 0;
}
各种排序算法的比较
1.稳定性比较
插入排序、冒泡排序、二叉树排序、二路归并排序及其他线形排序是稳定的。
选择排序、希尔排序、快速排序、堆排序是不稳定的。
2.时间复杂性比较
插入排序、冒泡排序、选择排序的时间复杂性为O(n2)；
快速排序、堆排序、归并排序的时间复杂性为O(nlog2n)；桶排序的时间复杂性为O(n);
若从最好情况考虑，则直接插入排序和冒泡排序的时间复杂度最好，为O(n)
其它算法的最好情况同平均情况相同；
若从最坏情况考虑，则快速排序的时间复杂度为O(n2)，直接插入排序和冒泡排序虽然平均情况相，
但系数大约增加一倍，所以运行速度将降低一半，最坏情况对直接选择排序、堆排序和归并排序影响不大。
由此可知，在最好情况下，直接插入排序和冒泡排序最快；在平均情况下，快速排序最快；在最坏情况下，堆排序和归并排序最快。
3.辅助空间的比较
桶排序、二路归并排序的辅助空间为O(n)
快速排序的辅助空间为O(log2n)，最坏情况为O(n)
其它排序的辅助空间为O(1);
4.其它比较
插入、冒泡排序的速度较慢，但参加排序的序列局部或整体有序时，这种排序能达到较快的速度。反而在这种情况下，快速排序反而慢了。
当n较小时，对稳定性不作要求时宜用选择排序，对稳定性有要求时宜用插入或冒泡排序。
若待排序的记录的关键字在一个明显有限范围内时,且空间允许是用桶排序。
当n较大时，关键字元素比较随机，对稳定性没要求宜用快速排序。
当n较大时，关键字元素可能出现本身是有序的，对稳定性没有要求时宜用堆排序
快速排序是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；
堆排序所需的辅助空间少于快速排序，并且不会出现快速排序可能出现的最坏情况。这两种排序都是不稳定的。