用委托泛型实现通用类型的冒泡排序

一、普通冒泡排序

　　冒泡排序想必大家都不陌生，原理也就不介绍了，直接看代码吧

　　（1）第一种

static void Sort(int[] unsorted)
      {
          for (int i = 0; i < unsorted.Length-1; i++)
          {
              for (int j = 0; j < unsorted.Length-i-1; j++)
              {
                  if (unsorted[j] > unsorted[j+1])
                  {
                      int temp = unsorted[j];
                      unsorted[j] = unsorted[j+1];
                      unsorted[j+1] = temp;
                  }
              }
          }
      }　

　

　　(2)第二种（与第一种并没有本质的区别，只不过加了一个标识位，当检索一遍发现没有交换时便停止循环，可以稍微提高下效率吧）　

static void Main(string[] args)
        {
            int[] array = new int[] { 1,23,23,14,14,24,25,525,66};
            Sort(array);
            foreach (var item in array)
            {
                Console.Write(item+" ");
            }
        }

        //从小到大排序
        static void Sort(int[] sortArray)
        { 
            bool isChange = true;
            do
            {
                isChange = false;
                for (int i = 0; i < sortArray.Length-1; i++)
                {
                    if (sortArray[i] > sortArray[i + 1])
                    {
                        int temp = sortArray[i];
                        sortArray[i] = sortArray[i + 1];
                        sortArray[i + 1] = temp;
                        isChange = true;
                    }
                }

            } while (isChange);
        }
    

二、通用类型冒泡排序

　　这里我们对一个Hero类进行排序（根据Hero中的attack属性），Compare方法由Hero类本身实现，方便委托

　　Hero类如下：

public class Hero
    {
        string Name { get; set; }
        int attack { get; set; }
        float speed { get; set; }
        Hero(string name,int attack,float speed=10f)
        {
            this.Name = name;
            this.attack = attack;
        }

        //h1的attack大于h2的attack返回true 否则返回false
        public static bool Compare(Hero h1, Hero h2)
        {
            if (h1.attack > h2.attack)
                return true;
        }
    }

　　

　　排序方法为Sort<T>(T[] sortArray,Func<T,T,bool> Compare)，比较采用Func委托

　　具体实现如下：

static void Sort<T>(T[] sortArray,Func<T,T,bool> Compare)
        {
            bool isChange = true;
            do
            {
                isChange = false;
                for (int i = 0; i < sortArray.Length - 1; i++)
                {
                    if (Compare(sortArray[i],sortArray[i+1]))
                    {
                        T temp = sortArray[i];
                        sortArray[i] = sortArray[i + 1];
                        sortArray[i + 1] = temp;
                        isChange = true;
                    }
                }

            } while (isChange);
        }

 　　

static void Main(string[] args)
        {
            Hero[] heroArray = new Hero[]
            {
                new Hero("a",12),
                new Hero("s",2),
                new Hero("d",144),
                new Hero("f",15),
                new Hero("g",6),
                new Hero("w",0),
            };
            Sort<Hero>(heroArray, Hero.Compare);
            foreach (var item in heroArray)
            {
                Console.WriteLine(item.ToString());
            }
            Console.ReadKey();
        }

其中Hero类中重写了ToString（）方法方便输出

public override string ToString()
        {
            return "name:"+this.Name+" attack:"+this.attack+" speed:"+this.speed;
        }

输出结果如下：