冒泡排序使用泛型委托方法的实现

冒泡排序相信大家都已经都熟悉了，那这篇文章用委托方法写一篇不一样的冒泡排序

冒泡排序

首先，我们先看一下正常的冒泡排序，一般是针对与int型数组来的，
冒泡排序就是将数组的第一个与第二个进行比较，如果第一个大于第二个，则两数交换，然后在判断第二个与第三个进行比较，以此类推，比较到最后一个的时候，那么最后一个数就是整个数组的最大值。如果发现我们从第一个一直到最后一个值比较后都没有发生交换，那么就说明该数组就是一个有序的数组。我们用 swapped 当作为标识，若 swapped == false，则直接跳出循环。看下面代码

static void Sort(int[] array)
{
    bool swapped = true;
    do
    {
        swapped = false;
        for(int i = 0; i < array.Length -1; i++)
        {
            if (array[i] > array[i + 1])
            {
                int temp = array[i];
                array[i] = array[i + 1];
                array[i + 1] = temp;
                swapped = true;
            }
        }
    } while (swapped);

}

上面的代码就是一个普通的冒泡排序的核心代码，当我们执行下面代码的时候，则会输出一个有序的数据组

int[] array = new int[] { 1, 3, 23, 455, 2, 34, 21, 77 };
Sort(array);
foreach (var temp in array)
{
    Console.WriteLine(temp);
}

1
2
3
21
23
34
77
455

冒泡的泛型委托实现

当我们在执行一个类的比较时（如：员工的工资），就不会是这样的纯数字，它将会是一个对象，那么我们对对象数组进行比较的时候，就需要两个知识点，一个是泛型，一个是委托
首先，我们要在创建一个泛型的函数，其中有两个参数，第一个是对象数组，第二个是Func泛型参数

> static void CommonSort<T>(T[] array, Func<T, T, bool> method)
其次我们在常规的冒泡排序比较的时候，是使用 array[i] > array[i + 1]， 但是这里的话，则需要使用委托的方法比较 method(array[i] , array[i + 1]),而因此，在比较对象类中则需要定义一个与Func相符合的函数。我么这里定义是这样的

public static bool Compoment(Employee employee1, Employee employee1)
{
	return employee1.Employ > employee2.Employ;
}

函数体内可以按照要比较的内容写就行。注意，这里是定义一个静态的static方法，之后，核心代码就可以这样写

static void CommonSort<T>(T[] array, Func<T, T, bool> method)
{
    bool swapped = true;
    do
    {
        swapped = false;
        for (int i = 0; i < array.Length -1; i++)
        {
            if (method(array[i], array[i + 1]))
            {
                T temp = array[i];
                array[i] = array[i + 1];
                array[i + 1] = temp;
                swapped = true;
            }
        }
    } while (swapped);

}

对象类：

class Employee
{
     public string Name{get; private set;}
     public int Employ { get; private set; }

     public Employee(string name, int employ)
     {
         this.Name = name;
         this.Employ = employ;
     }
     public static bool Compare(Employee employee1, Employee employee2)
     {
         return employee1.Employ > employee2.Employ;
     }
 }

输出测试：

Employee[] array = new Employee[]
{
     new Employee("name111", 111),
     new Employee("name222", 222),
     new Employee("name666", 666),
     new Employee("name453", 453),
     new Employee("name678", 678),
     new Employee("name342", 342),
 };

 CommonSort<Employee>(array, Employee.Compare);

 foreach (Employee temp in array)
 {
     Console.WriteLine(temp);
 }

这样写的时候，我们会发现输出是这样的：
SortStudy.Employee
SortStudy.Employee
SortStudy.Employee
SortStudy.Employee
SortStudy.Employee
SortStudy.Employee

这是因为我们在 WriteLine一个对象的时候，会输出项目下的类名。Console.WriteLine(temp);
这样输出就是相当于输出了temp.ToString(),Console.WriteLine(temp.ToString());,所以，我么要重写toString()方法

public override string ToString()
{
	return this.Name + ":" + this.Employ
}

这样再次调用**Console.WriteLine(temp);**就会正常了，输出如下：
name111:111
name222:222
name342:342
name453:453
name666:666
name678:678