排序问题（上) 【冒泡排序】【插入排序】【希尔排序】

注意：（在下面的各类排序问题中）

1. 只讨论基于比较的排序；
2. 只讨论内部排序；
3. 稳定性：任意两个相等的数据，排序前后的相对位置不发生改变；
4. 没有一种排序是在任何情况下都表现最好的；

    冒泡排序  :    

    原理：比较两个相邻的元素，将值大的元素交换到右边。

    排序过程：依次比较相邻的两个数，将比较小的数放在前面，比较大的数放在后面。

    冒泡排序的优点：每进行一趟排序，就会少比较一次，因为每进行一趟排序都会找出一个较大值。

    例如：对 12 ， 3 ，5 ，10 ，4 ，9 进行排序。

        (1)第一次比较：首先比较第一和第二个数，将小数放在前面，将大数放在后面。
        (2)比较第2和第3个数，将小数 放在前面，大数放在后面。
        …
        (3)如此继续，直到比较到最后的两个数，将小数放在前面，大数放在后面，重复步骤，直至全部排序完成。
        (4)在上一趟比较完成后，最后一个数一定是数组中最大的一个数，所以在比较第二趟的时候，最后一个数是不参加比较的。
        (5)在第二趟比较完成后，倒数第二个数也一定是数组中倒数第二大数，所以在第三趟的比较中，最后两个数是不参与比较的。
        (6)依次类推，每一趟比较次数依次减少。

    代码如下：

#include <iostream>

using namespace std;


int N=10;
int A[10];
int P;

void Bubble_Sort (int A[],int N)
{
   for(P=N-1;P>=0;P--)            /*每比较一次，排序的次数就会依次减少*/
   {
      int flag=0;

      for(int i=0;i<P;i++)        /*一趟冒泡排序*/
      {
         if(A[i]>A[i+1])
         {
            swap(A[i],A[i+1]);       /*进行比较交换*/

            flag=1;                   /*用来表示已经发生了交换*/
         }

       }

       if(flag==0)  break;            /*全程无交换，直接退出比较*/
   }

}

int main()
{

   for(int i=0;i<N;i++) cin >> A[i];

   Bubble_Sort(A,10);

   for(int i=0;i<N;i++) cout << A[i]<<endl;

    return 0;
}

  Addition :

     1. 最好情况：顺序 O(n)；
     2. 最坏情况：逆序 O(n^2);
     3. 稳定性：稳定。

---

    插入排序  :    

    原理：将第一个数字看作是有序的序列，将剩下的 n-1个数依次与有序序列中的数从后往前进行比较，直到该数比前一个数小，比后一个数大，插入其中，就此完成一趟插入排序。（联想 打扑克牌 插入扑克牌的过程）

    例如：对 12 ， 3 ，5 ，10 ，4 ，9 进行排序。

    代码如下：

#include <iostream>

using namespace std;

int N=10;
int A[10];
int P;
int Tmp;
int i;

void Insert_Sort (int A[],int N)
{
   for(P=1;P<N;P++)
   {

      Tmp=A[P];                             /*摸下一张牌*/

      for(i=P; i>0 && Tmp < A[i-1];i--)
      {
         A[i]=A[i-1];                        /*移出空位*/
      }
      
      A[i]=Tmp;                               /*新牌落位*/
   }

}

int main()
{

   for(i=0;i<N;i++) cin >> A[i];

   Insert_Sort(A,10);

   for(i=0;i<N;i++) cout << A[i]<<endl;

    return 0;
}

  Addition :

     1. 最好情况：顺序 O(n)；
     2. 最坏情况：逆序 O(n^2);
     3. 稳定性：稳定。

---

  两者关联与拓展 ：

• 逆序队：对于下标 i < j ,如果A [ i ] >A [ j ] ,则称（i , j )是一个逆序队。
• 交换两个相邻元素正好可以消去一个逆序队。
• 对于冒泡排序和插入排序，两者都是以交换两个相邻元素，消去逆序队的方法进行排序。时间复杂度均与逆序队个数有关。
• 定理：任意N个不同元素组成的序列平均具有N ( N-1)/4个逆序队。
• 定理：任何仅以交换相邻两元素来排序的算法，其平均时间复杂度为     Ω (N^2)。（指的是 时间复杂度下界）
• 因此，可以从    每次交换消去不止一个逆序队      每次交换相隔较远的两个元素 来提高算法效率。

---

    希尔排序  :    

    原理： 希尔排序是插入排序的一种

    排序过程：希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

    例如： 对12 ，3 ，5 ，10 ， 4 ，9进行希尔排序。 （图中深蓝部分按照插入排序的规则进行排序）

• 首先定义增量序列 Dm > Dm -1 > …=1 .
• 对每个Dk 进行 “ Dk-间隔 ”排序（k=M,M-1…）.
• 注意：“ Dk-间隔 ” 有序的序列，在执行“ Dk-1-间隔 ”排序后，仍然是“ Dk-间隔 ” 有序的。

    代码如下：

#include <iostream>

using namespace std;


int N=10;
int A[10];
int P;
int Tmp;
int i;
int D;

void Shell_Sort (int A[],int N)
{
   for( D=N/2;D>0;D=D/2)                      /*以N/2的间隔进行排序*/
   {
       for(P=D;P<N;P++)                       /*间隔了D个距离，因此先从第N个牌开始摸起*/
         {

            Tmp=A[P];                             /*摸下一张牌*/

            for(i=P; i>=D && Tmp < A[i-D];i-=D)
            {
               A[i]=A[i-D];                        /*移出空位*/
            }

            A[i]=Tmp;                               /*新牌落位*/
         }

   }

}

int main()
{

   for(i=0;i<N;i++) cin >> A[i];

   Shell_Sort(A,10);

   for(i=0;i<N;i++) cout << A[i]<<endl;

    return 0;
}

  Addition :

     1 . 时间复杂度为O( n^3/2 ) ； （非严格意义上讲）
     2 . 稳定性：不稳定。