三大简单排序

冒泡排序：
(一)概念及实现
冒泡排序的原理：重复的遍历要排序的数组，每次遍历过程中从头至尾比较两个相邻的元素，若顺序错误则交换两个元素。

具体如下（实现为升序）：
设数组为a[0…n]。
1. 从头至尾比较相邻的元素。如果第一个元素比第二个元素大，就交换。
2. 重复步骤1，每次遍历都将冒出一个最大数，直到排序完成。

实现代码：

void BallocSort(int a[],int n){

    int i,j,tmp;
    int flag = 1;

    for(i = 0;i<n-1;i++){
        flag = 0;
        for(j = 0;j<n-i;j++){
            if(a[j+1]<a[j]){
                tmp = a[j+1];
                a[j+1] = a[j];
                a[j] = tmp; 
                flag = 1;
            }
        } 
        if(flag == 0)
            break;
    }

}

(二)算法复杂度
1. 时间复杂度：O(n^2)
冒泡排序耗时的操作有：比较 + 交换（每次交换两次赋值）。时间复杂度如下：
1) 最好情况：序列是升序排列，在这种情况下，需要进行的比较操作为（n-1）次。交换操作为0次。即O(n)
2) 最坏情况：序列是降序排列，那么此时需要进行的比较共有n(n-1)/2次。交换操作数和比较操作数一样。即O(n^2)
3) 渐进时间复杂度（平均时间复杂度）：O(n^2)
2. 空间复杂度：O(1)
从实现原理可知，冒泡排序是在原输入数组上进行比较交换的（称“就地排序”），所需开辟的辅助空间跟输入数组规模无关，所以空间复杂度为：O(1)

(三)稳定性
冒泡排序是稳定的，不会改变相同元素的相对顺序。

(四)优化改进
1. 有序优化：在进行相邻元素比较时，可以记录下循环中没有发生交换的多个连续索引对（起始索引和结束索引），在下次轮询时直接对有序区间的最大值进行比较。
2. 双向冒泡：参考资料过程中看到了双向冒泡，不同之处在于“从左至右与从右至左两种冒泡方式交替执行”，个人认为不能提高算法效率并且增加代码复杂度。
选择排序：
（一）概念及实现
选择排序的原理：每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

具体如下（实现为升序）：
设数组为a[0…n]。
1. 初始状态：无序区为R[1..n]，有序区为空。
2. 第1趟排序。在无序区R[1..n]中选出关键字最小的记录R[k]，将它与无序区的第1个记录R[1]交换，使R[1..1]和R[2..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。
3. 第i趟排序。第i趟排序开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

实现代码：

void SelectSort(int a[],int n){
    int i,j,base,flag;
    for(i = 0;i<n-1;i++){
        base = a[i];
        flag = i;
        for(j = i+1;j<n;j++){
            if(base>a[j]){
                base = a[j];
                flag = j;
            }
        }
        if(flag!=i){
            a[flag] = a[i];
            a[i] = base;
        }
    }

}

(二)算法复杂度
1. 时间复杂度：O(n^2)
选择排序耗时的操作有：比较 + 交换 。时间复杂度如下：
1) 最好情况：序列是升序排列，在这种情况下，需要进行的比较操作为（n-1）次。交换操作为0次。即O(n)
2) 最坏情况：序列是降序排列，那么此时需要进行的比较共有n(n-1)/2次。交换操作数n/2次。即O(n^2)
3) 渐进时间复杂度（平均时间复杂度）：O(n^2)
2. 空间复杂度：O(1)
从实现原理可知，选择排序是在原输入数组上进行比较交换的（称“就地排序”），所需开辟的辅助空间跟输入数组规模无关，所以空间复杂度为：O(1)

(三)稳定性
选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元素选择第二小的，依次类推，直到第n-1个元素，第n个元素不用选择了，因为只剩下它一个最大的元素了。那么，在一趟选择，如果一个元素比当前元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了。比较拗口，举个例子，序列5 8 5 2 9，我们知道第一遍选择第1个元素5会和2交换，那么原序列中两个5的相对前后顺序就被破坏了，所以选择排序是一个不稳定的排序算法。

(四)优化改进
由于选择排序在第i趟都要进行(n-i)次比较，但其实这些比较在其后每趟中都会再进行重复的比较。所以最好的就是将比较的结果保存下来，这样就不用做很多重复无用的比较操作了。我们的解决方案就是用树结构来记录比较的结果。好了，就不卖关子了，其实就是堆排序。大家有兴趣的可以下去看看，这也是很重要的排序，必须得掌握的。
插入排序：
（一）概念及实现
选择排序的原理：把待排序的纪录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的纪录插入完为止，得到一个新的有序序列。

具体如下（实现为升序）：
设数组为a[0…n]。
1. 设置监视哨r[0]，将待插入纪录的值赋值给r[0]；
2. 设置开始查找的位置j；
3. 在数组中进行搜索，搜索中将第j个纪录后移，直至r[0].key≥r[j].key为止；
4. 将r[0]插入r[j+1]的位置上。

实现代码：

void InsertSort(int a[],int n){
    int i,j,base;
    for(i = 1;i<n;i++){
        base = a[i];
        for(j = i-1;j>=0;j--){
            if(base<a[j])
                a[j+1] = a[j];
            else
                break;
        }
        a[j+1] = base;
    }
}

(二)算法复杂度
1. 时间复杂度：O(n^2)
选择排序耗时的操作有：比较 + 交换 。时间复杂度如下：
1) 最好情况：序列已经是升序排列了，在这种情况下，需要进行的比较操作需（n-1）次即可。即O(n)
2) 最坏情况：序列是降序排列，那么此时需要进行的比较共有n(n-1)/2次。插入排序的赋值操作是比较操作的次数加上 (n-1）次。即O(n^2)
3) 渐进时间复杂度（平均时间复杂度）：O(n^2)
2. 空间复杂度：O(1)
从实现原理可知，选择排序是在原输入数组上进行比较交换的（称“就地排序”），所需开辟的辅助空间跟输入数组规模无关，所以空间复杂度为：O(1)

(三)稳定性
插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。当然，刚开始这个有序的小序列只有1个元素，就是第一个元素。比较是从有序序列的末尾开始，也就是想要插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其后面，否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。

(四)优化改进
1， 折半插入排序。将直接插入排序中寻找A[i]的插入位置的方法改为采用折半比较，即可得到折半插入排序算法。
2，希尔排序。又称缩小增量排序。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。