Introducere în sortarea în C #
Sortarea în c # este procesul de aranjare a conținutului unei colecții într-o ordine specifică. O colecție poate fi un tablou, o listă sau orice alt grup de date. Colecția poate conține elemente de tipuri simple, precum și tipuri complexe. Un tip simplu poate fi o colecție de numere întregi, șiruri, numere în virgulă flotantă etc. Un tip complex poate fi o colecție de obiecte de tipuri definite de utilizator, cum ar fi Angajat, Student etc. obiectele pot avea multiple atribute.
Exemple
- Tip simplu
- Colecție întreagă - (1, 2, 3, 4, 5)
- Colecția de coarde - („Mark”, „Jamie”, „Anna”)
- Tip complex
- ((Nume: „Marcă”, ID-ul angajatului: „123”, Birou: „Londra”),
(Nume: „Jane”, ID-ul angajatului: „456”, Birou: „NY”),
(Nume: „Annie”, ID angajat: „789”, Birou: „Sydney”))
- ((Nume: „Marcă”, ID-ul angajatului: „123”, Birou: „Londra”),
C # a furnizat metode încorporate pentru sortarea colecțiilor. Fie că este o Array, List sau orice colecție generică, metoda C # Sort () o poate sorta în funcție de Comparatorul furnizat. Pe plan intern, implementarea .Net utilizează algoritmul Quicksort pentru a sorta colecțiile în C #. Vom discuta mai multe despre acest lucru în secțiunile următoare ale articolului.
Cum se realizează sortarea în C #?
După cum am menționat anterior, cadrul .Net utilizează abordarea Quicksort pentru a sorta elementele dintr-o colecție C #. Deci, ce este quicksort?
Quicksort urmează o strategie de divizare și cucerire. Aceasta înseamnă că algoritmul de sortare selectează un element pivot și împarte tabloul în funcție de elementul pivot. Elementele mai mici decât pivotul sunt plasate înaintea acestuia. Elementele mai mari decât pivotul sunt plasate după el. Acest lucru asigură că elementul pivot este sortat. De asemenea, tabloul este împărțit în două - elemente mai mici decât pivot și elemente mai mari decât pivotul. În continuare, algoritmul urmărește aceeași abordare pentru ambele tablouri.
O ilustrare a acestui lucru poate fi văzută mai jos.
Arhivă nesortată - 18, 5, 16, 23, 50, 32
Pasul 1 (pivot = 32) - 18, 5, 16, 23, 32, 50
Etapa 2a
Arhivă nesortată - 18, 5, 16, 23
Pivot = 23
Parțial sortat parțial - 18, 5, 16, 23
Etapa 2b
Matricea nesortată - 50
Pivot = 50
Arie parțial sortată - 50
Etapa 3a
Arhivă nesortată - 18, 5, 16
Pivot = 16
Matrice parțial sortată - 5, 16, 18
Array Sorted - 5, 16, 18, 23, 32, 50
Astfel, Quicksort are două procese cheie - selectarea pivotului și partiționarea tabloului. Implementările algoritmului depind de selectarea pivotului. Poate fi fie primul element, fie ultimul, fie orice element aleatoriu, sau mediana tabloului. Odată ce partiția este terminată și pivotul este plasat în poziția corectă, algoritmul este apelat recursiv pentru tablele partiționate, până la sortarea fiecărui element.
Când sortarea se face în C #, vine conceptul de Quicksort stabil și instabil. Într-un Quicksort stabil, dacă două elemente sunt egale, ordinea lor din tabloul original este păstrată. În caz contrar, este într-un quicksort instabil. Implementarea C # folosește Quicksort instabilă.
Tipuri de sortare în C #
În această secțiune a articolului, ne-am concentra în principal pe două tipuri de colecții în C # - Schițe și Liste. Ne-am arunca în profunzime în modul în care C # sortează tablourile și listele. Următoarea secțiune ar încerca să o explice cu câteva exemple.
1. Sortarea unei Array în C #
Să ne uităm la diferitele moduri în care putem sorta un tablou în C #.
A. Utilizarea comparatorului implicit
Aceasta este metoda implicită Sort (). Dacă nu există un comparator în mod explicit la metodă, C # folosește ordinea ascendentă pentru a aranja elementele.
Cod:
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");
)
)
)
ieşire:
b. Utilizarea comparatorului personalizat
De asemenea, putem oferi propria noastră comparație personalizată în metoda Sort (). Acest lucru ar instrui compilatorul C # să utilizeze comparatorul personalizat în locul celui implicit.
Pentru a crea un comparator personalizat, trebuie să implementăm metoda Compare () din interfața IComparer. Codul de mai jos demonstrează modul de a crea un comparator care să ordone elementele în ordine descrescătoare.
Am creat o clasă, am moștenit-o de la interfața IComparer, am implementat metoda Compare () și am anulat-o pentru a compara elementele în ordine descrescătoare.
Cod:
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");
)
)
)
ieşire:
c. Utilizarea perechilor cheie-valoare
C # oferă, de asemenea, o modalitate de a sorta un tablou folosind valorile cheie dintr-un alt tablou. Exemplul de mai jos include perechi de nume cheie și nume de nume. Le-am sorta după nume și prenume folosind metoda Sort ().
Cod:
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));
)
)
)
ieşire:
2. Sortarea listei în C #
Să ne uităm la diferitele moduri în care putem sorta o listă în C #.
Notă - Pentru a utiliza Liste în C #, inclusiv biblioteca System.Collections.Generic.A. Utilizarea comparatorului implicit
Aceasta este metoda implicită sort (). dacă niciun comparator nu este trecut în mod explicit la metodă, c # folosește ordinea ascendentă pentru a aranja elementele.
Cod:
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");
)
)
)
ieşire:
b. Utilizarea comparatorului personalizat
De asemenea, putem oferi propriul nostru comparator personalizat cu metoda sort (). Acest lucru ar instrui compilatorul c # să utilizeze comparatorul personalizat în locul celui implicit.
Pentru a crea un comparator personalizat, trebuie să implementăm metoda Compare () din interfața IComparer. Codul de mai jos demonstrează modul de a crea un comparator care să ordone elementele în ordine descrescătoare.
Am creat o clasă, am moștenit-o de la interfața IComparer, am implementat metoda Compare () și am anulat-o pentru a compara elementele în ordine descrescătoare.
Cod:
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");
)
)
)
ieşire:
Sortarea tipurilor de liste complexe
Tipurile de liste complexe sunt liste definite de utilizator. Pentru a fi mai precise, acestea sunt liste de obiecte din clase definite de utilizator. Fiind definite de utilizator, obiectele sunt un amestec de diferite tipuri primitive. Este dificil să sortăm un tip de listă complexă. Compilatorul C # se așteaptă ca fiecare clasă complexă să moștenească de la interfața IComparabilă și să definească metoda CompareTo (). Această metodă conține instrucțiuni despre compararea elementelor listei pentru sortare.
În exemplul de mai jos, definim o clasă de angajați definită de utilizator și sortăm obiectele Angajat pe baza ID-urilor lor.
Exemplul # 1
Cod:
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);
)
)
)
ieşire:
Acum, întrebarea evidentă care îmi vine în minte este că dacă ne dorim să sortăm obiectele clasei de angajați pe baza unei alte proprietăți? Este posibil. Ar trebui să implementăm interfața IComparer. Să aruncăm o privire la exemplul de mai jos pentru a înțelege.
Exemplul # 2
Cod:
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);
)
)
)
ieşire:
Concluzie
Deci, acest articol a abordat în detaliu modul de sortare a colecțiilor în C #. Ne-am concentrat în principal pe Schițe și Liste, deoarece aceste două acoperă și toate tipurile primitive. Odată ce conceptul de Sortare în C # este foarte bine înțeles, devine ușor de implementat sortarea în alte colecții, cum ar fi Enumerații, Dicționare, etc. După completarea acestui articol, se recomandă să explorați documentația MSDN pentru mai multe implementări de Sortare în C #.
Articole recomandate
Acesta este un ghid pentru sortarea în C #. Aici discutăm performanțele de sortare, tipurile de sortare cum ar fi tabloul și lista împreună cu exemplele și implementarea codului. De asemenea, puteți consulta următoarele articole pentru a afla mai multe -
- Obiecte din C #
- Modificatori de acces în C #
- Sortare cu bule în Java
- Punctele în C #
- Sortare în Python
- Stray Array în JavaScript
- Comparabil în Exemplu Java | Interfață de colectare în Java
- Șiruri Array în C cu funcții
- Exemple diferite de colecții în C #