冒泡排序算法

/*
 * 创建时间20130604
 * 参考资料 http://student.zjzk.cn/course_ware/data_structure/web/paixu/paixu8.3.1.1.htm
 * 冒泡排序算法解读，冒泡排序是升序
 */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;


namespace ArithmeticTest
{
    class BubbleSort
    {
        /// <summary>
        /// 调用排序方法参数
        /// </summary>
        public enum sortType { yi, er, san, si };


        public static void sort(int[] array, sortType st)
        {
            //为了区别排序算法
            int[] array1 = new int[array.Length]; Array.Copy(array, array1, array.Length);
            int[] array2 = new int[array.Length]; Array.Copy(array, array2, array.Length);
            Console.Write("未排序数组：");
            foreach (int y in array)
            {
                Console.Write(y.ToString() + " ");
            }
            Console.WriteLine();
            switch (st.ToString())
            {
                case "yi":
                    //方法1 自己的思路比较清晰，两两替换，记录每次循环替换次数，替换次数为0时，跳出循环
                    int whileNum = 1;                           //第几次执行替换
                    int infor = 0;
                    while (true)                                //定义死循环
                    {
                        int count = 0;                          //记录每次循环执行替换次数
                        infor = 0;
                        for (int i = 0; i < array1.Length; i++)
                        {
                            int val = array1[i];
                            //替换规则 根据索引i标识，跟i+1进行替换
                            if (i < array1.Length - 1 && array1[i] > array1[i + 1])
                            {
                                array1[i] = array1[i + 1];
                                array1[i + 1] = val;
                                count++;
                                infor++;
                            }
                        }
                        Console.Write(string.Format("i+1替换，循环次数{1}，第{0}次替换排序：", whileNum, infor));
                        arrayWrite(array1);
                        infor = 0;
                        for (int i = 1; i < array2.Length; i++)
                        {
                            int val = array2[i];
                            //替换规则 根据索引i标识，跟i-1进行替换
                            if (i > -1 && array2[i] < array2[i - 1])
                            {
                                array2[i] = array2[i - 1];
                                array2[i - 1] = val;
                                count++;
                                infor++;
                            }
                        }
                        Console.Write(string.Format("i-1替换，循环次数{1}，第{0}次替换排序：", whileNum, infor));


                        arrayWrite(array1);
                        if (count == 0)                          //当死循环不再执行替换，排序完成跳出
                        {
                            break;
                        }
                        whileNum++;
                    }
                    break;
                case "er":
                    //方法2 
                    int forNum = 0;                              //记录内层循环次数
                    for (int i = 1; i < array.Length; i++)
                    {
                        int val = array1[i];                     //取出循环首项，用于作参照对比
                        int j = i;
                        forNum = 0;
                        //while1 这个算法比较不好理解，涉及到值的传递
                        while (j > 0 && val < array1[j - 1])     //固定参照对比，索引变小替换
                        {
                            array1[j] = array1[j - 1];
                            forNum += 1;
                            j--;
                        }
                        array1[j] = val;
                        Console.Write(string.Format("固定参照，循环次数{1}，第{0}次替换排序：", i, forNum));
                        arrayWrite(array1);


                        forNum = 0;
                        j = i;
                        //while2 这里的条件和while1里的条件是一样的，array2[j]执行替换后始终等于array2[i]
                        while (j > 0 && array2[j] < array2[j - 1])//变动参照对比，索引变小替换；这里有个疑问就是
                        {
                            val = array2[j - 1];
                            array2[j - 1] = array2[j];
                            array2[j] = val;
                            forNum += 1;
                            j--;
                        }
                        Console.Write(string.Format("变动参照，循环次数{1}，第{0}次替换排序：", i, forNum));
                        arrayWrite(array2);
                    }
                    break;
                case "san":
                    //方法3 百度百科写法 最一开始接触的写法
                    for (int i = 0; i < array.Length - 1; i++)
                    {
                        forNum = 0;
                        for (int k = 0; k < array1.Length - i - 1; k++)
                        {
                            if (array1[k + 1] < array1[k])
                            {
                                int t = array1[k + 1];
                                array1[k + 1] = array1[k];
                                array1[k] = t;
                                forNum++;
                            }
                        }
                        Console.Write(string.Format("循环次数{1}，第{0}次替换排序：", i, forNum));
                        arrayWrite(array1);
                    }
                    break;
            }
        }
        /// <summary>
        /// 迭代输出数组内容
        /// </summary>
        /// <param name="array1">int 数组</param>
        private static void arrayWrite(int[] array1)
        {
            foreach (int ii in array1)
            {
                Console.Write(ii.ToString() + " ");
            }
            Console.WriteLine();
        }
    }
}

static void Main(string[] args)
        {
            //调用测试
            int[] arry = new int[] { 23, 45, 16, 7, 42, 2, 534, 123, 362, 34, 12, 632 };
            BubbleSort.sort(arry, BubbleSort.sortType.yi);
            BubbleSort.sort(arry, BubbleSort.sortType.er);
            BubbleSort.sort(arry, BubbleSort.sortType.san);
            Console.ReadKey();
        }