Ordinamento in C # - Guida completa all'ordinamento in C # con esempi

• Introduzione all'ordinamento in C #

Introduzione all'ordinamento in C #

L'ordinamento in c # è il processo di organizzazione del contenuto di una raccolta in un ordine specifico. Una raccolta può essere una matrice, un elenco o qualsiasi altro gruppo di dati. La raccolta può contenere elementi di tipi semplici e tipi complessi. Un tipo semplice può essere una raccolta di numeri interi, stringhe, numeri in virgola mobile, ecc. Un tipo complesso può essere una raccolta di oggetti di tipi definiti dall'utente come Employee, Student, ecc. I tipi complessi sono più che spesso nidificati, il che significa gli oggetti possono avere più attributi.

Esempi

• Tipo semplice
  • Raccolta di numeri interi - (1, 2, 3, 4, 5)
  • Collezione di stringhe - ("Mark", "Jamie", "Anna")
• Tipo complesso
  • ((Nome: “Mark”, ID dipendente: “123”, Office: “London”),
    (Nome: "Jane", ID dipendente: "456", Ufficio: "NY"),
    (Nome: "Annie", ID dipendente: "789", Ufficio: "Sydney"))

C # ha fornito metodi integrati per ordinare le raccolte. Che si tratti di una matrice, di un elenco o di qualsiasi raccolta generica, il metodo C # Sort () può ordinarlo in base al comparatore fornito. Internamente, l'implementazione .Net utilizza l'algoritmo Quicksort per ordinare le raccolte in C #. Discuteremo di più su questo nelle sezioni successive dell'articolo.

Come viene eseguito l'ordinamento in C #?

Come affermato in precedenza, il framework .Net utilizza l'approccio Quicksort per ordinare gli elementi in una raccolta C #. Allora, cos'è quicksort?

Quicksort segue una strategia di divisione e conquista. Ciò significa che l'algoritmo di ordinamento seleziona un elemento pivot e divide l'array in base all'elemento pivot. Gli elementi più piccoli del perno vengono posizionati prima di esso. Gli elementi più grandi del perno vengono posizionati dopo di esso. Ciò garantisce che l'elemento pivot sia ordinato. Inoltre, l'array è diviso in due elementi più piccoli del perno e elementi più grandi del perno. Successivamente, l'algoritmo segue lo stesso approccio per entrambi gli array.

Un'illustrazione di questo può essere vista sotto.

Matrice non ordinata - 18, 5, 16, 23, 50, 32

Passaggio 1 (pivot = 32) - 18, 5, 16, 23, 32, 50

Passaggio 2a
Matrice non ordinata - 18, 5, 16, 23
Pivot = 23
Matrice parzialmente ordinata - 18, 5, 16, 23

Passaggio 2b
Matrice non ordinata - 50
Pivot = 50
Matrice parzialmente ordinata - 50

Passaggio 3a
Matrice non ordinata - 18, 5, 16
Pivot = 16
Matrice parzialmente ordinata - 5, 16, 18

Matrice ordinata - 5, 16, 18, 23, 32, 50

Pertanto, Quicksort ha due processi chiave: selezionare il pivot e partizionare l'array. Le implementazioni dell'algoritmo dipendono dalla selezione del pivot. Può essere il primo elemento o l'ultimo o qualsiasi elemento casuale o la mediana dell'array. Una volta eseguita la partizione e il perno è posizionato nella posizione corretta, l'algoritmo viene chiamato ricorsivamente per le matrici partizionate, fino a quando ogni elemento non viene ordinato.

Quando l'ordinamento viene eseguito in C #, arriva il concetto di Quicksort stabile e instabile. In un Quicksort stabile, se due elementi sono uguali viene conservato il loro ordine dall'array originale. Altrimenti, è in un quicksort instabile. L'implementazione di C # utilizza Quicksort instabile.

Tipi di ordinamento in C #

In questa sezione dell'articolo, ci concentreremo principalmente su due tipi di raccolte in C #: array e liste. Ci immergeremo nel modo in cui C # ordina gli array e le liste. La prossima sezione cercherebbe di spiegarlo con alcuni esempi.

1. Ordinamento di una matrice in C #

Esaminiamo i diversi modi in cui possiamo ordinare un array in C #.

un. Utilizzo del comparatore predefinito

Questo è il metodo Sort () predefinito. Se nessun comparatore viene esplicitamente passato al metodo, C # usa l'ordine crescente per disporre gli elementi.

Codice:

using System;
public class Program
(
public static void Main()
(
String() strArray = ("I", "Am", "Learning", "Array", "Sorting", "In", "C#");
int() intArray = (23, 76, 12, 43, 90, 30);
Array.Sort(strArray);
Array.Sort(intArray);
Console.WriteLine("Sorted String Array:\n");
DisplayArray(strArray);
Console.WriteLine("\n\n\nSorted Integer Array:\n");
DisplayArray(intArray);
)
static void DisplayArray(string() arr)
(
foreach (string a in arr)
(
Console.Write(a + "\t");
)
)
static void DisplayArray(int() arr)
(
foreach (int a in arr)
(
Console.Write(a + "\t");
)
)
)

Produzione:

b. Utilizzo del comparatore personalizzato

Possiamo anche fornire il nostro comparatore personalizzato al metodo Sort (). Ciò indicherebbe al compilatore C # di utilizzare il comparatore personalizzato anziché quello predefinito.

Per creare un comparatore personalizzato, dobbiamo implementare il metodo Compare () dall'interfaccia IComparer. Il codice seguente mostra come creare un comparatore che ordinerebbe gli elementi in ordine decrescente.

Abbiamo creato una classe, ereditata dall'interfaccia IComparer, implementato il metodo Compare () e sovrascritto per confrontare gli elementi in ordine decrescente.

Codice:

using System;
public class DescendingComparer : System.Collections.IComparer
(
public int Compare(Object a, Object b)
(
return (new System.Collections.CaseInsensitiveComparer()).Compare(b, a);
)
)
public class Program
(
public static void Main()
(
String() strArray = ("I", "Am", "Learning", "Array", "Sorting", "In", "C#");
int() intArray = (23, 76, 12, 43, 90, 30);
Array.Sort(strArray, new DescendingComparer());
Array.Sort(intArray, new DescendingComparer());
Console.WriteLine("Sorted String Array in Descending Order:\n");
DisplayArray(strArray);
Console.WriteLine("\n\n\nSorted Integer Array in Desc Order:\n");
DisplayArray(intArray);
)
static void DisplayArray(string() arr)
(
foreach (string a in arr)
(
Console.Write(a + "\t");
)
)
static void DisplayArray(int() arr)
(
foreach (int a in arr)
(
Console.Write(a + "\t");
)
)
)

Produzione:

c. Utilizzo di coppie chiave-valore

C # fornisce anche un modo per ordinare un array usando i valori chiave di un altro array. L'esempio seguente ha coppie chiave-valore di nomi e cognomi di persone. Li ordineremmo per nome e cognome usando il metodo Sort ().

Codice:

using System;
public class Program
(
public static void Main()
(
String() firstNames = ("Tom", "Jack", "Anna", "Veronica", "Jessica", "Mike");
String() lastNames = ("Phelps", "Anderson", "Spectre", "Clarke", "Williams", "Fonseca");
Array.Sort(firstNames, lastNames);
Console.WriteLine("Sorted by First Names:\n");
DisplayArray(firstNames, lastNames);
Array.Sort(lastNames, firstNames);
Console.WriteLine("\n\nSorted by Last Names:\n");
DisplayArray(firstNames, lastNames);
)
static void DisplayArray(string() arr1, string() arr2)
(
for (int i = 0; i < arr1.Length; i++)
(
Console.WriteLine(arr1(i) + " " + arr2(i));
)
)
)

Produzione:

2. Ordinamento di un elenco in C #

Esaminiamo i diversi modi in cui possiamo ordinare un elenco in C #.

Nota : per utilizzare gli elenchi in C #, inclusa la libreria System.Collections.Generic.

un. Utilizzo del comparatore predefinito

Questo è il metodo sort () predefinito. se nessun comparatore viene esplicitamente passato al metodo, c # usa l'ordine crescente per disporre gli elementi.

Codice:

public class Program
using System.Collections.Generic;
(
public static void Main()
(
String() strArray = ("I", "Am", "Learning", "Array", "Sorting", "In", "C#");
List strList = new List(strArray);
int() intArray = (23, 76, 12, 43, 90, 30);
List intList = new List(intArray);
strList.Sort();
intList.Sort();
Console.WriteLine("Sorted String List:\n");
DisplayList(strList);
Console.WriteLine("\n\n\nSorted Integer List:\n");
DisplayList(intList);
)
static void DisplayList(List myList)
(
foreach (string a in myList)
(
Console.Write(a + "\t");
)
)
static void DisplayList(List myList)
(
foreach (int a in myList)
(
Console.Write(a + "\t");
)
)
)

Produzione:

b. Utilizzo del comparatore personalizzato

Possiamo anche fornire il nostro comparatore personalizzato al metodo sort (). Questo dovrebbe indicare al compilatore c # di utilizzare il comparatore personalizzato anziché quello predefinito.

Per creare un comparatore personalizzato, dobbiamo implementare il metodo Compare () dall'interfaccia IComparer. Il codice seguente mostra come creare un comparatore che ordinerebbe gli elementi in ordine decrescente.

Abbiamo creato una classe, ereditata dall'interfaccia IComparer, implementato il metodo Compare () e sovrascritto per confrontare gli elementi in ordine decrescente.

Codice:

using System;
using System.Collections.Generic;
public class LengthComparer : IComparer
(
public int Compare(string a, string b)
(
return (a.Length.CompareTo(b.Length));
)
)
public class DigitSumComparer : IComparer
(
public int Compare(int a, int b)
(
int sum_a = 0;
int sum_b = 0;
while (a > 0)
(
sum_a += (a % 10);
a /= 10;
)
while (b > 0)
(
sum_b += (b % 10);
b /= 10;
)
return (sum_a.CompareTo(sum_b));
)
)
public class Program
(
public static void Main()
(
LengthComparer lc = new LengthComparer();
DigitSumComparer dsc = new DigitSumComparer();
String() strArray = ("I", "Am", "Learning", "Array", "Sorting", "In", "C#");
List strList = new List(strArray);
int() intArray = (23, 76, 12, 43, 90, 30);
List intList = new List(intArray);
strList.Sort(lc);
intList.Sort(dsc);
Console.WriteLine("Sorted String List by Length:\n");
DisplayList(strList);
Console.WriteLine("\n\n\nSorted Integer List by Sum of Digits:\n");
DisplayList(intList);
)
static void DisplayList(List myList)
(
foreach (string a in myList)
(
Console.Write(a + "\t");
)
)
static void DisplayList(List myList)
(
foreach (int a in myList)
(
Console.Write(a + "\t");
)
)
)

Produzione:

Ordinamento di tipi di elenchi complessi

I tipi di elenchi complessi sono elenchi definiti dall'utente. Per essere più precisi, sono elenchi di oggetti di classi definite dall'utente. Essendo definiti dall'utente, gli oggetti sono una miscela di vari tipi primitivi. È difficile ordinare un tipo di elenco complesso. Il compilatore C # prevede che ogni classe complessa erediti dall'interfaccia IComparable e definisca il metodo CompareTo (). Questo metodo contiene le istruzioni su come confrontare gli elementi dell'elenco per l'ordinamento.

Nell'esempio seguente, definiamo una classe di Dipendenti definita dall'utente e ordiniamo gli oggetti Dipendente in base ai loro ID.

Esempio 1

Codice:

using System;
using System.Collections.Generic;
public class Employee : IComparable
(
public int id (get;set;)
public string name(get;set;)
public double salary(get;set;)
public int CompareTo(Employee e)
(
return this.id.CompareTo(e.id);
)
)
public class Program
(
public static void Main()
(
List emps = new List();
emps.Add(new Employee()
(id = 123, name = "Tom Phelps", salary = 20000.00));
emps.Add(new Employee()
(id = 897, name = "Jack Anderson", salary = 40050.50));
emps.Add(new Employee()
(id = 342, name = "Anna Spectre", salary = 31030.89));
emps.Add(new Employee()
(id = 219, name = "Veronica Clarke", salary = 66333.66));
emps.Add(new Employee()
(id = 642, name = "Jessica Williams", salary = 50505.05));
emps.Add(new Employee()
(id = 923, name = "Mike Fonseca", salary = 76543.21));
Console.WriteLine("Original Employee List:\n");
DisplayList(emps);
emps.Sort();
Console.WriteLine("\n\nSorted Employee List by IDs:\n");
DisplayList(emps);
)
static void DisplayList(List emp)
(
foreach (Employee e in emp)
(
Console.WriteLine("Id: " + e.id + ", Name: " + e.name + ", Salary: " + e.salary);
)
)
)

Produzione:

Ora, l'ovvia domanda che mi viene in mente è che cosa succede se vogliamo ordinare gli oggetti della classe Employee in base a qualche altra proprietà? Questo è possibile. Dovremmo implementare l'interfaccia IComparer. Diamo un'occhiata all'esempio seguente per capire.

Esempio n. 2

Codice:

using System;
using System.Collections.Generic;
public class Employee
(
public int id (get;set;)
public string name(get;set;)
public double salary(get;set;)
)
public class SortByName : IComparer
(
public int Compare(Employee e1, Employee e2)
(
return e1.name.CompareTo(e2.name);
)
)
public class SortBySalary : IComparer
(
public int Compare(Employee e1, Employee e2)
(
return e1.salary.CompareTo(e2.salary);
)
)
public class Program
(
public static void Main()
(
SortByName sbn = new SortByName();
SortBySalary sbs = new SortBySalary();
List emps = new List();
emps.Add(new Employee()
(id = 123, name = "Tom Phelps", salary = 20000.00));
emps.Add(new Employee()
(id = 897, name = "Jack Anderson", salary = 40050.50));
emps.Add(new Employee()
(id = 342, name = "Anna Spectre", salary = 31030.89));
emps.Add(new Employee()
(id = 219, name = "Veronica Clarke", salary = 66333.66));
emps.Add(new Employee()
(id = 642, name = "Jessica Williams", salary = 50505.05));
emps.Add(new Employee()
(id = 923, name = "Mike Fonseca", salary = 76543.21));
emps.Sort(sbn);
Console.WriteLine("Sorted Employee List by Names:\n");
DisplayList(emps);
emps.Sort(sbs);
Console.WriteLine("\n\nSorted Employee List by Salaries:\n");
DisplayList(emps);
)
static void DisplayList(List emp)
(
foreach (Employee e in emp)
(
Console.WriteLine("Id: " + e.id + ", Name: " + e.name + ", Salary: " + e.salary);
)
)
)

Produzione:

Conclusione

Quindi, questo articolo ha approfondito come ordinare le raccolte in C #. Ci siamo concentrati principalmente su array ed elenchi poiché questi due coprono anche tutti i tipi primitivi. Una volta compreso il concetto di ordinamento in C #, diventa facile implementare l'ordinamento in altre raccolte come enumerazioni, dizionari, ecc. Dopo aver completato questo articolo, si consiglia di esplorare la documentazione MSDN per ulteriori implementazioni di ordinamento in C #.

Articoli consigliati

Questa è una guida all'ordinamento in C #. Qui discutiamo le prestazioni di ordinamento, i tipi di ordinamento come array ed elenco insieme agli esempi e all'implementazione del codice. Puoi anche consultare i seguenti articoli per saperne di più -

1. Oggetti in C #
2. Modificatori di accesso in C #
3. Bubble Sort in Java
4. Puntatori in C #
5. Ordinamento in Python
6. Array di stringhe in JavaScript
7. Paragonabile in Java Esempio | Interfaccia di raccolta in Java
8. Matrice di stringhe in C con funzioni
9. Diversi esempi di raccolte in C #