基础篇——常见排序算法总结（一）冒泡算法
新人小白学习和总结一下常见的排序算法。
排序算法分类
按照排序过程中数据的保存形式的不同，可将排序分为内部排序和外部排序两大类。
如果排序过程不需要访问外存，就称之为内部排序（外存也就是计算机配备的存储容量更大的磁盘存储器和光盘存储器）。其实，所有排序过程都是在内存里面做的，但是外部排序需要做与外界的内外存交换，也就是说，内部排序消耗的是时间复杂度，外部排序消耗的是空间复杂度。当待排序的文件很大时，计算机内存不够大，所以需要进行内外存交换。
网上盗图如下:
排序算法的稳定性
排序的过程中，会碰到如下情况，比如当排序的俩个数值相等时，比如序列{2,5,8,2,3,2}，如果排序后这些元素2的相对位置不变，即对于一个已经排序好的序列{2,2,2,3,5,8}，排序算法还会不会改变上述元素的相对位置，如果不改变的话，那这个算法是稳定的，否则是不稳定的。
常见排序算法如下：
稳定的排序算法有：插入排序、冒泡排序、归并排序和基数排序。
快排、希尔、选择排序和堆排序是不稳定的算法。
1.冒泡算法（所学第一个排序算法）
#include<iostream>
int main()
{
int a[10] = { 2,12,5,6,1,2,25,11,254,12};
int swap = 0;
//冒泡从小到大排序
for (int i = 0; i < 9; i++)
for (int j = 0; j < 9 - i; j++)
{
if (a[j] > a[j + 1])
{
swap = a[j + 1];
a[j + 1] = a[j];
a[j] = swap;
}
}
for (int i = 0; i < 10; i++)
std::cout << a[i] << "\n";
//冒泡从大到小排序
for (int i = 0; i < 9; i++)
for (int j = 0; j < 9 - i; j++)
{
if (a[j] < a[j + 1])
swap = a[j];
a[j] = a[j + 1];
a[j + 1] = swap;
}
for (int i = 0; i < 10; i++)
std::cout << a[i] << "\n";
return 0;
}
光看是没用的，还得自己写，光是这个排序我还出了不少错误。。。。。。
时间复杂度O（n的平方）
最大时间复杂度1+2+3+…+（n-1）(判断一次（包括判断后的执行语句）算一次运算)
所以：最坏时间复杂度为O（n^2）
然而，根据资料显示，冒泡算法的最好时间复杂度为O(n)，但是正序情况下难道不是也要比较O（n^2）次么，按照上述的我写的冒泡算法确实不是O(n)，但是可以做一个小改进，就是如何在所有的排序顺序都对的时候，返回一个值，终止循环？
int main(){
int a[10] = { 2,12,5,6,1,2,25,11,254,12 };
int swap = 0;
bool choice=true;
//改进冒泡算法
for (int i = 0; i < 9; i++)
{ for (int j = 0; j < 9 - i; j++)
choice = true;
if (a[j] > a[j + 1])
{
swap = a[j + 1];
a[j + 1] = a[j];
a[j] = swap;
choice = false;
}
//如果经过一次冒泡过程，没发生交换
if (choice == true)
return 0;
}1.2定向冒泡算法
为了改进冒泡算法，提出了定向冒泡算法（鸡尾酒排序）
为什么叫鸡尾酒排序呢，因为这种改进算法是气泡从左到右，得到序列尾部的最大值后，又从右到左，可以得出头部的最小值。鸡尾酒是需要不断翻转的，这种比喻很生动。
int main(){
int a[10] = { 2,12,5,6,1,2,25,11,254,12 };
//如果是10个数 则最多4个来回确定4个最小的和4个最大的数 ，然后再进行一次比较
//如果按n分成奇数偶数感觉好麻烦 就做2*int（（n+1）/2）次循环比较
int swap = 0;
for (int j = 0; j < 10 - 1; j++)
{
if(j % 2 == 0 && j < (10 - 1)) //i为偶数 从左到右排序
for (int i = 0; i < 9 - j; i++)
{
if (a[i] > a[i + 1])
{
swap = a[i];
a[i] = a[i + 1];
a[i + 1] = swap;
}
}
if( j % 2 == 1 && j < 9) //i为奇数，从右往左排序
for (int i = 9 - j; i > 0; i--)
{
if (a[i] < a[i - 1])
{
swap = a[i];
a[i] = a[i - 1];
a[i - 1] = swap;
}
}
}
下面是加了标记后的鸡尾酒算法
int main()
{
int a[10] = { 2,12,5,6,1,2,25,11,254,12 }
//如果是10个数 则最多4个来回确定4个最小的和4个最大的数 ，然后再进行一次比较
//如果按n分成奇数偶数感觉好麻烦 就做2*int（（n+1）/2）次循环比较
bool choice = false;
int swap = 0;
for (int j = 0; j < 10 - 1; j++)
{
choice = true;
if(j % 2 == 0 && j < (10 - 1)) //i为偶数 从左到右排序
for (int i = 0; i < 9 - j; i++)
{
if (a[i] > a[i + 1])
{
swap = a[i];
a[i] = a[i + 1];
a[i + 1] = swap;
choice = false;
}
}
if( j % 2 == 1 && j < 9) //i为奇数，从右往左排序
for (int i = 9 - j; i > 0; i--)
{
if (a[i] < a[i - 1])
{
swap = a[i];
a[i] = a[i - 1];
a[i - 1] = swap;
choice = false;
}
}
if (choice == true)
return 0;
}
for (int i = 0; i < 10; i++)
std::cout << a[i] << "\n";
return 0;
}
定向冒泡排序，能稍稍增加排序算法的性能，但总的来说效率不高。
本人水平比较差，欢迎批评指正~
