算法：四种冒泡排序（Bubble Sort）实现

背景

大学关于排序的算法，好像就学会了冒泡排序，这个算是排序界的 hello,world 了，冒泡排序的定义如下：

重复的遍历数组。

/// <summary>
/// 重复的遍历数组。
/// 每次遍历都比较两个元素，如果顺序不正确就把他们交换一下。
/// 如果遍历后只交换了 1 次或 0 次，排序结束。
/// 最多需要 length -1 次遍历，第 iterTimes 次需要遍历 length - iterTimes - 1 个元素。
/// </summary>

四种实现代码

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;

 namespace DataStuctureStudy.Sorts
 {
     /// <summary>
     /// 重复的遍历数组。
     /// 每次遍历都比较两个元素，如果顺序不正确就把他们交换一下。
     /// 如果遍历后只交换了 1 次或 0 次，排序结束。
     /// 最多需要 length -1 次遍历，第 iterTimes 次需要遍历 length - iterTimes - 1 个元素。
     /// </summary>
     class BubbleSort<T>
         where T : IComparable<T>
     {
         private static void Swap(T[] items, int left, int right)
         {
             if (left != right)
             {
                 var temp = items[left];
                 items[left] = items[right];
                 items[right] = temp;
             }
         }

         public static void Sort1(T[] items)
         {
             if (items.Length < )
             {
                 return;
             }

             int swappedTimes;
             do
             {
                 swappedTimes = ;
                 // 重复的遍历数组。
                 for (var i = ; i < items.Length; i++)
                 {
                     // 每次遍历都比较两个元素，如果顺序不正确就把他们交换一下。
                     if (items[i - ].CompareTo(items[i]) > )
                     {
                         Swap(items, i - , i);
                         swappedTimes++;
                     }
                 }
             } while (swappedTimes > );// 如果遍历后只交换了 1 次或 0 次，排序结束。
         }

         public static void Sort2(T[] items)
         {
             if (items.Length < )
             {
                 return;
             }

             int swappedTimes;
             do
             {
                 swappedTimes = ;
                 int iterTimes = ;

                 for (var i = ; i < items.Length - iterTimes; i++)
                 {
                     if (items[i - ].CompareTo(items[i]) > )
                     {
                         Swap(items, i - , i);
                         swappedTimes++;
                     }
                 }
                 iterTimes--;
             } while (swappedTimes > );
         }

         public static void Sort3(T[] items)
         {
             if (items.Length < )
             {
                 return;
             }

             for (var i = ; i < items.Length; i++)
             {
                 int swappedTimes = ;
                 for (var j = ; j < items.Length - i + ; j++)
                 {
                     if (items[j - ].CompareTo(items[j]) > )
                     {
                         Swap(items, j - , j);
                         swappedTimes++;
                     }
                 }

                 if (swappedTimes <= )
                 {
                     break;
                 }
             }
         }

         public static void Sort4(T[] items)
         {
             Sort4Helper(items, );
         }

         private static void Sort4Helper(T[] items, int iterTimes)
         {
             if (items.Length < )
             {
                 return;
             }

             int swappedTimes = ;
             for (var i = ; i < items.Length - iterTimes; i++)
             {
                 if (items[i - ].CompareTo(items[i]) > )
                 {
                     Swap(items, i - , i);
                     swappedTimes++;
                 }
             }

             if (swappedTimes <= )
             {
                 return;
             }

             Sort4Helper(items, iterTimes + );
         }
     }
 }

备注

真不知道如何说，说明我对这些简单算法的理解还不够深入。