算法系列15天速成——第一天 七大經典排序【上】

今天是開篇，得要吹一下算法，算法就比如程序開發中的利劍，所到之處，刀起頭落。

 

針對現實中的排序問題，算法有七把利劍能夠助你馬道成功。

 

首先排序分爲四種： 

      交換排序： 包括冒泡排序，快速排序。

      選擇排序： 包括直接選擇排序，堆排序。

      插入排序： 包括直接插入排序，希爾排序。

      合併排序： 合併排序。

 

那麼今天咱們講的就是交換排序，咱們都知道，C#類庫提供的排序是快排，爲了讓今天玩的有意思點，

咱們設計算法來跟類庫提供的快排較量較量。爭取KO對手。

 

冒泡排序：

首先咱們本身來設計一下「冒泡排序」，這種排序很現實的例子就是：

我抓一把沙仍進水裏，那麼沙子會立馬沉入水底， 沙子上的灰塵會由於慣性暫時沉入水底，可是又會立馬像氣泡同樣浮出水面，最後也就真相大白咯。

 

關於冒泡的思想，我不會說那麼官方的理論，也不會貼那些文字上來，個人思想就是看圖說話。

那麼咱們就上圖.

           

要達到冒泡的效果，咱們就要把一組數字豎起來看，你們想一想，如何冒泡？如何來體會重的沉底，輕的上浮？

 

第一步:  咱們拿40跟20比，發現40是老大，不用交換。

第二步:  而後向前推一步，就是拿20跟30比，發現30是老大，就要交換了。

第三步：拿交換後的20跟10比，發現本身是老大，不用交換。

第四步：拿10跟50交換，發現50是老大，進行交換。

 

最後，咱們通過一次遍歷，把數組中最小的數字送上去了，看看，咱們向目標又邁進了一步。

 

如今你們思想都知道了，下面咱們就強烈要求跟快排較量一下，不是你死就是我活。

  System;
  System.Collections.Generic;
  System.Linq;
  System.Text;
  System.Diagnostics;
  System.Threading;
 
  BubbleSort
 {
       Program
     {
           Main([] args)
         {
                           ( i = ; i <= ; i++)
             {
                 List<> list =  List<>();
                                   ( j = ; j < ; j++)
                 {
                     Thread.Sleep();
                     list.Add( Random(()DateTime.Now.Ticks).Next(, ));
                 }
                 Console.WriteLine( + i + );
                 Stopwatch watch =  Stopwatch();
                 watch.Start();
                  result = list.OrderBy(single => single).ToList();
                 watch.Stop();
                 Console.WriteLine( + watch.ElapsedMilliseconds);
                 Console.WriteLine( + .Join(, result.Take().ToList()));
                 watch.Start();
                 result = BubbleSort(list);
                 watch.Stop();
                 Console.WriteLine( + watch.ElapsedMilliseconds);
                 Console.WriteLine( + .Join(, result.Take().ToList()));
             }
         }
 
                   List<> BubbleSort(List<> list)
         {
              temp;
                           ( i = ; i < list.Count - ; i++)
             {
                                    ( j = list.Count - ; j > i; j--)
                 {
                                           (list[j - ] > list[j])
                     {
                         temp = list[j - ];
                         list[j - ] = list[j];
                         list[j] = temp;
                     }
                 }
             }
              list;
         }
     }
 }

 

 

嗚嗚，看着這兩種排序體檢報告，心都涼了，冒泡被快排KO了，真慘，難怪人家說冒泡效率低，原來真tmd低。

 

快速排序：

既然能把冒泡KO掉，立刻就激起咱們的興趣，tnd快排咋這麼快，必定要好好研究一下。

首先上圖：    

 

從圖中咱們能夠看到：

left指針，right指針，base參照數。

其實思想是蠻簡單的，就是經過第一遍的遍歷（讓left和right指針重合）來找到數組的切割點。

第一步：首先咱們從數組的left位置取出該數（20）做爲基準（base）參照物。

第二步：從數組的right位置向前找，一直找到比（base）小的數，

            若是找到，將此數賦給left位置（也就是將10賦給20），

            此時數組爲：10，40，50，10，60，

            left和right指針分別爲先後的10。

第三步：從數組的left位置向後找，一直找到比（base）大的數，

             若是找到，將此數賦給right的位置（也就是40賦給10），

             此時數組爲：10，40，50，40，60，

             left和right指針分別爲先後的40。

第四步：重複「第二,第三「步驟，直到left和right指針重合，

             最後將（base）插入到40的位置，

             此時數組值爲： 10，20，50，40，60，至此完成一次排序。

第五步：此時20已經潛入到數組的內部，20的左側一組數都比20小，20的右側做爲一組數都比20大，

            以20爲切入點對左右兩邊數按照"第一，第二，第三，第四"步驟進行，最終快排大功告成。

 

一樣，咱們把本身設計的快排跟類庫提供的快拍比較一下。看誰牛X。

  System;
  System.Collections.Generic;
  System.Linq;
  System.Text;
  System.Threading;
  System.Diagnostics;
 
  QuickSort
 {
       Program
     {
           Main([] args)
         {
                           ( i = ; i <= ; i++)
             {
                 List<> list =  List<>();
 
                                   ( j = ; j < ; j++)
                 {
                     Thread.Sleep();
                     list.Add( Random(()DateTime.Now.Ticks).Next(, ));
                 }
 
                 Console.WriteLine( + i + );
 
                 Stopwatch watch =  Stopwatch();
 
                 watch.Start();
                  result = list.OrderBy(single => single).ToList();
                 watch.Stop();
 
                 Console.WriteLine( + watch.ElapsedMilliseconds);
                 Console.WriteLine( + .Join(, result.Take().ToList()));
 
                 watch.Start();
                  QuickSortClass().QuickSort(list, , list.Count - );
                 watch.Stop();
 
                 Console.WriteLine( + watch.ElapsedMilliseconds);
                 Console.WriteLine( + .Join(, list.Take().ToList()));
 
             }
         }
     }
 
       QuickSortClass
     {
 
                          Division(List<> list,  left,  right)
         {
                           baseNum = list[left];
 
              (left < right)
             {
                                   (left < right && list[right] >= baseNum)
                     right = right - ;
 
                                  list[left] = list[right];
 
                                   (left < right && list[left] <= baseNum)
                     left = left + ;
 
 
                                  list[right] = list[left];
             }
                          list[left] = baseNum;
 
                            left;
         }
 
           QuickSort(List<> list,  left,  right)
         {
                           (left < right)
             {
                                   i = Division(list, left, right);
 
                                  QuickSort(list, left, i - );
 
                                  QuickSort(list, i + , right);
             }
         }
     }
 }

 

 

不錯，快排就是快，難怪內庫非要用他來做爲排序的標準。

 

嗯，最後要分享下：

冒泡的時間複雜度爲： 0(n) - 0(n^2)

快排的時間複雜度爲: 

    平均複雜度： N(logN)

    最壞複雜度：  0(n^2)

添加好友

小額贊助

微信	支付寶