Buborék módszer C soros kimenet. Buborék válogatás és minden-all. Javított válogatási algoritmus Pascalban

A tömböt felülről lefelé helyezzük, a nulla elemtől az utolsóig.

A módszer ötlete: A rendezési lépés a tömb alulról felfelé halad. Útközben vannak a szomszédos elemek párjai. Ha néhány pár eleme rossz sorrendben van, akkor megváltoztatjuk őket helyeken.

A "TOP" tömbözés után a "Top" a "Light" elemnek köszönhetően - innen egy analógiát egy buborékkal. A következő lépés a fenti második elemre történik, így a második legnagyobb elem a megfelelő pozícióba emelkedik ...

A tömb teljes csökkentő alsó részét, amíg csak egy elem marad. Ezen a válogatási végeken, mivel a szekvenciát felemelkedik.

Sablon. Void Buborbubleort (T A, Long Méret) (hosszú i, J; t x; az (i \u003d 0; i)< size; i++) { // I - Pass szám (j \u003d méret-1, j\u003e i; j--) ( // belső átjáró ciklus ha (a\u003e a [j]) (x \u003d a; A \u003d a [j]; a [j] \u003d x;))))))))

Az összehasonlítások és cserékek átlagos száma négy négyszögletes növekedési sorrendben van: Theta (N 2), innen arra a következtetésre juthat, hogy a buborék algoritmusa nagyon lassú és hatástalan.
Mindazonáltal hatalmas plusz van: egyszerű, és bármilyen módon javítható. Mit fogunk menni.

Először is, fontolja meg a helyzetet, ha az áthaladások bármelyikében nincs csere. Mit jelent?

Ez azt jelenti, hogy minden pár a megfelelő sorrendben található, így a tömb már rendezett. És folytassa a folyamatnak nincs értelme (különösen, ha a tömböt a kezdetektől fogva rendezték!).

Tehát az algoritmus első javulása az, hogy emlékezzen arra, hogy minden csere történt-e ezen a szakaszon. Ha nem, az algoritmus befejezi a munkát.

A fejlesztési folyamat folytatható, ha nemcsak a csere tényét, hanem a K utolsó cseréjét is emlékezzen. Valójában: az indexekkel ellátott elemek összes párja már a kívánt sorrendben található. További részleteket lehet kitölteni a K indexen, ahelyett, hogy az előre telepített felső határoló verzióra való áthelyezhető.

Minőségi szempontból az algoritmus másik javulása a következő megfigyelésből származhat. Bár a fénybuborék az alulról emelkedik egy átmenettel, a nehéz buborékok minimális sebességgel csökkennek: egy lépés az iterációhoz. Tehát a 2 3 4 5 6 1 tömb 1-ben lesz rendezve, és a 6 1 2 3 4 5 szekvencia válogatása 5 átadást igényel.

Hasonló hatás elkerülése érdekében megváltoztathatja az alábbiak irányát más útmutatással. A kapott algoritmust néha hívják " shaker-válogatás".

Sablon. Void Shakersort (T A, Hosszú méret) (hosszú J, K \u003d méret-1, hosszú lb \u003d 1, UB \u003d méret-1; // a tömb nem kívánt részének határai T x; ( // pass biztonsági mentés Mert (j \u003d ub; j\u003e 0; j--) (ha (a\u003e a [j]) (x \u003d a, A \u003d A [J]; a [j] \u003d x; k \u003d j; \u003d K + 1; // a felülről lefelé (j \u003d 1; j)<=ub; j++) { if (a > a [j]) (x \u003d a; A \u003d a [j]; a [j] \u003d x; k \u003d j;)) UB \u003d K-1; ) Míg (lb< ub); }

Hogyan befolyásolták a módosítások a módszer hatékonyságát? Az összehasonlítások átlagos száma, bár csökkent, de továbbra is O (n 2), míg a cserék száma semmilyen módon nem változott. Az átlag (ez a legrosszabb) A műveletek száma négyzet marad.

A további memória nyilvánvalóan nem szükséges. A javított (de nem kezdeti) módszer viselkedése meglehetősen természetes, szinte válogatott tömb lesz sokkal gyorsabb véletlenszerűen. Rendezés buborék stabil, de a shaker-válogatás elveszíti ezt a minőséget.

A gyakorlatban a buborék módszer, még a fejlesztések, a munkák, az alas, túl lassú. És ezért - szinte nem alkalmazandó.

Buborék-módszer

Válogató egyszerű cserék , rendezés buborékkal (Eng. buborék rendezés.) - Egy egyszerű válogató algoritmus. Az algoritmus megértése és végrehajtása - a legegyszerűbb, de csak kis tömbök esetén hatékony. Az algoritmus összetettsége: o ( n.²).

Az algoritmust oktatási és gyakorlatilag nem alkalmazza az oktatási irodalomon kívül, ahelyett, hogy a gyakorlatban a betéteket alkalmazzák.

Algoritmus

Példa a véletlen számok buboréklistájával.

Az algoritmus ismétlődő folyosókból áll a sorrendben. Minden egyes átmenettel az elemeket folyamatosan párosítják párban, és ha a megrendelés helytelen, az elemek cseréje teljesül. A tömbök megismétlődnek, amíg a következő átjáró kiderül, hogy a cserék már nem szükségesek, ami azt jelenti, hogy - egy tömb rendezett. A áthaladását az algoritmus, az elem, ami nem a helyén, „felbukkan”, a kívánt helyzetben, mint egy buborék a vízben, innen a név az algoritmus.

Néha minden lépésben a tömb látható az elején, majd a végétől. Ezt hívják a shaker válogatásnak.

Példák a megvalósításra

Piton

Def swap (ARR, I, J): ARR [I], ARR [J] \u003d ARR [J], ARR [I] DEF BUBBLE_SORT (ARR): I \u003d Len (ARR) míg I\u003e 1: a j a xrange-ben (I - 1): Ha ARR [J]\u003e ARR [J + 1]: SWAP (ARR, J, J + 1) I - \u003d 1

VBA.

Sub rendezés (MUS () hosszú ideig) dim n hosszú, i hosszú, tmp olyan hosszú i \u003d 1, míg (i< UBound (Mus) ) If Mus(i) > Mus (i + 1), majd tmp \u003d mus (i) mus (i) \u003d mus (i + 1) mus (i + 1) \u003d tmp, ha i\u003e 1, akkor i \u003d i - 1 mást i \u003d i + 1 vég, ha Egyébként i \u003d i + 1 vég, ha a hurok vége

Javított válogatási algoritmus Pascalban

P: \u003d igaz; (Van egy permutáció) K: \u003d 1; (Nézetszám) Míg a p kezdődik p: \u003d hamis; Az i: \u003d 1 - n - k Do Ha x [i]\u003e x [i + 1] akkor kezdődik: \u003d x [i]; X [i]: \u003d x [i + 1]; X [i + 1]: \u003d a; P: \u003d igaz; Vége; K: \u003d K + 1; Vége;

PHP.

$ Méret \u003d szám ($ ARR) -1; Mert ($ i \u003d $ méret; $ i\u003e \u003d 0; $ i -) (a ($ j \u003d 0, $ j<=($i -1 ) ; $j ++) if ($arr [ $j ] >$ ARR [$ J +1]) ($ k \u003d $ ARR [$ J]; $ ARR [$ J] \u003d $ ARR [$ J +1]; $ ARR [$ J +1] \u003d $ K;)

Nemcsak nem tekinthető a leggyorsabb módszernek, ráadásul bezárja a leglassabb rendelési módok listáját. Azonban előnye van. Tehát, válogatás a buborék módszerével - a legtöbbet, hogy sem logikus és természetes megoldás van a problémára, ha az elemeket egy bizonyos sorrendben kell elhelyezni. Egy hétköznapi személy manuálisan, például kihasználja őket - csak az intuíción.

Hol származott ilyen szokatlan név?

A módszer nevét a vízben lévő légbuborékokkal analógiával találtuk fel. Ez egy metafora. Csakúgy, mint a kis légbuborékok felemelkednek - végül is, sűrűségük nagyobb, mint bármely folyadék (ebben az esetben - víz), és a tömb minden eleme, annál kevésbé értékeli, annál kisebb, hogy fokozatosan fokozatosan teszi az elejét számok száma.

Az algoritmus leírása

A buborék rendezése az alábbiak szerint történik:

• első rész: A számok tömbelemei két, és összehasonlítjuk a párokat is. Ha két elemnél az első érték több mint a második, a program létrehozza a mezőmegosztást;
• következésképpen a tömb a végére esik. Míg minden más elem marad, mivel kaotikus sorrendben voltak, és több válogatást igényelnek;
• ezért, a második lépésben szükséges: ez által analógiájára az előző (a már ismertetett), és van egy összehasonlítások száma - mínusz egy;
• Átmeneti szám három összehasonlítás egységenként kevesebb, mint a második és kétszer, mint az első. Stb;
• Összefoglaljuk, hogy minden egyes átjáró (teljes értékek egy tömbben, egy meghatározott számban) mínusz (átjárási szám) az összehasonlítások.

Röviden, a jövőbeni program algoritmusa a következőképpen írható:

• számos számot ellenőriznek, amíg két számot nem találnak, a másodiknak többnek kell lennie, mint az első;
• helytelenül helytelenül található a tömbprogram egymás elemeihez, a helyeken.

Pszeudokód a leírt algoritmus alapján

A legegyszerűbb végrehajtás az alábbiak szerint történik:

Eljárás Sortirovka_puzirkom;

Rajt

ciklus j. tól től nachalnii_index előtt konechii_index;

ciklus ÉN. tól től nachalnii_index előtt konechii_index-1.;

ha egy massiv [I]\u003e Massiv

(módosítsa az értékeket a helyeken);

vége

Természetesen itt az egyszerűség csak súlyosbítja a helyzetet: annál egyszerűbb az algoritmus, különösen az egész hibák nyilvánulnak meg. Az időköltség túl nagy ahhoz, hogy egy kis tömb esetében is túl nagy legyen (relativitás kérdése: az átlag esetében az idő kisebb lehet kicsinek, de a programozó programozójában, minden második vagy akár milliszekundum a számlán).

Jobb volt a megvalósítás. Például, figyelembe véve az értékek cseréjét a tömbben helyeken:

Eljárás Sortirovka_puzirkom;

Rajt

sortirovka. \u003d igazság;

ciklus sortirovka. \u003d igazság;

sortirovka. \u003d hamis;

ciklus ÉN. tól től nachalnii_index előtt konechii_index-1.;

ha egy massiv [I]\u003e Massiv (Az első elem nagyobb, mint a második), akkor:

(az elemek megváltoztatása a helyeken);

sortirovka. \u003d igazság; (Jelölje meg, hogy a csere előállt).

Vége.

A módszer hátrányai

A fő mínusz a folyamat időtartama. Mennyi időt vesz igénybe egy buborék?

A végrehajtási időt a tömb számok számának négyzetéből számolják ki - a végeredmény arányos.

A legrosszabb verzió esetén a tömb annyi alkalommal kerül átadásra, amennyire az IT elemek mínusz egy értéket. Ez azért van, mert végül csak egy olyan elem van, amelynek nincs semmi összehasonlítása, és a Massif utolsó áthaladása használhatatlanná válik.

Ezenkívül az egyszerű csereprogramok rendezésének módja, amint azt csak kis tömbök esetében is nevezik. Nagy mennyiségű adatmennyiség nem kerül feldolgozásra: az eredmény hibák vagy programhiba lesz.

Méltóság

A buborék rendezése nagyon egyszerű a megértéshez. A műszaki egyetemek tantervi programjaiban, amikor a tömbelemek tömbjét tanulmányozza, először veszi fel. A módszer könnyen megvalósítható, mint a nyelv. delphi programozása. (D (Delphi) és C / C ++ (SI Plus Plus), hihetetlenül egyszerű algoritmus a megfelelő sorrendben lévő értékek helyére és a buborék rendezésére ideális kezdőknek.

A hiányosságok miatt az algoritmus nem alkalmazható szabadidős célokra.

A válogatás Visory elve

Kezdeti nézet a tömb 8 22 4 74 44 37 1 7

1. lépés 8 22 4 74 44 37 1 7

8 22 4 74 44 1 37 7

8 22 4 74 1 44 37 7

8 22 4 1 74 44 37 7

8 22 1 4 74 44 37 7

8 1 22 4 74 44 37 7

1 8 22 4 74 44 37 7

2. lépés. 1 8 22 4 74 44 7 37

1 8 22 4 74 7 44 37

1 8 22 4 7 74 44 37

1 8 22 4 7 74 44 37

1 8 4 22 7 74 44 37

1 4 8 22 7 74 44 37

3. lépés. 1 4 8 22 7 74 37 44

1 4 8 22 7 37 74 44

1 4 8 22 7 37 74 44

1 4 8 7 22 37 74 44

1 4 7 8 22 37 74 44

4. lépés. 1 4 7 8 22 37 44 74

1 4 7 8 22 37 44 74

1 4 7 8 22 37 44 74

1 4 7 8 22 37 44 74

5. lépés. 1 4 7 8 22 37 44 74

1 4 7 8 22 37 44 74

1 4 7 8 22 37 44 74

6. lépés. 1 4 7 8 22 37 44 74

1 4 7 8 22 37 44 74

7. lépés. 1 4 7 8 22 37 44 74

Példa a pascal buborék rendezése

Példa:

const kol_mas \u003d 10;

var Massiv: egész számú tömb;

a, B, K: egész szám;

writeln ("bemenet", kol_mas, "Array elemei");

a: \u003d 1-re kol_mas do readln (Massiv [A]);

a: \u003d 1-re a kol_mas-1-re kezdődik

a b: \u003d a + 1-re kol_mas-ra kezdődik

ha Massiv [a]\u003e Massiv [B] kezdődik

k: \u003d Massiv [A]; Massiv [a]: \u003d Massiv [b]; Massiv [b]: \u003d K;

vége;

writeln ("Utána));

a: \u003d 1-re kol_mas do writeln (Massiv [a]);

Példa egy buborék válogatására egy (si) nyelven

#Inlude.

#Inlude.

int Main (int Argc, Char * argv)

int Massiv \u003d (36, 697, 73, 82, 68, 12, 183, 88), I, FF;

(;) (

ff \u003d 0;

(i \u003d 7, i\u003e 0; i -) (

Ha (Massiv [i]< massiv) {

Swap (Massiv [i], Massiv);

ha (ff \u003d\u003d 0) szünet;

getch (); // Képernyő késedelem

Címkék: Rendezés buborék si, si buborék válogatásRendezés buborék kétdimenziós tömb

Rendezés buborékkal

És az algoritmus cselekedete nagyon egyszerű. Átmegyünk a számok sorában, és ellenőrizzük a megrendelést (a következő számnak többet kell lennie, és egyenlő az előzővel), amint a megrendelés megsértése, azonnali elemek cseréje a helyeken, elérjük a végét tömb, majd kezdje el először.

Rendezze a tömböt (1, 5, 2, 7, 6, 3)
A MassiF-en megyünk, ellenőrizzük az első számot és a második számot, növekvő sorrendben mennek. Ezután megsérti a megrendelést, megváltoztatjuk ezeket az elemeket
1, 2, 5, 7, 6, 3
Továbbra is átmegyünk a tömbön, 7 több mint 5, de 6 kevesebb, így cseréljük ki a helyekből
1, 2, 5, 6, 7, 3
3 megsérti a megrendelést, a 7-es helyek megváltoztatását
1, 2, 5, 6, 3, 7
Visszatérünk a tömb elejére, és ugyanezt tesszük

1, 2, 5, 3, 6, 7
1, 2, 3, 5, 6, 7

Azt mondják, hogy ez hasonló a "lebegő" több "lungs" elemekhez, mint például a buborékok, ezért az algoritmus és kapott ilyen nevet. Voidbublebleort (int * a, size_t méret) (Size_t i, j; int tmp; az (i \u003d 1, i)< size; i++) { for (j = 1; j < size; j++) { if (a[j] > a) (tmp \u003d a [j]; a [j] \u003d a, a \u003d tmp;))))))))))

Ez az algoritmus mindig (N-1) 2 lépést tesz, függetlenül a bemeneti adatoktól. Még akkor is, ha a tömb rendezve van, még mindig 2-szer kerül át (n-1). Ráadásul a már rendezett adatokat ismét ellenőrzik.

Szükség legyen az 1, 2, 4, 3 tömb rendezésére

1 2 4 3
1 2 4 3
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4

Miután megváltozott az A elem helyszíneiben, és a tömb ezen szakaszának meg kell adnia. Figyelembe vesszük és állítjuk az algoritmust

Void bubblebubleort2 (int * a, size_t méret) (Méret_t i, j; int tmp; az (i \u003d 1, i)< size; i++) { for (j = i; j > 0; j--) (ha (a [j)< a) { tmp = a[j]; a[j] = a; a = tmp; } } } }

Egy másik megvalósítás

Void bubblebubleort2b (int * a, size_t méret) (size_t i, j; int tmp; az (i \u003d 1; i)< size; i++) { for (j = 1; j <= size-i; j++) { if (a[j] < a) { tmp = a[j]; a[j] = a; a = tmp; } } } }

Ebben az esetben fél kevesebb lépés lesz, de még mindig a már rendezett tömb rendezésének problémája marad: meg kell tennie, hogy a rendezett tömb egyszer történjen. Ehhez adja meg a lobogó változóját: ez kihagyásra kerül (zászló \u003d 0), ha a tömb rendezve van. Amint megsértjük a megrendelés megsértését, a zászlót fel fogják emelni (zászló \u003d 1), és a szokásos módon elkezdjük rendezni a tömböt.

Void bubblebuborsort3 (int * a, size_t méret) (Méret_t i; int tmp; char Flag, do (flag \u003d 0, for (i \u003d 1, i< size; i++) { if (a[i] < a) { tmp = a[i]; a[i] = a; a = tmp; flag = 1; } } } while (flag); }

Ebben az esetben a komplexitás szintén N 2, de egy soros tömb esetén csak egy átjáró lesz.

Most javítsa az algoritmust. Meg fogjuk írni az általános űrlap funkcióját úgy, hogy rendes típusú ürességet rendezze. Mivel a változó típus nem ismert, szükség lesz továbbá továbbítani az egyik tömbelem méretét és az összehasonlító funkciót.

Int Intsor (CONST VOID * A, CONST VOID * B) (Visszatérés * ((int *) a)\u003e * ((int *) b);) Void Buborment3g (Void * A, Size_T tétel, Size_T méret, Int (* Cmp) (CONST VOID *, CONST VOID *))) (Size_t i, void * tmp \u003d null; char flag, tmp \u003d malloc (tétel); do (lobogó \u003d 0;< size; i++) { if (cmp(((char*)a + i*item), ((char*)a + (i-1)*item))) { memcpy(tmp, ((char*)a + i*item), item); memcpy(((char*)a + i*item), ((char*)a + (i-1)*item), item); memcpy(((char*)a + (i-1)*item), tmp, item); flag = 1; } } } while (flag); free(tmp); }

A funkció csúnya - gyakran az aktuális és az előző elem címét kiszámítják. Kiemeljük a külön változókat erre.

Void bubblebuborsort3gi (Void * A, Size_t elem, Size_T méret, int (* cmp) (CONST VOID *, CONST *)) (SIZE_T I, VOID * TMP \u003d NULL, VOID * TMP \u003d malloc (tétel); do (flag \u003d 0, i \u003d 1, prev \u003d (char *) a; cur \u003d (char *) prev + elem; míg (i< size) { if (cmp(cur, prev)) { memcpy(tmp, prev, item); memcpy(prev, cur, item); memcpy(cur, tmp, item); flag = 1; } i++; prev = (char*)prev + item; cur = (char*)cur + item; } } while (flag); free(tmp); }

Most ezeken a funkciók segítségével bármilyen típusú tömböket rendezheti, például

Void Main () (INT A \u003d (1, 0, 9, 8, 7, 6, 2, 3, 4, 5); int i; bubortort3gi (A, Sizeof (int), 10, Intsort); mert (i \u003d 0; én< 10; i++) { printf("%d ", a[i]); } _getch(); }

Multidimenziós tömb rendezése

A statikus többdimenziós tömb lényegében nem különbözik az egydimenziós rendezéstől. Használhatja azt a tulajdonságot, hogy a statikus egydimenziós és többdimenziós tömbök ugyanolyan nézetben vannak a memóriában.

Void Main () (INT A \u003d (1, 9, 2, 8, 3, 7, 4, 6, 5); int I, J; buborlubtort3gi (A, Sizeof (int), 9, Intsort); mert (i \u003d 0; én< 3; i++) { for (j = 0; j < 3; j++) { printf("%d ", a[i][j]); } } } Сортировка динамически созданного двумерного массива может быть произведена двумя способами. Во-первых, можно по определённому алгоритму находить индекс i-го и j-го элемента по порядковому номеру k от 0 до n * m. #include #Inlude. #Inlude. #Inlude. Void BuborbubleSort2D (int ** a, size_t m, size_t n) (int tmp; size_t i, j, k, jp, ip; size_t méret \u003d m * n; char flag, do (k \u003d 1) ; k.< size; k++) { //Вычисляем индексы текущего элемента j = k / m; i = k - j*m; //Вычисляем индексы предыдущего элемента jp = (k-1) / m; ip = (k-1) - jp*m; if (a[i][j] > a) (tmp \u003d a [i] [j]; a [i] [j] \u003d a; a \u003d tmp; lobogó \u003d 1;))))), míg (lobogó); ) #Define size_x 3 #define size_y 4 Void Main () (INT ** A \u003d NULL; INT I, J; A \u003d (INT **) MALLOC (méret (int *) * size_x); mert (i \u003d 0; ÉN.< SIZE_X; i++) { a[i] = (int*) malloc(sizeof(int) * SIZE_Y); for (j = 0; j < SIZE_Y; j++) { a[i][j] = rand(); printf("%8d ", a[i][j]); } printf("\n"); } printf("\nafter sort\n"); bubbleSort2d(a, SIZE_X, SIZE_Y); for (i = 0; i < SIZE_X; i++) { for (j = 0; j < SIZE_Y; j++) { printf("%8d ", a[i][j]); } printf("\n"); } for (i = 0; i < SIZE_X; i++) { free(a[i]); } free(a); _getch(); }

Másodszor, először áthelyezheti a tömböt egydimenziósnak, rendezze az egydimenziós tömböt, majd térjen vissza a kétdimenziósnak.

Void BuborbubleSt3gi2D (Void ** A, Size_T elem, Size_t M, Size_t N, Int (* CMP) (CONST VOID *, CONST VOID *)) (Méret_t méret \u003d m * n, sub_size \u003d n * ted , k; void * arr \u003d malloc (méret * tétel); char * p1d \u003d (char *) arr; char * p2d \u003d (char *) a; // másol egy kétdimenziós üregtípust egydimenziósnak \u003d 0; én< m; i++) { memcpy(p1d + i*sub_size, *((void**)(p2d + i*item)), sub_size); } bubbleSort3gi(arr, item, size, cmp); //Копируем одномерный массив обратно в двумерный for (i = 0; i < m; i++) { memcpy(*((void**)(p2d + i*item)), p1d + i*sub_size, sub_size); } }

Ha ez a funkció megzavarja Önt, akkor használja a gépelt. Hívja az előző példát

Becslések szerint az időn belül központi számítógépek Az adatrendelésnek fizetik. Ez azért van, mert sokkal könnyebb megtalálni az értéket egy olyan tömbben, amelyet előre rendezett. Ellenkező esetben a keresés egy kicsit olyan, mint egy tűkeresés egy szénakazalban.

Vannak olyan programozók, akik minden munkaidőt végzik a válogató algoritmusok tanulmányozásában és végrehajtásában. Ez azért van, mert az üzleti programok túlnyomó többsége magában foglalja az adatbáziskezelést. Az emberek minden alkalommal információt keresnek adatbázisokban. Ez azt jelenti, hogy a keresési algoritmusok nagyon kereslet.

De van egy "de". A keresési algoritmusok sokkal gyorsabban dolgoznak a már rendezett adatbázisokkal. Ebben az esetben csak egy lineáris keresés szükséges.

Míg a számítógépek bizonyos időpontokban felhasználók nélkül vannak, a válogató algoritmusok továbbra is dolgoznak adatbázisokkal. Ismét a felhasználók keresik, és az adatbázis már rendezett, egy adott keresési cél alapján.

Ez a cikk példa a szabványos válogatási algoritmusok megvalósítására.

Kiválasztás sorrend (kiválasztás rendezés)

Annak érdekében, hogy a tömböt növekvő sorrendben rendezze, az egyes iterációt követi, hogy megtalálja az elemet a legmagasabb értékkel. Ezzel meg kell cserélni az utolsó elemet. A következő elem a legnagyobb értékévé válik az utolsó előtti hely. Ennek meg kell történnie mindaddig, amíg a tömbök első helyén lévő elemek nem lesznek megfelelően.

C ++ kód

void sortalgo :: Selectionsort (int adatok, int kölcsönadag) (int j \u003d 0, int tmp \u003d 0, mert (int i \u003d 0; i) adatok [k]) (J \u003d K;)) TMP \u003d adatok [i]; Adatok [i] \u003d adatok [j]; Adatok [j] \u003d tmp; )))))))))

Buborékfajta

A buborék válogatással a szomszédos elemek összehasonlítása és helyeken változik, ha a következő elem kisebb, mint az előző. Több rész szükséges. Az első lépés során a tömb első két eleme harcol. Ha nincs rendben, megváltoztatják a helyeket, majd összehasonlítják az elemeket a következő párban. Ugyanezzel a feltételekkel is megváltoztatják a helyeket is. Így a válogatás minden ciklusban bekövetkezik, amíg a tömb végét el nem érik.

C ++ kód

void sortalgo :: bubblebors (int adatok, int kölcsön) (int tmp \u003d 0, for (int i \u003d 0; i \u003d (I + 1); J -) (ha (Adatok [J]

Beillesztési rendezés (beillesztés rendezése)

A betétek rendezése során a tömb két területre oszlik: megrendelt és rendezetlen. Kezdetben az egész tömb rendezetlen terület. Az első passzán az első elem egy rendezetlen régióból származik, és a megfelelő helyzetbe kerül egy megrendelt területen.

Minden egyes szakaszon a megrendelt terület mérete 1-re nő, és a rendezetlen régió mérete 1-vel csökken.

A főciklus 1-től N-1-ig terjedő tartományban működik. A J-TH ITERENÁCIÓBAN, az [I] elem beillesztésre kerül a megrendelt terület megfelelő helyzetébe. Ezt úgy végezzük, hogy áthelyezi a megrendelt terület összes elemét, amelyek nagyobbak, mint az [i], az egyik helyzet jobbra. Az [I] az olyan elemek közötti intervallumba kerül, amelyek kevesebb, mint [I], és azok, amelyek nagyobbak [I].

C ++ kód

void sortalgo :: INSERTIONSORT (INT DATA, INT LEND) (INT gomb \u003d 0, int i \u003d 0; mert (int j \u003d 1; j) \u003d 0 && adat [i]\u003e gomb) (adatok \u003d adatok [i]; i \u003d i-1, adat \u003d kulcs;))))))))

Merge rendezés (egyesítés rendezése)

C ++ kód

void sortalgo :: Mergesort (Int adatok, int kölcsönzés) (ha (lend\u003e 1) (INT MIDDLE \u003d LEND / 2, INT REM \u003d kölcsön-középső; int * l \u003d új int; int * r \u003d új int; mert ( int i \u003d 0; én

Gyors rendezés

A gyors válogatás az "osztja és meghódít" algoritmust használja. Az eredeti tömb két területre való felosztásával kezdődik. Ezek az alkatrészek a kijelölt elem bal oldalán helyezkednek el, amelyet a hivatkozásnak neveznek. A folyamat végén az egyik rész tartalmazza az elemeket, mint a támogatás, a másik rész tartalmazza az elemeket több referencia.

C ++ kód

void sortalgo :: Quicksort (INT * DATA, INT CONST LEN) (INT CONST LEND \u003d LEN, INT PIVOT \u003d 0; INT IND \u003d LEND / 2; INT I, J \u003d 0, K \u003d 0; ha (LEND\u003e 1) (int * l \u003d új int; int * r \u003d új int; pivot \u003d adatok; az (i \u003d 0; i)