排序-冒泡、插入、选择

排序一：选择排序
1、算法介绍
基本思想是：每一趟从待排序的数据元素中从头至尾扫描选出最小（或最大）的一个元素，和原始序列的第一个元素交换，接着从剩下的元素中继续执行这样的选择和交换，最终使序列有序。
2、执行流程：
进行第一趟排序，从无序序列中选取一个最小的关键字13，使其与无序序列的第一个关键字交换，则此时产生了仅含有一个关键字的有序序列，而无序序列中的关键字减少1个。
原始序列：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 49 65 97
第五趟排序后：[13 27 38 49 49] 76 65 97
第六趟排序后：[13 27 38 49 49 65] 76 97
第七趟排序后：[13 27 38 49 49 65 76] 97
第八趟排序后：[13 27 38 49 49 65 76 97]
3、源码
#include<iostream>
using namespace std;
void Selectsort(int R[],int n)
{
int i,j,k;
int temp;
for(i=0;i<n;++i)
{
k=i;
for(j=i+1;j<n;++j)
if(R[k]<R[j])//<降序，>升序
k=j;
temp=R[i];
R[i]=R[k];
R[k]=temp;
}
}
int main()
{
int a[10]={2,5,6,3,7,8,0,9,12,1};
Selectsort(a,10);
for(int i=0;i<10;++i)
cout<<a[i]<<" ";
return 0;
}
4、选择排序的性能分析

• 时间复杂度分析：
  从上面的代码中，我们可以看出两层循环的执行次数和初始序列没有关系，外层循环执行n次，内层循环执行n-i次，将最内层循环中的比较操作视为关键操作。其执行次数为(n-1+1)*(n-1)/2=n(n-1)/2。即时间复杂度为O(n2)。

• 空间复杂度分析：
  算法所需要的辅助存储空间不随待排序列规模的变化而变化，是个常量，因此时间复杂度度为O(1)。

排序二：冒泡排序
1、基本思想
首先第一个元素和第二个元素比较，如果第一个大，则两者交换，否则二不交换；然后第二个元素和第三个元素比较，如果第二个大，则两者交换，否则不交换，……一直按这种方式进行下去，最终最大的那个元素被交换到最后，一趟冒泡排序完成。
在这个过程中个，大的关键字像石头一样“沉底”,小的关键字像气泡一样逐渐向上“浮动”，冒泡排序的名字由此而来。
2、执行流程
原始序列：49 38 65 97 76 13 27 49
下面进行一趟气泡排序:
1)1号和2号比较，49>38,交换
结果：[38 49] 65 97 76 13 27 49
2)2号和3号比较，49<65,不交换
结果：[38 49 65] 97 76 13 27 49
3)3号和4号比较，65<97,不交换
结果：[38 49 65 97] 76 13 27 49
4)4号和5号比较，76<97,交换
结果：[38 49 65 76 97] 13 27 49
5)5号和6号比较,97>13,交换
结果：[38 49 65 76 13 97] 27 49
6)6号和7号比较,97>27,交换
结果：[38 49 65 76 13 27 97] 49
7)7号和8号比较,97>27,交换
结果：[38 49 65 76 13 27 49 97]
小结：
至此一趟排序结束，最大的97被交换到了最后，97达到了它最后的位置。接下来对序列38 49 65 76 13 27 49按照同样的方法进行第二趟冒泡排序。经过若干趟冒泡排序后，最终序列有序。要注意的是，冒泡排序算法结束的条件是在一趟排序过程中没有发生关键字交换。

代码

void  BubbleSort(int R[],int n)
{
    int i,j,flag;
    int temp;
    for(i=n-1;i>=1;--i)
    {
        flag=0;//变量flag用来标记本趟排序是否发生了交换。 
        for(j=1;j<=i;++j)
         if(R[j-1]<R[j])
         {
            temp=R[j];
            R[j]=R[j-1];
            R[j-1]=temp;
            flag=1;//如果没发生交换，则flag的值为0；如果发生 
                   //交换，则flag的值改为1。 
          } 
          if(flag==0)//一趟排序过程找那个没有发生关键字交换，则证明序列
                     //有序，排序结束 
          return; 
    }
 } 

4、性能分析
1、时间复杂度分析

 从上面的代码中，我们可以把最内层循环里的元素交换操作看做基本操作。
    1、最坏情况，待排序列为逆序，此时对于外层循环的都每次执行，内层循环中if语句的条件R[j]<R[j-1]始终成立，即基本操作执行的次数为n-i。i的取值为1~n-1。因此基本操作总的执行次数为：(n-1+1)*(n-1)/2=n(n-1)/2。也就是O(n2)。
    2、最好情况，待排序列为有序，此时内层循环中if语句的条件始终不成立，交换不发生，且内层循环执行n-1后整个算法结束，所以时间复杂度为O(n)。

2、空间复杂度分析

一般我们以最坏时间复杂度为参考，这个算法的额外空间只有一个temp，空间复杂度为O(1)。

排序三
1、基本思想
每趟将一个待排序的元素按照元素的大小插入到已经排好的部分有序序列的适当位置上，直到所有待排序元素都插入到有序序列中为止。
2、执行流程
原始序列：49 38 65 97 76 13 27 49
1）一开始只看49，一个数当然是有序的。
[49] 38 65 97 76 13 27 49
2）插入38。38<49,所以49向后移动一个位置，38插入到49原来的位置，这趟排序后的结果为： [38 49] 65 97 76 13 27 49
3）插入65。65>49,所以不需要移动，65就应该在49之后，这趟排序后的结果为：
[38 49 65] 97 76 13 27 49
4）插入97。97>65,所以不需要移动，97就应该在65之后，这趟排序后的结果为：
[38 49 65 97] 76 13 27 49
5）插入76。97>76,所以97向后移动一个位置；继续比较，76>65,65不需要移动，76应该插 入在65之后、97之前，这趟排序后的结果为：
[38 49 65 76 97] 13 27 49
6）插入13。13<97,97后移；这样逐个向前比较，发现13应该插入在最前面，这趟排序后的结果为：[13 38 49 65 76 97] 27 49
7）插入27。还是从后面向前进行比较，确定27应该插入在13之后、38之前，这趟排序的结果为： [13 27 38 49 65 76 97] 49
8）插入49。同样从后面向前进行比较，直到49=49<65,它的位置确定，直接插入排序全过程完 成这趟排序的结果为：
[13 27 38 49 49 65 76 97]

void InsertSort(int R[],int n)
{
    int i,j;
    int temp;
    for(i=1;i<n;++i)
    {
        temp=R[i];//将待插入关键字暂存于temp中。 
        j=i-1;
        //下面这个循环完成了从待排序关键字之前的关键字开始扫描，
        //如果大于待排关键字，则后移一位
        while(j>=0&&temp>R[j])
        {
            R[j+1]=R[j];
            --j;
         } 
         R[j+1]=temp;//找到 
    }

}

4、性能分析
<1>时间复杂度分析
从上面的代码中，我们可以把最内层循环里的R[j+1]=R[j];操作看做基本操作。
1、最坏情况，待排序列为逆序，此时对于内层循环中的temp