經典演算法題每日演練——第二十三題 雞尾酒排序

 

 

　　這篇我們繼續扯淡一下雞尾酒排序，為了知道為啥取名為雞尾酒，特意看了下百科，見框框的話，也只能勉強這麼說了。

 

要是文藝點的話，可以說是攪拌排序，通俗易懂點的話，就叫“雙向氣泡排序”，我想作為碼農的話，不可能不知道氣泡排序，

冒泡是一個單向的從小到大或者從大到小的交換排序，而雞尾酒排序是雙向的，從一端進行從小到大排序，從另一端進行從大

到小排序。

從圖中可以看到，第一次正向比較，我們找到了最大值9. 

                      第一次反向比較，我們找到了最小值1.

                      第二次正向比較，我們找到了次大值8.

                      第二次反向比較，我們找到了次小值2

                      。。。

                     最後就大功告成了。

 

下面我們看看程式碼：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Xsl;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> list = new List<int>() { 8, 1, 4, 2, 9, 5, 3 };

            Console.WriteLine("\n排序前 => {0}\n", string.Join(",", list));

            list = CockTailSort(list);

            Console.WriteLine("\n排序後 => {0}\n", string.Join(",", list));

            Console.Read();
        }

        /// <summary>
        /// 雞尾酒排序
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        static List<int> CockTailSort(List<int> list)
        {
            //因為是雙向比較，所以比較次數為原來陣列的1/2次即可。
            for (int i = 1; i <= list.Count / 2; i++)
            {
                //從前到後的排序 (升序)
                for (int m = i - 1; m <= list.Count - i; m++)
                {
                    //如果前面大於後面，則進行交換
                    if (m + 1 < list.Count && list[m] > list[m + 1])
                    {
                        var temp = list[m];

                        list[m] = list[m + 1];

                        list[m + 1] = temp;
                    }
                }

                Console.WriteLine("正向排序 => {0}", string.Join(",", list));

                //從後到前的排序（降序）
                for (int n = list.Count - i - 1; n >= i; n--)
                {
                    //如果前面大於後面，則進行交換
                    if (n > 0 && list[n - 1] > list[n])
                    {
                        var temp = list[n];

                        list[n] = list[n - 1];

                        list[n - 1] = temp;
                    }
                }

                Console.WriteLine("反向排序 => {0}", string.Join(",", list));
            }

            return list;
        }
    }
}

 

從結果上面看，我們會發現，當陣列有序的時候，我們還會繼續往下排，知道完成length/2次，這個就跟沒優化之前的氣泡排序一樣，

此時我們可以加上一個標誌位IsSorted來判斷是否已經沒有交換了，如果沒有，提前退出迴圈。。。

        /// <summary>
        /// 雞尾酒排序
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        static List<int> CockTailSort(List<int> list)
        {
            //判斷是否已經排序了
            var isSorted = false;

            //因為是雙向比較，所以比較次數為原來陣列的1/2次即可。
            for (int i = 1; i <= list.Count / 2; i++)
            {
                //從前到後的排序 (升序)
                for (int m = i - 1; m <= list.Count - i; m++)
                {
                    //如果前面大於後面，則進行交換
                    if (m + 1 < list.Count && list[m] > list[m + 1])
                    {
                        var temp = list[m];

                        list[m] = list[m + 1];

                        list[m + 1] = temp;

                        isSorted = true;
                    }
                }

                Console.WriteLine("正向排序 => {0}", string.Join(",", list));

                //從後到前的排序（降序）
                for (int n = list.Count - i - 1; n >= i; n--)
                {
                    //如果前面大於後面，則進行交換
                    if (n > 0 && list[n - 1] > list[n])
                    {
                        var temp = list[n];

                        list[n] = list[n - 1];

                        list[n - 1] = temp;

                        isSorted = true;
                    }
                }

                //當不再有排序，提前退出
                if (!isSorted)
                    break;

                Console.WriteLine("反向排序 => {0}", string.Join(",", list));
            }

            return list;
        }