学步园

namespace Chapter35
{
    enum SortType
    {
        ASC,  //正序 A-Z
        DESC  //到序 Z-A
    }

    class BubbleSort
    {
        # region 字段
        // 表示排序类型的私有字段
        private SortType order;
        // 表示排序数组的私有字段
        private int[] list;
        // 表示迭代次数的私有字段
        private int iterateCount;
        # endregion

        # region 属性
        // 表示排序类型的属性，可读可写
        public SortType Order
        {
            get { return order; }
            set { order = value; }
        }
        // 表示排序数组的属性，可读可写
        public int[] List
        {
            get { return list; }
            set { list = value; }
        }
        // 表示迭代次数的属性，只读
        public int IterateCount
        {
            get { return iterateCount; }
        }
        # endregion

        # region 构造方法
        // 没有任何参数的构造方法
        public BubbleSort()
        {
            order = SortType.ASC;
        }
        // 带有一个参数的重载构造方法
        public BubbleSort(int[] arr)
        {
            list = arr;
            order = SortType.ASC;
        }
        // 带有两个参数的重载构造方法
        public BubbleSort(int[] arr, SortType type)
        {
            list = arr;
            order = type;
        }
        # endregion

        # region 私有方法
        // 用于交换两个变量私有方法
        private void Swap(ref int a, ref int b)
        {
            int c = a;
            a = b;
            b = c;
        }
        # endregion

        # region 公有方法
        // 用于排序操作的公有方法
        public void Sort()
        {
            bool isOK = false;
            iterateCount = 0;
            while (!isOK)
            {
                isOK = true;
                for (int i = 0; i < list.Length - 1; i++)
                {
                    iterateCount++;
                    switch (order)
                    {
                        case SortType.ASC:
                            {
                                if (list[i] > list[i + 1])
                                {
                                    Swap(ref list[i], ref list[i + 1]);
                                    isOK = false;
                                }
                                break;
                            }
                        case SortType.DESC:
                            {
                                if (list[i] < list[i + 1])
                                {
                                    Swap(ref list[i], ref list[i + 1]);
                                    isOK = false;
                                }
                                break;
                            }
                    }
                }
            }
        }
        // 用于把字符数组转化为字符串的公有方法
        public string GetDataString()
        {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < list.Length; i++)
                sb.Append(list[i]);
            return sb.ToString();
        }
        // 用于把字符数组转化为字符串的公有重载方法，接受一个字符串参数作为分割符
        public string GetDataString(string separator)
        {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < list.Length; i++)
            {
                sb.Append(list[i]);
                sb.Append(separator);
            }
            sb.Remove(sb.Length - separator.Length, separator.Length);
            return sb.ToString();
        }
        # endregion
    }
}