C#写算法之冒泡排序

bubble sort ,一种基础的交换排序。

思想：相邻元素两两比较，当一个元素大于右侧相邻元素时，交换它们的位置；当一个元素小于或等于右侧相邻元素时，位置不变。

using System;

namespace CSharpTest01
{
    class Program
    {
        /// <summary>
        /// 冒泡排序
        /// sortBorder 有序区标记
        /// </summary>
        static void BubbleSort(int[] array)
        {
            // 记录最后一次交换的位置
            int lastExchangeIndex = 0;
            // 无序数列的边界，每次比较只需要比到这里为止
            int sortBorder = array.Length - 1;
            for (int i = 0; i < array.Length-1; i++)
            {
                // 有序标记，每一轮的初始值都是true
                bool isSorted = true;
                for (int j = 0; j < sortBorder; j++)
                {
                    int temp = 0;
                    if(array[j] > array[j + 1])
                    {
                        temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = temp;
                        // 因为有元素进行交换，所以不是有序的，标记为false
                        isSorted = false;
                        // 更新为最后一次交换元素的位置
                        lastExchangeIndex = j;
                    }
                }
                sortBorder = lastExchangeIndex;
                if (isSorted) { break; }
            }
        }

        static void Main(string[] args)
        {
            int[] array = new int[] { 5, 8, 6, 3, 9, 2, 1, 7 };
            BubbleSort(array);
            foreach (var item in array)
            {
                Console.Write(item + " ");
            }
            Console.ReadLine();
        }
    }
}

上述代码中，sortBorder就是无序数列的边界。在每一轮排序过程中，处于sortBorder之后的元素就不需要进行比较排序了，肯定是有序的。

鸡尾酒排序--基于冒泡排序的升级排序法：

鸡尾酒排序过程就像钟摆一样，第1轮从左到右，第2轮从右到左，第3轮再从左到右...

鸡尾酒排序的优点是能够在特定条件下，减少排序的回合数；而缺点也很明显，就是代码量增加一倍。

在大部分元素已经有序的情况下，鸡尾酒排序可以发挥优势。

using System;

namespace CSharpTest01
{
    class Program
    {
        /// <summary>
        /// 鸡尾酒排序
        /// 代码外层的大循环控制着所有排序回合，大循环内包含2个小循环，
        /// 第1个小循环从左向右比较并交换元素，
        /// 第2个小循环从右向左比较并交换元素
        /// 适用场合：大部分元素已经有序的情况下
        /// </summary>
        static void ShakerSort(int[] array)
        {
            int temp = 0;
            for (int i = 0; i < array.Length/2; i++)
            {
                // 有序标记，每一轮的初始值都是true
                bool isSorted = true;
                // 奇数轮，从左到右比较和交换
                for (int j = i; j < array.Length-i-1; j++)
                {
                    if (array[j] > array[j + 1])
                    {
                        temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = temp;
                        // 有元素交换，所以不是有序的，标记变为false
                        isSorted = false;
                    }
                }
                if (isSorted) break;
                // 在偶数轮之前，将isSorted重新标记为true
                isSorted = true;
                for (int j = array.Length-i-1; j > i; j--)
                {
                    if (array[j] < array[j - 1])
                    {
                        temp = array[j];
                        array[j] = array[j - 1];
                        array[j - 1] = temp;
                        // 因为有元素进行交换，所以不是有序的，标记变为false
                        isSorted = false;
                    }
                }
                if (isSorted) { break; }
            }            
        }
        static void Main(string[] args)
        {
            Console.WriteLine("Program Start:");
            int[] array = new int[] { 2, 3, 4, 5, 6, 7, 8, 1 };
            ShakerSort(array);
            for (int i = 0; i < array.Length; i++)
            {
                Console.WriteLine(array[i]);
            }
            Console.WriteLine("Program End:");
        }
    }
}