双向冒泡排序

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

//双向冒泡排序说明
//鸡尾酒排序，也称为双向冒泡排序、调酒器排序、搅拌排序（可以参考选择排序的一个变种）、纹波排序、接送排序，或欢乐时光排序。它由冒泡排序变化而来，是一种稳定的比较排序算法。该算法不同于冒泡排序，它在排序上由两个方向同时进行。该排序算法只是比冒泡排序稍难实现，但解决了冒泡排序中的“乌龟问题”（数组尾部的小值）。

//首先从左向右方向为大元素移动方向，从右向左方向为小元素移动方向，然后每个元素都依次执行。在第 i 次移动后，前 i 个元素和后个 i 元素都放到了正确的位置，也不需要在检查一次。每次缩短已排序的那部分列表，都可以减半操作次数。

//但是在乱数序列的状态下，双向冒泡排序与冒泡排序的效率都很差劲。

namespace 双向冒泡排序
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> arrayToSort = new List<int>() { 12, 4654, 789, 1, 456, 174, 6, 54, 9 };
            int limit = arrayToSort.Count;
            int st = -1;
            bool swapped = false;
            do//do-while语句，当while中为false时结束。
            {
                swapped = false;
                st++;
                limit--;
                //从左往右方向为大元素移动方向
                for (int j = st; j < limit; j++)//这个for循环的条件和下面的for循环条件不一样，注意！！！
                {
                    if (((IComparable)arrayToSort[j]).CompareTo(arrayToSort[j + 1]) > 0)
                    {
                        int temp = arrayToSort[j];
                        arrayToSort[j] = arrayToSort[j + 1];
                        arrayToSort[j + 1] = temp;
                        swapped = true;
                    }
                }
                //从右往左方向为小元素移动方向
                for (int j = limit - 1; j >= st; j--)//这个for循环的条件和上面的for循环条件不一样，注意！！！
                {
                    if (((IComparable)arrayToSort[j]).CompareTo(arrayToSort[j + 1]) > 0)
                    {
                        int temp = arrayToSort[j];
                        arrayToSort[j] = arrayToSort[j + 1];
                        arrayToSort[j + 1] = temp;
                        swapped = true;
                    }
                }
            } while (st < limit && swapped);//在第i次移动后，前i个元素和后i个元素都放到了正确的位置，也不需要在检查一次。每次缩短已排序的那部分列表，都可以减半操作次数。
            #region 遍历输出数组
            for (int i = 0; i < arrayToSort.Count; i++)
            {
                Console.Write(arrayToSort[i].ToString() + ",");
            }

            Console.ReadKey();
            #endregion
        }

        //上面的算法是基于该实现套用的。
        public IList BiDerectionalBubleSort(IList arrayToSort)
        {
            int limit = arrayToSort.Count;
            int st = -1;
            bool swapped = false;
            do
            {
                swapped = false;
                st++;
                limit--;
                //从左往右方向为大元素移动方向
                for (int j = st; j < limit; j++)
                {
                    if (((IComparable)arrayToSort[j]).CompareTo(arrayToSort[j + 1]) > 0)
                    {
                        object temp = arrayToSort[j];
                        arrayToSort[j] = arrayToSort[j + 1];
                        arrayToSort[j + 1] = temp;
                        swapped = true;
                    }
                }
                //从右往左方向为小元素移动方向
                for (int j = limit-1; j >= st; j--)
                {
                    if (((IComparable)arrayToSort[j]).CompareTo(arrayToSort[j + 1]) > 0)
                    {
                        object temp = arrayToSort[j];
                        arrayToSort[j] = arrayToSort[j + 1];
                        arrayToSort[j + 1] = temp;
                        swapped = true;
                    }
                }
            } while (st<limit&&swapped);//在第i次移动后，前i个元素和后i个元素都放到了正确的位置，也不需要在检查一次。每次缩短已排序的那部分列表，都可以减半操作次数。
            return arrayToSort;
        }
    }
}

学习来源：http://blog.jobbole.com/72850/