数据结构之冒泡排序与插入排序的思想与实现

   经典的排序算法有很多种，有的时间复杂度也各不一样。《代码之美》一书的第三章《我从未编写过的最漂亮的代码》还对快速排序代码进行优化精讲，挺优美。这书不错。这次主要来自己动手实现这简单的冒泡排序与插入排序，加深熟练程度。

（一）冒泡排序

    基本思想：依次比较相邻的两个数，将小数放在前面，大数放在后面。由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序。主要通过两层循环来实现。

时间复杂度为:O（n∧2）

代码实现:

Code
 1 
 2         /// <summary>
 3         /// 冒泡排序（小数往前放，大数往后放，相当于气泡往上升）
 4         /// </summary>
 5         /// <param name="array"></param>
 6         public static void BubbleSort(int[] array)
 7         {
 8             int length = array.Length;
 9             for (int i = 1; i < length; i++)
10             {//外层：共需length-1轮
11                 ///在进行每趟比较前将flag置成true。
12                 /// 如果在比较中发生了数据交换，则将flag置为false，在一趟比较结束后，再判断flag，
13                 ///如果它仍为true（表明在该趟比较中未发生一次数据交换）则结束排序，否则进行下一趟比较。
14                 bool flag = true;
15                 for (int j = length-1; j >=1; j--)
16                 {
17                     if (array[j] < array[j - 1])
18                     {
19                         int temp = array[j];
20                         array[j] = array[j - 1];
21                         array[j - 1] = temp;
22                         flag = false;
23                     }
24                 }
25                 if (flag == true)
26                     return;
27             }
28 

(二)插入排序

 

   基本思想：插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中,从而得到一个新的、个数加一的有序数据，时间复杂度为O(㎡)。是稳定的排序方法。

其中包括很多种插入排序，包括：直接插入排序，折半插入排序，链表插入排序。

Code
 1         /// <summary>
 2         /// 直接插入排序
 3         /// </summary>
 4         /// <param name="array"></param>
 5         public static void InsertSort(int[] array)
 6         {
 7             int i, j;
 8             int temp;
 9             for (i =  1; i < array.Length; i++)
10             {
11                 temp = array[i];
12                 j = i - 1;
13                 //与已排序的数逐一比较, 大于temp时, 该数移后
14                 while ((j >= 0) && (array[j] > temp))
15                 {
16                     array[j + 1] = array[j];
17                     j--;
18                 }
19                 array[j + 1] = temp;
20             }

}
21 

 

补充：

直接选择排序：

   基本思想：从待排序的序列中，选择最小的一个记录，与第一个数据交换；然后从不包括第一个记录的序列中选择最小一个与第二个交换；如此重复，重复直至剩余序列只剩一个数据截止。

代码：

代码

 1           ///   <summary>
 2           ///  选择排序
 3           ///   </summary>
 4           ///   <param name="array"></param>
 5           private   void  SelectSort( int [] array)
 6          {
 7               int  tmp; // 暂存要交换的数据
 8               int  t; // 交换数据的位置
 9               for  ( int  i  =   0 ; i  <  arr.Length; i ++ )
10              {
11                  t  =  i;
12                   for  ( int  j  =  i + 1 ; j  <  arr.Length; j ++ )
13                  {
14                       if  (arr[j]  <  arr[t])
15                      {
16                          t  =  j;
17                      }
18                  }
19                  tmp  =  arr[i];
20                  arr[i]  =  arr[t];
21                  arr[t]  =  tmp;
22              }
23          }

 

 

转载于:https://www.cnblogs.com/wakerobin/archive/2009/10/21/1587706.html