Sissejuhatus Java sorteerimisse

  • Java-s sortimine tähendab põhimõtteliselt kuskil kindlas järjekorras salvestatud elementide rühma korraldamist, see järjekord võib olla nii tõusev kui ka langev. Reaalajas programmeerimisel on palju stsenaariume, kus on vaja elemente sorteerida, kuna see muudab vajalikuks ka otsimise konkreetne element on lihtne, kuna elemente saab sorteerimise korral massiivide indeksi abil hõlpsasti kätte. Elemente, mida tuleb sortida, saab salvestada nii massiivi kui ka kollektsiooni. Kogumikku on mitut tüüpi Java-tüüpi komplektides, puudes, kaardis, hunnikus, loendis jne. Ehkki on olemas ka erinevat tüüpi sortimisalgoritme, mida kasutatakse elementide sortimiseks massiivilaadses mullide sortimises, hunniku sortimises, lisamises sortimises, Valiku sortimine, liitmise sortimine jne.
  • Programmeerijad kasutavad elementide sorteerimiseks erinevaid algoritme vastavalt nende konkreetsetele nõudmistele ja algoritmide keerukusele. Neid sortimisalgoritme rakendatakse mitmesuguste silmuste ja muutujate abil selle iteratsiooniks. Lisaks sortimisalgoritmide kasutamisele massiivi elementide sortimiseks pakub Java ka sisseehitatud sortimisfunktsiooni, mis võib aidata ka samaga ning programmeerija ei pea olema suurte silmuste külge kinni jäänud ja mõtlema keerukusele. Jah, kuulsite õigesti, Java-s kasutatakse funktsiooni sortimine () massiividesse või kogumitesse salvestatud elementide sorteerimiseks ja o (n (logn)) väga väikse keerukusega elementide sortimiseks. Kuigi meetodi rakendamine mõlemas on pisut erinev.

Massiivide süntaks:

Arrays.sort(array_name);

Kollektsioonide jaoks

Collections.sort(array_name_list);

  • Massiivi_nimi ja massiivi_nimi_loend on siin massiivi või kollektsiooni nimi, mida tuleb sortida.
  • Massiivid on Java klasside nimed.
  • Kogumik on Java raamistik.
  • sort () on Java-s kasutatav sisseehitatud sortimisfunktsioon.

Kuidas Java-s sorteeritakse?

Järgnevad punktid on järgmised:

  • Sortimisalgoritmide kasutamise kaudu saab sorteerida ka algoritmidega, mis varieeruvad ebaefektiivsest efektiivseks ja igal algoritmil on oma aja- ja ruumi keerukus.
  • Mõnikord on need algoritmid väga keerulised ja neid ei saa kasutada reaalsetes stsenaariumides, kus on vaja käsitleda suuri andmemahte.
  • Nagu eespool mainitud, kasutatakse Java sisseehitatud funktsioonis sorti () sortimiseks massiivi ja kogumi kõiki elemente. Ametliku Java DOC andmetel kasutab Array.sort kiirsorti, mis on kahekordne pöördtelg ja suhteliselt palju kiirem kui ühe pöördenurgaga kiire sortimine.
  • Selle üks suurimaid eeliseid on see, et see annab O (n (logn)) keerukuse. See kasutab Merge Sordi massiivi objekti väga stabiilset ja iteratiivset teostust. Java pakub meetodit massiivi sortimiseks ka vastupidises järjekorras vastavalt programmeerija nõudele sorteerida kas kasvavas või kahanevas järjekorras. Kollektsiooni.reverseOrder () meetodit kasutatakse elementide sortimiseks vastupidises või kahanevas järjekorras.
  • Java 8 pakub ka võimalust massiivide sortimiseks paralleelselt, kasutades paralleelset sortimist, mis kasutab Java mitmekeelset kontseptsiooni ning jagab kogu massiivi osadeks ja liidab need pärast sortimist.

Sorteerimise tüübid Java-s

Allpool on toodud mõned viisid, kuidas sortimist Java-s sortimiseks saab teha:

1. sort (massiivi_nimi)

Seda kasutatakse kogu massiivi sorteerimiseks kasvavalt. Vaikimisi sorteerib see meetod massiivi elemendid kasvavas järjekorras.

Kood:

import java.util.Arrays;
public class SimpleSort
(
public static void main(String() args)
(
//Unsorted array of numbers
Integer() arr = new Integer() (100, 20, 10, 30, 80, 70, 90, 40, 50, 60);
//Sort function to sort the above array
Arrays.sort(arr);
//Printing the sorted array on console
System.out.println(Arrays.toString(arr));
)
)

Väljund:

2. Collection.reverseOrder ()

Seda Java meetodit kasutatakse massiivi sorteerimiseks vastupidises või kahanevas järjekorras. On stsenaariume, kus peame elemendid sorteerima kahanevas järjekorras ja Java teeb seda sisseehitatud meetodi abil.

Kood:

import java.util.Arrays;
public class ReverseSort
(
public static void main(String() args)
(
//Unsorted array of numbers
Integer() arr = new Integer() ( 100, 20, 10, 30, 80, 70, 90, 40, 50, 60);
//Sort function to sort the above array
Arrays.sort(arr, Collections.reverseOrder());
//Printing the sorted array on console
System.out.println(Arrays.toString(arr));
)
)

Väljund:

3. sortimine (int () massiivi_nimi, int findex, int lindex)

Kui kogu massiivi asemel on vaja sortida mõnda massiivi osa, pakub Java võimalust seda tüüpi massiivi sorteerida, määrates 3 parameetrit, st massiivi nimi, esimene register, kust sortimist tuleb alustada, ja viimane indekseerige, millal sortimine tuleb läbi viia.

Kood:

import java.util.Arrays;
public class ReverseSort
(
public static void main(String() args)
(
//Unsorted array of numbers
Integer() arr = new Integer() ( 100, 20, 10, 30, 80, 70, 90, 40, 50, 60);
//Sort function to sort the above array
Arrays.sort(arr, 1, 5);
//Printing the sorted array on console
System.out.println(Arrays.toString(arr));
)

Väljund:

4. Arrays.parllelSort (massiivi_nimi)

Java 8-st on välja antud uus paralleelse sortimise API. Põhimõtteliselt paralleelses sortimises jagatakse massiiv kaheks alammassiiviks ja seejärel täidab Array.sort () põhifunktsiooni eraldi niit. Seejärel liidetakse sorteeritud massiivid lõpuks lõpuni sorteeritud massiivi moodustamiseks. Seda tehakse mitme keermestamise kasutamise võimendamiseks.

Kood:

import java.util.Arrays;
public class ParallelSort
(
public static void main(String() args)
(
//Unsorted array of numbers
Integer() arr = new Integer() ( 100, 20, 10, 30, 80, 70, 90, 40, 50, 60);
//parallel Sort function to sort the above array
Arrays.parallelSort(arr);
//Printing the sorted array on console
System.out.println(Arrays.toString(arr));
)
)

Väljund:

Nagu tavaline Array.sort (), pakub ka Arrays.parallelSort () kindla massiivivahemiku sorteerimiseks või massiivi sorteerimiseks vastupidises järjekorras.

Süntaks:

// to Sort a range of array by parallelsort
Arrays.parallelSort(array_name, findex, lindex);
// to sort an array in reverse order using parallelSort
Arrays.parallelSort(array_name, Collections.reverseOder());

5. Kogumine.sort ()

Seda meetodit kasutatakse selliste kollektsioonide sorteerimiseks nagu nimekiri, kaart, komplekt jne. See kasutab liitmise sorteerimist ja annab sama keerukuse nagu Array.sort (), st O (n (logn)).

1. Loendi sortimine kasvavas järjekorras

Kood:

import java.util.Arrays;
import java.util.Collections;
public class ListSort
(
public static void main(String() args)
(
//Unsorted list
Integer() arr = new Integer() ( 100, 20, 10, 30, 80, 70, 90, 40, 50, 60 );
List arrList = Arrays.asList(arr);
//Sorting of list using the method
Collections.sort(arrList);
//Printing the list sorted above
System.out.println(arrList);
)
)

Väljund:

2. Massiiviloendi sortimine kahanevas järjekorras

Kood:

import java.util.Arrays;
import java.util.Collections;
public class ListSortRev
(
public static void main(String() args)
(
//Unsorted array list of Integers
Integer() arr = new Integer() (100, 20, 10, 30, 80, 70, 90, 40, 50, 60 );
List arrList = Arrays.asList(arr);
//Sorting of list using the method
Collections.sort(arrList);
//Printing the list sorted above
System.out.println(arrList);
)
)

Väljund:

3. Komplekti sorteerimine

Kollektsiooni „Komplekt” sortimisel ülaltoodud meetodil sorti (massiivi_nimi) on kolm põhireeglit:

    1. Teisendage komplekt loendiks.
    2. Sorteerige loend meetodit sortides (massiivi_nimi).
    3. Teisendage saadud sorteeritud loend tagasi seadeks.

Kood:

List numList = new ArrayList(num) ;
//Sorting the list retrieved above
Collections.sort(numList);
// Converting sorted List into Set
num = new LinkedHashSet(numList);
//Printing the Resulting Set on console
System.out.println(num);
)
)

Väljund:

4. Sorteeri kaart

Kogumiskaart Java-s on võtme ja väärtuse kombinatsioon. Nii saab sorteerida kahel viisil - võtme kaudu või väärtuse järgi.

  • Kaardi sortimine võtme järgi: vaatame allolevat näidet kaardi võtme järgi sortimise kohta.

Kood:

import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
public class SortHashKey
(
public static void main(String() args)
(
HashMap map = new HashMap();
map.put(80, "Akshay");
map.put(20, "Akash");
map.put(10, "Bob");
map.put(30, “Nitika");
map.put(90, "Yashi");
map.put(100, "Dragisa");
TreeMap treeMap = new TreeMap(map);
System.out.println(treeMap);
)
)

Väljund:

Üks lihtsamaid viise kaardi elementide sortimiseks võtme abil on sortimata kaardielementide lisamine TreeMapisse. TreeMap sorteerib elemendid automaatselt Hash Keys'i kasvavas järjekorras. Ehkki kogumist.sort () saab kasutada ka sama tegemiseks, on see mõnevõrra keeruline ja seda tuleb hästi kodeerida.

  • Kaardi sortimine väärtuse järgi: Allpool on toodud näide, kuidas kaardil sortimist saab teha väärtuse abil.

Kood:

import java.util.HashMap;
import java.util.Map;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.Map;
public class SortHashValue
(
public static void main(String() args)
(
HashMap map = new HashMap(); map.put(80, "Akshay");
map.put(20, "Akash");
map.put(10, "Bob");
map.put(30, “Nitika");
map.put(90, "Yashi");
map.put(100, "Dragisa");
LinkedHashMap sorted = new LinkedHashMap(); map.entrySet()
.stream()
.sorted(Map.Entry.comparingByValue())
.forEachOrdered(x -> sorted.put(x.getKey(), x.getValue()));

Väljund:

Ülaltoodud näites kaardi väärtuse järgi sortimise kohta seadsime esiteks kirjed kasutades map.entrySet () ja seejärel voogu nendest kirjetest oja () meetodil, kutsudes sorteeritud massiivi sorteeritud () meetodi abil, võrreldes väärtust jaotises paar. iga tellitud () kasutatakse voo liikumiseks tulemuse saamiseks.

5. võrreldav

Võrreldav on liides ja see muudab klassid võrreldavaks selle esinemisjuhtudega.

Sama klassi kahe esinemisjuhu võrdlemiseks tuleb kasutusele võtta võrreldav liides ja üle vaadata meetod salīdzTo (). Klassid, mis seda liidest rakendavad, ja selle objektide loend sorteeritakse automaatselt, kasutades meetodeid Collections.sort () ja Arrays.sort ().

Kood:

ArrayList list = new ArrayList();
// Adding the instance objects of class Employee in list
list.add(new Employee(10, "Akshay")));
list.add(new Employee(40, "Bob")));
list.add(new Employee(20, "Priyansh")));
list.add(new Employee(50, "Chandni")));
list.add(new Employee(70, "Yashi")));
Collections.sort(list);
// Printing the sorted list on Console
System.out.println(list);

Väljund:

Järeldus

Ülalpool on selgitatud Java-meetodite sorteerimist, mida Java-s kasutatakse massiivide ja kogude mitme stsenaariumi korral. Programmeerija peab meeles pidama, kuidas sort () meetodit tuleks kasutada eri kollektsiooni tüüpide jaoks. Java 8 abil saab sorteerimisliidese juurutamiseks sorteerida ka Lambdase kaudu, mis teeb sortimise lihtsamaks. Ehkki neid kõiki on natuke keeruline õppida, võib nendega hõlpsasti töötada, kui kõik Java põhimõisted, eriti andmevoogesitus, massiivid ja kogud on selged. Ehkki sortimisalgoritmid on igihaljad ja Java-sarnastes teistes programmeerimiskeeltes hõlpsasti rakendatavad, on nende keerukus erinev ja Java sisseehitatud funktsioonitüüp () muudab asja lihtsamaks, kui põhikontseptsioonid õpitakse südamest.

Soovitatavad artiklid

See on Java-sorteerimise juhend. Siin räägime sellest, kuidas sorteerimine Java-s toimib ja Java-sorteerimise tüübid erinevate koodide ja väljunditega. Lisateavet leiate ka meie muudest seotud artiklitest -

  1. JComboBox Java-s
  2. Sorteerimine C-s
  3. Hunnik Sorteeri C-s
  4. Mull Sorteeri JavaScriptis
  5. Mis on sortimine C ++ -s?
  6. Sissejuhatus PHP-s sorteerimisse
  7. Hunnik sorteerimine Pythonis
  8. Sisestus Sorteeri JavaScriptis
  9. Java Java-kaart
  10. Võrreldav Java näites | Kogumisliides Java-s

Kategooria: