Bevezetés a C # rendezéséhez
A c # -ben történő rendezés a gyűjtemény tartalmának meghatározott sorrendbe rendezésének folyamata. A gyűjtemény lehet tömb, lista vagy bármilyen más adatcsoport. A gyűjtemény tartalmazhat egyszerű típusú és komplex elemeket. Egy egyszerű típus lehet egész számok, karakterláncok, lebegőpontos számok stb. Gyűjteménye. Komplex típus lehet a felhasználó által definiált típusok, például alkalmazott, hallgató stb. Objektumainak gyűjteménye. A komplex típusok többnyire nem egymásba ágyazottak, vagyis az objektumoknak több attribútumuk lehet.
Példák
- Egyszerű típus
- Egész számgyűjtemény - (1, 2, 3, 4, 5)
- Vonósok gyűjteménye - („Mark", "Jamie", "Anna")
- Komplex típus
- ((Név: “Mark”, Munkavállalói azonosító: “123”, Iroda: “London”),
(Név: “Jane”, Munkavállalói azonosító: “456”, Iroda: “NY”),
(Név: “Annie”, Munkavállalói azonosító: “789”, Iroda: “Sydney”))
- ((Név: “Mark”, Munkavállalói azonosító: “123”, Iroda: “London”),
A C # beépített módszereket nyújtott a gyűjtemények rendezésére. Legyen tömb, lista vagy bármilyen általános gyűjtemény, a C # Sort () módszer a megadott összehasonlító alapján rendezheti. Belsőleg a .Net megvalósítás a Quicksort algoritmust használja a gyűjtemények rendezéséhez a C # -ben. Erről bővebben tárgyalunk a cikk következő szakaszaiban.
Hogyan történik a szortírozás a C # -ben?
Mint korábban kifejtettük, a .Net keretrendszer a Quicksort megközelítést használja a C # gyűjtemény elemeinek rendezéséhez. Szóval, mi az a quicksort?
A Quicksort elválasztási és hódítási stratégiát követ. Ez azt jelenti, hogy a rendezési algoritmus kiválasztja a pivot elemet, és a tömböt a pivot elem alapján osztja fel. A csapnál kisebb elemeket előtte helyezik. A csapnál nagyobb elemek kerülnek utána. Ez biztosítja a forgó elem rendezését. Ezenkívül a tömb két elemre oszlik: a pivotnál kisebb elemekre és a pivotnál nagyobb elemekre. Ezután az algoritmus ugyanazt a megközelítést követi mindkét tömb esetében.
Ennek egy példája az alábbiakban látható.
Válogatott tömb - 18, 5, 16, 23, 50, 32
1. lépés (Pivot = 32) - 18, 5, 16, 23, 32, 50
2a lépés
Válogatott tömb - 18, 5, 16, 23
Pivot = 23
Részben rendezett tömb - 18, 5, 16, 23
2b lépés
Válogatott tömb - 50
Pivot = 50
Részben rendezett tömb - 50
3a lépés
Válogatott tömb - 18, 5, 16
Pivot = 16
Részben rendezett tömb - 5, 16, 18
Rendezett tömb - 5, 16, 18, 23, 32, 50
Így a Quicksortnak két kulcsfontosságú folyamata van - a pivot kiválasztása és a tömb particionálása. Az algoritmus megvalósítása a pivot kiválasztásától függ. Lehet, hogy az első elem, vagy az utolsó, vagy bármely véletlenszerű elem, vagy a tömb mediánja. Miután a partíció befejeződött és a pivot a megfelelő helyzetbe került, az algoritmust rekurzív módon fel kell hívni a particionált tömbökre, mindaddig, amíg minden elem rendezésre nem kerül.
Amikor a válogatást C # -ben végzik, akkor a stabil és instabil Quicksort fogalma lép fel. Stabil Quicksort esetén, ha két elem megegyezik, akkor megmarad az eredeti tömb sorrendje. Ellenkező esetben instabil gyorsaságban van. A C # megvalósítás instabil Quicksortot használ.
Rendezés típusai C # -ben
A cikk ebben a szakaszában elsősorban a C # két gyűjteményére összpontosítunk - Tömbök és Listák. Mélyen belemerülnénk a C # sorrendbe a tömbökbe és a listákba. A következő rész néhány példával megpróbálja ezt magyarázni.
1. Egy tömb rendezése C # -ben
Nézzük meg a tömb osztályozásának különböző módjait a C # -ben.
a. Alapértelmezett összehasonlító használata
Ez az alapértelmezett Sort () módszer. Ha egyetlen összehasonlítót sem adnak kifejezetten a módszerhez, akkor a C # az elemek rendezéséhez a növekvő sorrendet használja.
Kód:
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");
)
)
)
Kimenet:
b. Az Custom Comparer használata
Biztosíthatunk egyéni összehasonlítót is a Sort () módszerhez. Ez arra utasítja a C # fordítót, hogy az alapértelmezett helyett az egyéni összehasonlítót használja.
Egyéni összehasonlító létrehozásához be kell építenünk az Összehasonlítás () metódust az IComparer felületen. Az alábbi kód bemutatja, hogyan lehet létrehozni egy összehasonlítót, amely csökkenő sorrendben rendezi az elemeket.
Készítettünk egy osztályt, örököltük azt az IComparer felületről, megvalósítottuk az Összehasonlítás () módszert és felülbíráltuk az elemek csökkenő sorrendben történő összehasonlításához.
Kód:
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");
)
)
)
Kimenet:
c. Kulcs-érték párok használata
A C # lehetőséget kínál egy tömb rendezésére egy másik tömb kulcsértékei alapján. Az alábbi példa kulcs- és értékpárokat tartalmaz az emberek kereszt- és utóneveiben. Rendezzük őket mind utónév, mind utónév szerint a Sort () módszerrel.
Kód:
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));
)
)
)
Kimenet:
2. Egy lista rendezése C # -ben
Nézzük meg a C # -ben szereplő listák rendezésének különböző módjait.
Megjegyzés : A C # listájának használata, beleértve a System.Collections.Generic könyvtárat.a. Alapértelmezett összehasonlító használata
Ez az alapértelmezett sort () módszer. ha egyetlen összehasonlítót sem adunk kifejezetten a módszerhez, akkor a c # a növekvő sorrendet használja az elemek rendezéséhez.
Kód:
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");
)
)
)
Kimenet:
b. Az Custom Comparer használata
Biztosíthatunk saját egyedi összehasonlítót a sort () módszerhez is. Ez arra utasítja a c # fordítót, hogy az alapértelmezett helyett az egyéni összehasonlítót használja.
Egyéni összehasonlító létrehozásához be kell építenünk az Összehasonlítás () metódust az IComparer felületen. Az alábbi kód bemutatja, hogyan lehet létrehozni egy összehasonlítót, amely csökkenő sorrendbe rendezi az elemeket.
Készítettünk egy osztályt, örököltük azt az IComparer felületről, megvalósítottuk az Összehasonlítás () módszert és felülbíráltuk az elemek csökkenő sorrendben történő összehasonlításához.
Kód:
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");
)
)
)
Kimenet:
Komplex listatípusok rendezése
Az összetett listatípusok a felhasználó által meghatározott listák. Pontosabban: ezek a felhasználó által meghatározott osztályok objektumai. A felhasználó által definiált objektumok különféle primitív típusok keverékei. Nehéz összetett listát rendezni. A C # fordító elvárja, hogy minden egyes komplex osztály örököljön az IC összehasonlítható interfészről, és meghatározza az Összehasonlítás () módszert. Ez a módszer tartalmazza a lista elemeinek a válogatáshoz való összehasonlításának útmutatásait.
Az alábbi példában a Felhasználók által definiált alkalmazottak osztályt definiáljuk, és az alkalmazottak objektumait az azonosítók alapján rendezzük.
1. példa
Kód:
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);
)
)
)
Kimenet:
Most az a nyilvánvaló kérdés, amelyre jut eszembe jut, hogy mi van, ha a Munkavállalói osztály tárgyait valamilyen más tulajdonság alapján akarjuk rendezni? Ez lehetséges. Be kell valósítanunk az IComparer felületet. Vessen egy pillantást az alábbi példára, hogy megértsük.
2. példa
Kód:
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);
)
)
)
Kimenet:
Következtetés
Tehát ez a cikk mélyrehatóan ismerteti a gyűjtemények rendezését a C # -ben. Elsősorban a tömbökre és a listákra összpontosítottunk, mivel ezek a kettő kiterjed az összes primitív típusra is. Miután a C # szerinti válogatás fogalma nagyon jól megértett, a válogatás könnyen megvalósítható más gyűjteményekben, például felsorolásokban, szótárakban stb. A cikk kitöltése után ajánlott az MSDN dokumentációja felfedezni a C # szerinti rendezés további megvalósításait.
Ajánlott cikkek
Ez egy útmutató a C # szerinti rendezéshez. Itt tárgyaljuk a rendezési teljesítményt, a válogatás típusait, mint például a tömb és a lista, valamint a példákat és a kód megvalósítását. A következő cikkeket is megnézheti további információkért -
- Objektumok a C # -ben
- Hozzáférés-módosítók a C # -ben
- Bubble Sort of Java
- Mutatók a C # -ben
- Rendezés Pythonban
- Karakterlánc-tömb a JavaScript-ben
- Hasonlítható össze a Java példában Gyűjtemény interfész Java-ban
- Karakterláncok tömbje C funkciókkal
- Különböző példák a C # gyűjteményekről