Kuidas kasutada C ++ järjekorda

Sissejuhatus

Järjekord on üksuste kogu, kus esimene loendisse lisatud üksus peab olema esimene eemaldatav üksus järgmisena. Nii et kui esemeid kollektsiooni lisatakse, kasvab selle suurus, s.t.e. selle pikkus kasvab. Alati, kui mõni üksus eemaldatakse, tuleb see esimene lisada. Kui üksusi eemaldatakse pidevalt, siis järgmine on eemaldatud üksus; kolmas eemaldatakse pärast seda jne.

Pärast algse loendi esimese üksuse eemaldamist saab teisest esimene üksus. Pärast teise üksuse eemaldamist saab kolmandast esimene element jne.

Hea näide reaalelust on see, kui inimesed seisavad rivis, et teenust või head oodata. Esimest inimest serveeritakse enne viimast. Selles õpetuses räägitav järjekord on aga tarkvara järjekord, nagu see on kavandatud C-s++.

FIFO

FIFO tähistab First-In, First-Out. See on järjekordse hindamise viis. See tähendab, et esimene loendisse kantud element on esimene eemaldatav element alati, kui eemaldamine toimub. Loendi algust nimetatakse peaks või esiküljeks; loendi lõppu nimetatakse tagumiseks või sabaks.

Olulised toimingud

Tarkvarajärjekorras peavad olema vähemalt järgmised toimingud:

suruma

See toiming lisab järjekorra taha uue elemendi. Seda operatsiooni nimetatakse ametlikult enqueue.

vahetustega

See toiming eemaldab järjekorra esimese elemendi ja teisest elemendist saab esimene esimene. Seda operatsiooni nimetatakse ametlikult dequeue'ks. Seda nimetatakse C-s popiks++.

Selles artiklis selgitatakse, kuidas kasutada C ++ järjekorra andmestruktuuri. Selle artikli ülejäänud mõistmiseks peaksite teadma C ++ viiteid ja viiteid.

Klass ja objektid

Klass on koos töötavate muutujate ja funktsioonide kogum, kus muutujatel pole väärtusi määratud. Kui muutujatele määratakse väärtused, saab klass objektiks. Samale klassile antud erinevad väärtused toovad kaasa erinevad objektid; see tähendab, et erinevad objektid on sama klass, millel on erinevad väärtused. Klassist objekti loomine öeldakse, et see kiirendab objekti.

Nimi, järjekord, on klass. Järjeklassist loodud objektil on programmeerija valitud nimi.

Klassile kuuluva funktsiooni olemasolu on vajalik objekti klassist kiirendamiseks. C ++ versioonis on sellel funktsioonil sama nimi kui klassi nimel. Klassist loodud (instantsitud) objektidel on programmeerija poolt antud erinevad nimed.

Klassist objekti loomine tähendab objekti ehitamist; see tähendab ka kiirustamist.

Järjeklassi kasutav C ++ programm algab faili ülaosas järgmiste ridadega:

# kaasata
# kaasata
nimeruumi kasutamine std;

Esimene rida on sisendi / väljundi jaoks. Teine rida on lubada programmil kasutada kõiki järjekorra klassi funktsioone. Kolmas rida võimaldab programmil kasutada nimesid standardses nimeruumis.

Funktsiooni ülekoormamine

Kui kahel või enamal erineval funktsiooniallkirjal on sama nimi, öeldakse, et see nimi on ülekoormatud. Ühe funktsiooni kutsumisel määrake argumentide arv ja tüüp, milline funktsioon tegelikult täidetakse.

Ehitus

järjekorda nimi ()

Järgmine deklaratsioon kiirendab järjekorda nimega, järjekorra tüüp int.

järjekorda järjekord;

Järjekord on tühi. Deklaratsioon algab reserveeritud sõnaga, järjekord, millele järgnevad nurksulgud andmetüübiga. Siis on teil programmeerijal järjekorra nimi.

Algatajate loendiga koostamine

Järgmine määratlus näitab, kuidas luua lähtestajate loendiga järjekord:

järjekorda järjekord (1.1, 2.2, 3.3, 4.4);

Järjekorra hävitamine

Järjekorra hävitamiseks laske sellel lihtsalt reguleerimisalast välja minna.

Juurdepääs järjekorraelemendile

tõuge (väärtus)

Järjekord on nimekiri First-In-First-Out. Niisiis, iga väärtus lisatakse tagantpoolt. Järgmine koodilõik loob tühja järjekorra, mille järel tagant lisatakse viis ujukväärtust:

järjekorda järjekord;
järjekord.lükake (1.1);
järjekord.suruge (2.2);
järjekord.suruge (3.3);
järjekord.suruge (4.4);
järjekord.lükake (5.5);

suurus () konst

See tagastab järjekorras olevate elementide arvu. Järgmine kood illustreerib:

järjekorda järjekord;
järjekord.lükake (1.1); järjekord.suruge (2.2); järjekord.suruge (3.3); järjekord.suruge (4.4); järjekord.lükake (5.5);
cout << que.size() << '\n';

Väljund on 5.

ees ()

See tagastab viite järjekorra esimesele elemendile ilma elementi eemaldamata. Järgmise koodi väljund on 1.1.

järjekorda järjekord;
järjekord.lükake (1.1); järjekord.suruge (2.2); järjekord.suruge (3.3); järjekord.suruge (4.4); järjekord.lükake (5.5);
cout << que.front() << '\n';

Elementi ei eemaldata järjekorrast.

ees () const

Kui järjekorra koostamisele eelneb const, käivitatakse fraasi „front ()” asemel väljend „front () const”. Seda kasutatakse näiteks järgmises koodis.

const järjekord järjekord (1.1, 2.2, 3.3, 4.4, 5.5);
cout << que.front() << '\n';

Tagastatakse pidev viide. Elementi vektorist ei eemaldata. Järjekorra elemente ei saa muuta.

tagasi()

See tagastab viite järjekorra viimasele elemendile ilma elementi eemaldamata. Järgmise koodi väljund on 5.5.

järjekorda järjekord;
järjekord.lükake (1.1); järjekord.suruge (2.2); järjekord.suruge (3.3); järjekord.suruge (4.4); järjekord.lükake (5.5);
cout << que.back() << '\n';

tagasi () konst

Kui järjekorra koostamisele eelneb const, käivitatakse väljendi „back ()” asemel väljend „back () const”. Seda kasutatakse näiteks järgmises koodis.

const järjekord järjekord (1.1, 2.2, 3.3, 4.4, 5.5);
cout << que.back() << '\n';

Tagastatakse pidev viide. Elementi ei eemaldata järjekorrast. Järjekorra ehitamiseks eelneva konstanti korral ei saa järjekorra elemente muuta.

Järjekordade maht

suurus () konst

- vt eespool

tühi () const

See tagastab tõese 1, kui järjekorras pole elemente, või 0 vale, kui järjekord on tühi. Järgmine kood illustreerib seda:

järjekorda que1 (1.1, 2.2, 3.3, 4.4, 5.5);
cout << que1.empty() << '\n';
järjekorda que2;
cout << que2.empty() << '\n';

Väljund on:

0
1

Järjekorra muutjad

pop ()

Järjekord on FIFO, nii et kõik eemaldatavad elemendid tuleb järjekorra ülaosast (pea) eemaldada. See liikme funktsioon eemaldab esimese elemendi seda tagastamata. Järgmine kood illustreerib seda:

järjekorda järjekord (1.1, 2.2, 3.3, 4.4, 5.5);
cout << que.front() << '\n';
järjekord.pop ();
cout << que.size() << '\n';

Väljund on:

1.1
4

a.vahetada (b)

Kaks järjekorda saab vahetada, nagu on illustreeritud selles koodisegmendis:

järjekorda que1 (1.1, 2.2, 3.3, 4.4, 5.5);
järjekorda que2 (10, 20);
1. järjekord.vahetada (que2);
cout << "First element and size of que1:
"<< que1.front() <<", "<< que1.size() << '\n';
cout << "First element and size of que2 "<<
que2.ees () <<", "<< que2.size() << '\n';

Väljund on:

Q1 esimene element ja suurus: 10, 2

Q2 esimene element ja suurus: 1.1, 5

Pange tähele, et vajadusel suurendatakse järjekorra pikkust. Väärtused, millel ei olnud asendusi, asendatakse mõne vaikeväärtusega. Andmetüübid peavad olema sama tüüpi.

Võrdõiguslikkuse ja suhtlusoperaatorite järjekorrad

Tavaliste tähtede puhul C ++, kasvavas järjekorras, tulevad numbrid enne suurtähti, mis enne väiketähti. Kosmosetäht tuleb nulli ja kõigi nende ette.

Võrdõiguslikkuse operaatorid

Tagastab tõese 1 ja vale 0.

== Operaator

Tagastab 1, kui kahes järjekorras on sama suurus ja vastavad elemendid on võrdsed; muidu tagastab 0. Näide:

järjekorda que1 ("lahke", "midagi muud");
järjekorda que2 ("kuri");
int arv = que1 == que2;
cout << num << '\n';

Väljund on: 0.

The != Operaator

- vastupidine ülaltoodule. Näide:

järjekorda que1 ("lahke", "midagi muud");
järjekorda que2 ("kuri");
int arv = que1 != que2;
cout << num << '\n';

Väljund on: 1.

Suheteoperaatorid

Tagastab tõese 1 ja vale 0.

The < Operator

Tagastab 1, kui esimene järjekord on teise järjekorra esialgne alamhulk, kusjuures kahe võrdse osa elemendid on samad ja samas järjekorras. Kui mõlemad järjekorrad on sama suurusega või erineva suurusega ning liikudes vasakult paremale, satub esimeses järjekorras element, mis on väiksem kui teise järjekorra vastav element, siis 1 tagastatakse ikkagi. Vastasel juhul tagastatakse 0. Näide:

järjekorda que1 ("lahke", "midagi muud");
järjekorda que2 ("kuri");
int arv = que1 < que2;
cout << num << '\n';

Väljund on 1. < does not include the case when the size and order are the same.

Operaator

- vastupidine ülaltoodule. Näide:

järjekorda que1 ("lahke", "midagi muud");
järjekorda que2 ("kuri");
int arv = que1> que2;
cout << num << '\n';

Väljund: 0

The <= Operator

- sama nagu < but includes the case when the size and order are the same. Example:

järjekorda que1 ("lahke", "midagi muud");
järjekorda que2 ("kuri");
int arv = que1 <= que2;
cout << num << '\n';

Väljund: 1

Operaator> =

- vastupidine ülaltoodule. Näide:

järjekorda que1 ("lahke", "midagi muud");
järjekorda que2 ("kuri");
int arv = que1> = que2;
cout << num << '\n';

Väljund: 0

Klass ja selle kohesed objektid

Väärtus on andmetüübile, nagu instantsitud objekt klassile. Järjekorraldus võib ka andmetüübina aktsepteerida klassi. Järgmine programm illustreerib seda:

# kaasata
# kaasata
nimeruumi kasutamine std;
klass TheCla

avalik:
int number;
staatiline süsinik;
tühine func (char cha, const char * str)

cout << "There are " << num << " books worth " << cha << str << " in the store." << '\n';

staatiline tühisus (char ch)

kui (ch == 'a')
cout << "Official static member function" << '\n';

;
int main ()

TheCla obj1; TheCla obj2; TheCla obj3; TheCla obj4; TheCla obj5;
järjekorda järjekord;
järjekord.tõuge (obj1); järjekord.lükkama (obj2); järjekord.lükkama (obj3); järjekord.lükkama (obj4); järjekord.lükkama (obj5);
cout << que.size() << '\n';
tagastama 0;

Väljund on 5.

Lingitud loend

Järjekordade loendit nimetatakse tehniliselt lingitud loendiks. Järjekorras on kahte tüüpi lingitud loendeid: ühe lingiga loend ja topelt lingitud loend.

Üksikult lingitud loendi elemendi saab rakendada kahest liikmest koosnev struktuur. Ühel liikmel on järgmise elemendi kursor ja teisel liikmel on nullpunkt (andmete ainsus).

Topelt lingitud loendi elemendi saab rakendada kolmeliikmeline struktuur. Keskmisel liikmel on nullpunkt, samal ajal kui esimesel ja kolmandal liikmel on näpunäited nende külgnevatele elementidele.

Järjekorra rakendused

Järjekord on esimene-esimene-välja andmestruktuur. Arvutamisel on olukordi, kui andmed saabuvad järjekorra kujul, mis nõuab käitumist esimesest-esimesest-välja.

Arvutiressursside jagamine

Arvuti ressurss on piiratud kättesaadavusega mis tahes füüsiline või virtuaalne komponent. Nende hulka kuuluvad protsessor, videokaart, kõvaketas ja mälu. Sellise ressursi jagamine vajab järjekorda.

Katkestuste käitlemine

Arvuti välisseadmed peavad arvutit aeg-ajalt katkestama. Katkestajatega tuleb käituda samamoodi, nagu nad saabusid. See vajab järjekorda.

Teabe haldamine.

Järjekorda saab kasutada näiteks töö rakenduse failide haldamiseks, kui failid on arvutisse salvestatud.

Järeldus

Järjekord on loendi andmestruktuur, mis on kas ühe lingi või topelt lingitud loend. Reeglina on esimene loendisse sisenev element esimene, mis välja tuleb. C ++ pakub oma tavapärases teegis järjekorraandmete struktuuri. Selle struktuuri jaoks saadaval olevate liikmete funktsioonide ja operaatorite kategooriad on järjekorra koostamine, juurdepääs järjekorraelementidele, järjekorra maht, järjekorra modifikaatorid ja järjekorra ülekoormatud operaatorid.

Mis tahes järjekorra andmestruktuur peab pakkuma vähemalt funktsiooni push () ja pop (). push () tähendab uue elemendi saatmist järjekorra taha; ja pop () tähendab, et eemaldatakse järjekorra ees olev element. Kahjuks ei tagasta C ++ puhul need funktsioonid tõugatud või hüppatud väärtust. Nii et viimase elemendi tundmiseks enne tõukamist tuleb kasutada funktsiooni extra back (); Esimese elemendi tundmiseks enne hüppamist tuleb kasutada funktsiooni front front ().

Väärtus on andmetüübile, nagu instantsitud objekt klassile. Niisiis, konkreetset klassi saab kasutada andmetüübina järjekorra malli kiirendamisel. Klassi erinevad objektid muutuvad klassi jaoks nagu erinevateks väärtusteks.

Järjekorras on arvutis rakendused. Seda saab kasutada näiteks töö rakenduse failide haldamiseks, kui failid on arvutisse salvestatud.

Chrys