Extensión de ordenación de burbujas y delegado de C #

1. Principio de clasificación de burbujas

1. Suponga que hay una fila de matrices. Empezando por la primera, compárela con el siguiente número. Si el siguiente número es menor que este número, intercambie las posiciones de los dos números.

2. Entonces, el segundo número debe ser mayor que el primer número. Luego continúe comparando el segundo número con el tercer número, realice el mismo intercambio y repita el proceso hasta n veces.

3. Después de comparar n veces, se puede saber que el número de la enésima posición debe ser el mayor. Continúe repitiendo los pasos 1, 2 anteriores, esta vez no es necesario comparar el n-1 con el n, porque se sabe que el n es el más grande en el paso anterior. A partir de esto, se puede inferir que la complejidad de la clasificación de burbujas es (1 + 2 + 3 + …… + n) en notación Big O, que es O (n2)

2. Optimización de la clasificación de burbujas

En el proceso de comparación, suponga que una matriz es 21345678. En este momento, el ciclo externo solo se ha realizado 3 veces. De acuerdo con la verdad, debe realizarse 4 veces. A partir de los datos, se puede encontrar que solo debe realizarse de nuevo para combinar 2 y 1 La posición se puede invertir, y las 3 veces restantes son operaciones de comparación completamente redundantes.

Puede agregar una bandera bool al bucle externo. Cuando se encuentre que un bucle interno solo se ha comparado sin intercambio, saltará del bucle externo. el código se muestra a continuación

   //冒泡排序算法
        public static void buddle(int[] arrays)
        {
            //冒泡优化
            for (int i = 0; i < arrays.Length; i++)
            {
                bool isChange = false;
                for (int j = 0; j < arrays.Length - i - 1; j++)
                {
                    if (arrays[j] > arrays[j + 1])
                    {
                        int temp;
                        temp = arrays[j];
                        arrays[j] = arrays[j + 1];
                        arrays[j + 1] = temp;
                        isChange = true;
                    }
                }
                if (!isChange)
                {
                    break;
                }
            }
        }

3. Orden de burbuja de extensión genérica + delegada

La clasificación de burbujas anterior solo puede clasificar números y no puede comparar tipos arbitrarios. Para comparar objetos de cualquier tipo, necesita genérico + delegado para ampliar el algoritmo de clasificación de burbujas.

Mejorar el algoritmo genérico + delegación:

 public static void CommonBuddle<T>(T[] dataArrays, Func<T, T, bool> compareFuc)
        {
            //冒泡优化
            for (int i = 0; i < dataArrays.Length; i++)
            {
                bool isChange = false;
                for (int j = 0; j < dataArrays.Length - i - 1; j++)
                {
                    if (compareFuc(dataArrays[j], dataArrays[j + 1]))
                    {
                        T temp;
                        temp = dataArrays[j];
                        dataArrays[j] = dataArrays[j + 1];
                        dataArrays[j + 1] = temp;
                        isChange = true;
                    }
                }
                if (!isChange)
                {
                    break;
                }
            }
        }

Categoría de personal:

   public class Employ
    {
        public string Name { get; private set; }
        public int Salary { get; private set; }
        public Employ(string name, int salary)
        {
            this.Name = name;
            this.Salary = salary;
        }
        public static bool compareFuc(Employ a, Employ b)
        {
            //比较两个员工的工资大小
            if (a.Salary > b.Salary) return true;
            return false;
        }
        public override string ToString()
        {
            return Name + ":" + Salary;
        }
    }

prueba:

  public static Employ[] employs = new Employ[]
        {
            new Employ("lei",12),
            new Employ("ledi",34),
            new Employ("lefi",564),
            new Employ("leig",23),
            new Employ("leri",4),
            new Employ("lhei",9),
            new Employ("lhei",45),
        };
        public static void Main(string[] args)
        {
            buddle(arrays);
            for (int i = 0; i < arrays.Length; i++)
            {
                Console.WriteLine(arrays[i]);
            }

            CommonBuddle<Employ>(employs, Employ.compareFuc);

            foreach(var emply in employs)
            {
                Console.WriteLine(emply);
            }

            Console.ReadKey();
        }