帽泡排序

 

using  System;
using  System.Text;

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
    }
}