Cómo ordenar una array en C# | Conjunto de métodos Array.Sort() – 1

Posted on by Rudeus Greyrat

El método Array.Sort se utiliza para ordenar elementos en una array unidimensional. Hay 17 métodos en la lista de sobrecarga de este método de la siguiente manera:

  1. Ordenar<T>(T[]) Método
  2. Ordenar<T>(T[], IComparer<T>) Método
  3. Ordenar<T>(T[], Int32, Int32) Método
  4. Ordenar<T>(T[], Comparar<T>) Método
  5. Ordenar (Array, Int32, Int32, IComparer) Método
  6. Ordenar (Array, Array, Int32, Int32, IComparer) Método
  7. Ordenar (Array, Int32, Int32) Método
  8. Ordenar (Array, Array, Int32, Int32) Método
  9. Ordenar (Array, IComparer) Método
  10. Método Ordenar (Array, Array, IComparer)
  11. Ordenar (Array, Array) Método
  12. Método de clasificación (array)
  13. Ordenar<T>(T[], Int32, Int32, IComparer<T>) Método
  14. Ordenar<TKey,TValue>(TKey[], TValue[]) Método
  15. Ordenar<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Método
  16. Ordenar<TKey,TValue>(TKey[], TValue[], Int32, Int32) Método
  17. Ordenar<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) Método

Aquí discutiremos los primeros 4 métodos.

Ordenar<T>(T[]) Método

Este método ordena los elementos de un Array mediante la implementación de la interfaz genérica IComparable<T> de cada elemento del Array.

Sintaxis: public static void Sort<T> (array T[]);

Parámetro:
array: Es el Array unidimensional de base cero que se va a ordenar.

Excepciones:

  • ArgumentNullException: si la array es nula.
  • InvalidOperationException: si uno o más elementos de la array no implementan la interfaz genérica IComparable<T>.

Ejemplo:

// C# Program to illustrate the use 
// of the Array.Sort<T>(T[]) Method
using System;
using System.Collections.Generic;
  
class GFG {
  
    // Main Method
    public static void Main()
    {
        // array elements
        string[] arr = new string[5] { "A", 
                      "D", "X", "G", "M" };
  
        foreach(string g in arr)
        {
            Console.WriteLine(g);
            // display original array
        }
  
        Console.WriteLine("\nAfter Sort:");
        Array.Sort(arr);
  
        foreach(string g in arr)
        {
            Console.WriteLine(g);
            // display sorted array
        }
  
        Console.WriteLine("\nB sorts between :");
  
        // binary Search for "B"
        int index = Array.BinarySearch(arr, "B");
  
        // call "sortT" function
        // which is the Sort<T>(T[]) function
        sortT(arr, index);
          
        Console.WriteLine("\nF sorts between :");
        index = Array.BinarySearch(arr, "F");
        sortT(arr, index);
    }
  
    public static void sortT<T>(T[] arr, int index)
    {
  
        // If the index is negative, 
        // it represents the bitwise
        // complement of the next larger 
        // element in the array.
        if (index < 0) {
              
            index = ~index;
  
            if (index == 0)
                Console.Write("beginning of array");
            else
                Console.Write("{0} and ", arr[index - 1]);
  
            if (index == arr.Length)
                Console.WriteLine("end of array.");
            else
                Console.WriteLine("{0}", arr[index]);
        }
    }
}
Producción:

A
D
X
G
M

After Sort:
A
D
G
M
X

B sorts between :
A and D

F sorts between :
D and G

Ordenar<T>(T[], IComparer<T>) Método

Este método ordena los elementos de una array mediante la interfaz genérica IComparer<T> especificada .

Sintaxis: public static void Sort<T> (array T[], comparador System.Collections.Generic.IComparer<T>);

Parámetros:

  • T : Es el tipo de los elementos del arreglo.
  • array : Es el Array unidimensional que se va a ordenar.
  • comparer : es la implementación de la interfaz genérica IComparer<T> que se usa al comparar elementos o null para usar la implementación de la interfaz genérica IComparable<T> de cada elemento.

Excepciones:

  • ArgumentNullException: si la array es nula.
  • InvalidOperationException: si el comparador es nulo y no hay implementación de la interfaz genérica IComparable<T> .
  • ArgumentoExcepción:

    • Si la implementación de comparer provocó un error durante la ordenación.

Ejemplo:

// C# program to demonstrate the use of the 
// Array.Sort<T>(T[], IComparer<T>) method
using System;
using System.Collections.Generic;
  
public class GeeK : IComparer<string> {
  
    public int Compare(string x, string y)
    {
        // Compare x and y in reverse order.
        return x.CompareTo(y);
    }
}
  
class GFG {
  
    // Main Method
    public static void Main()
    {
        // array elements
        string[] arr = new string[5] {"A", 
                     "D", "X", "G", "M" };
  
        foreach(string g in arr)
        {
  
            // display original array
            Console.WriteLine(g);
        }
  
        Console.WriteLine("\nAfter Sort: ");
        GeeK gg = new GeeK();
  
        // Sort<T>(T[], IComparer<T>) method
        Array.Sort(arr, gg);
          
        foreach(string g in arr)
        {
            // display sorted array
            Console.WriteLine(g);
        }
  
        Console.WriteLine("\nD Sorts between :");
  
        // binary Search for "D"
        int index = Array.BinarySearch(arr, "D");
          
         // call "sortT" function
        sortT(arr, index);
         
        Console.WriteLine("\nF Sorts between :");
        index = Array.BinarySearch(arr, "F");
        sortT(arr, index);
    }
  
    public static void sortT<T>(T[]arr, int index)
    {
        if (index < 0)
        {
              
            // If the index is negative, 
            // it represents the bitwise
            // complement of the next 
            // larger element in the array.
            index = ~index;
  
            Console.Write("Not found. Sorts between: ");
  
            if (index == 0)
                Console.Write("Beginning of array and ");
            else
                Console.Write("{0} and ", arr[index-1]);
  
            if (index == arr.Length)
                Console.WriteLine("end of array.");
            else
                Console.WriteLine("{0}.", arr[index]);
        }
        else
        {
            Console.WriteLine("Found at index {0}.", index);
        }
    }
}
Producción:

A
D
X
G
M

After Sort: 
A
D
G
M
X

D Sorts between :
Found at index 1.

F Sorts between :
Not found. Sorts between: D and G.

Método Array.Sort<T>(T[], Int32, Int32)

Este método ordena los elementos en un rango de en un Array usando la implementación de la interfaz genérica IComparable<T> de cada elemento del Array.

Sintaxis: public static void Sort<T> (array T[], índice int, longitud int);

Parámetros:

  • array: es el Array unidimensional de base cero que se va a ordenar.
  • índice: Es el índice inicial del rango a ordenar.
  • longitud: Es el número de elementos del rango a ordenar.

Excepciones:

  • ArgumentNullException: si la array es nula.
  • ArgumentOutOfRangeException: si el índice es menor que el límite inferior de la array o la longitud es menor que cero.
  • ArgumentException: si el índice y la longitud no especifican un rango válido en la array.
  • InvalidOperationException: si uno o más elementos de la array no implementan la interfaz genérica IComparable<T> .

Ejemplo:

// C# program to demonstrate the use of
// Array.Sort<T>(T[], Int32, Int32) method
using System;
using System.Collections.Generic;
  
public class Geek : IComparer<string> {
  
    public int Compare(string x, string y)
    {
        // Compare y and x in reverse order.
        return y.CompareTo(x);
    }
}
  
public class Example {
  
    // Main Method
    public static void Main()
    {
        // Array elements
        string[] arr = {"AB", "CD", 
           "GH", "EF", "MN", "IJ"};
             
        Console.WriteLine("Original Array :");
          
        Display(arr);
  
        Console.WriteLine("\nSort the array between "+
                                      "index 1 to 4");
          
        // Array.Sort(T[], Int32, Int32) method
        // sort will happen in between
        // index 1 to 4
        Array.Sort(arr, 1, 4);
        Display(arr);
  
        Console.WriteLine("\nSort the array reversely"+
                           " in between index 1 to 4");
          
        // sort will happen in between
        // index 1 to 4 reversely          
        Array.Sort(arr, 1, 4, new Geek());
      
        Display(arr);
    }
  
    public static void Display(string[] arr)
    {
        foreach(string g in arr)
        {
            Console.WriteLine(g);
        }
    }
}
Producción:

Original Array :
AB
CD
GH
EF
MN
IJ

Sort the array between index 1 to 4
AB
CD
EF
GH
MN
IJ

Sort the array reversely in between index 1 to 4
AB
MN
GH
EF
CD
IJ

Array.Sort<T>(T[], Comparación<T>) Método

Este método ordena los elementos en un Array usando el Comparison<T> especificado.

Sintaxis: public static void Sort<T> (array T[], comparación Comparation<T>);

Parámetros:

  • array: Es el Array unidimensional de base cero que se va a ordenar.
  • comparación: es la comparación <T> que se utiliza al comparar elementos.

Excepciones:

  • ArgumentNullException : si la array es nula o la comparación es nula.
  • ArgumentException : si la implementación de la comparación provocó un error durante la ordenación.

Ejemplo:

// C# program to demonstrate the use of the 
// Array.Sort<T>(T[ ], Comparison<T>) Method
using System;
using System.Collections.Generic;
  
class GFG {
      
    private static int CompareComp(string x, string y)
    {
        if (y == null && x == null) {
              
            // If x and y is null
            // then x and y are same
            return 0;
        }
        else {
              
            // If x is null but y is not 
            // null then y is greater.
            return -1;
        }
    }
  
    // Main method
    public static void Main()
    {
        string[] arr = {"Java", "C++", "Scala",
                        "C", "Ruby", "Python"};
        
        Console.WriteLine("Original Array: ");
          
        // display original array
        Display(arr);
          
        Console.WriteLine("\nSort with Comparison: ");
  
        // Array.Sort<T>(T[], Comparison<T>)
        // Method
        Array.Sort(arr, CompareComp);
          
        // display sorted array
        Display(arr);
          
    }
  
    // Display function
    public static void Display(string[] arr)
    {
        foreach(string g in arr)
        {
            Console.WriteLine(g);
        }
    }
}
Producción:

Original Array: 
Java
C++
Scala
C
Ruby
Python

Sort with Comparison: 
Python
Ruby
C
Scala
C++
Java

Referencia:

Publicación traducida automáticamente

Artículo escrito por SoumikMondal y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *