排序算法之插入排序、冒泡排序和选择排序

　　将这三个排序放在一起的原因是在输入数据无序或者随机性较大的情况下，三种排序的时间复杂度都是O(n^2)，下面将依次介绍这三种排序方法

1、插入排序

　　所谓插入排序，就相当于将未排序的序列分为两部分，第一部分是已经有序的（初试状态下，第一部分只包含第一个元素，它肯定是有序的），第二部分是无序的，顺序遍历第二部分，将其插入到第一部分中合适的位置

　　所以，插入排序需要两个主要步骤，第一个就是维持有序部分，第二个就是遍历无序序列并插入元素（插入过程中涉及到元素的移动）

　　代码如下：

　　

#include <iostream>
#include <algorithm>
#include <iterator>
using namespace std;
void insertSort(int data[],int length){
    if(data==NULL||length<=0)
        return ;
    for(int i=1;i<length;i++){   //遍历无序的第二部分
        int cur=data[i];     //记录当前的值，因为如果需要将该值插入到前面的有序部分，需要将该值前面的部分后移一位
        if(data[i-1]>cur){   //如果当前元素的值比它前面的值小，则需要插入操作，否则不需要
            int j=i-1
            for(;j>=0&&data[j]>cur;j--)  //找到对应的插入位置
                data[j+1]=data[j];    //移动元素
            data[j+1]=cur;            //插入当前值
        }
    }
}
int main(){
    int data[]={9,5,6,4,1,2,3,7,8,1};
    int length=sizeof(data)/sizeof(int);
    insertSort(data,length);
    copy(data,data+length,ostream_iterator<int>(cout,","));
    return 0;
}

　　插入排序的时间复杂度分析：试想，如果数组本来有序，则第一层循环中的插入操作没有执行，整个排序过程只是遍历了一下数组，所以插入排序在数组有序的情况下，时间复杂度是O(n)，当数组逆序的时候，第二部分的每一个数组都需要向前插入，时间复杂度是O(n^2)，在平均情况下，时间复杂度也是O(n^2)

　　插入排序的稳定性：由插入排序的过程可以知道，插入排序是稳定的

　　总结：插入排序的时间复杂度原始数组有关系，最差和平均时间复杂度是O(n^2)，最优情况下是O(n)，插入排序是稳定的排序

2、冒泡排序

　　冒泡排序的过程就像水中的气泡逐渐向上升的过程，深度越大的气泡越小，我们从最上面的气泡开始考虑，如果当前气泡小于它下面的气泡，则交换两个气泡的位置，这个过程依次向下执行，这样的一组比较过程称为一趟排序，经过一趟排序，总是有一个数组元素到达它应该在的位置上，因此，假设数组共有n个元素，则经历n-1趟排序就可使数组有序。

　　代码如下：

#include <iostream>
#include <algorithm>
#include <iterator>
using namespace std;
void bubbleSort(int data[],int length){
    if(data==NULL||length<=0)
        return ;
    for(int i=0;i<length-1;i++){    //n-1趟排序过程
        bool flag=false;                //用来记录一趟排序中，数组元素是否进行了交换
        for(int j=length-1;j>i;j--){  //后到前依次比较
            if(data[j-1]>data[j]){
                swap(data[j],data[j-1]);
                flag=true;
            }
        }
        if(flag==false)
            return ;
    }
}
int main(){
    int data[]={6,9,5,4,5,6,2,1,3};
    int length=sizeof(data)/sizeof(int);
    bubbleSort(data,length);
    copy(data,data+length,ostream_iterator<int>(cout,","));
    return 0;
}

　　冒泡排序的时间复杂度分析：由上面的代码可知，在一趟排序中，内循环执行了n-1次比较，如果数组有序，则交换的次数为0，函数退出，因此冒泡的最佳时间复杂度是O(n)，如果数组逆序，每趟排序都需要（j-i）次交换，所以最坏的时间复杂度是O(n^2)，平均时间复杂度也是O(n^2)

　　冒泡排序的稳定性：由于是从上到下依次比较，因此，如果两个数相同，它们在原始数组中的相对位置和排序过后的相对位置应该不变，所以冒泡排序是稳定的排序

　　总结：冒泡排序的时间复杂度和输入数组有关系，如果有序，则有最佳时间复杂度O(n)，它的平均和最差时间复杂度是O(n^2)，冒泡排序是稳定的排序

3、选择排序

　　选择排序，顾名思义，就是每次从数组选择出最小的数字放置在数组中，是这三种排序中最简单的一种排序方法

　　代码如下所示：

　　

#include <iostream>
#include <algorithm>
#include <iterator>
using namespace std;
void selectSort(int data[],int length){
    if(data==NULL||length<=0)
        return ;
    for(int i=0;i<length-1;i++){
        int min=i;
        for(int j=i;j<length;j++){
            if(data[j]<data[min])
                min=j;
        }
        if(min!=i)
            swap(data[i],data[min]);
    }
}
int main(){
    int data[]={9,5,4,6,1,2,3,10,7,8};
    int length=sizeof(data)/sizeof(int);
    selectSort(data,length);
    copy(data,data+length,ostream_iterator<int>(cout,","));
    return 0;
}

　　选择排序的时间复杂度分析：要排序n个数，只需要进行n-1次选择即可，但是每一次的选择过程都需要从当前位置的下一位置遍历到最后，所以选择排序的时间复杂度是O(n^2)

　　选择排序的稳定性：由于每次选择都需要进行遍历数组，在原始数组中两个相同的数字A、B，在选择时B可能会先于A被选择，所以选择排序不是稳定的排序

　　总结：选择排序和输入数组没有关系，它的时间复杂度总是O(n^2)，选择排序是不稳定的排序。