Metoda bubble C de ieșire serială. Sortare cu bule și all-all-toate. Algoritmul îmbunătățit de sortare în Pascal

Plăim o matrice de sus în jos, de la elementul zero până la ultima.

Ideea metodei: Pasul de sortare constă în trecerea de jos în jos. Pe drum există perechi de elemente vecine. Dacă elementele unor perechi sunt în ordine greșită, atunci le schimbăm în locuri.

După trecerea zero de către matrice "top" se dovedește a fi cel mai "lumină" element - de aici o analogie cu un balon. Următorul pasaj se face la al doilea element de sus, astfel încât al doilea element cel mai mare se ridică la poziția corectă ...

Facem pasaje pentru întreaga parte scăzută a matricei până când un singur element rămâne în el. Pe această sortare se termină, deoarece secvența este ordonată ascendentă.

Șablon. Vid bubblesort (t a, dimensiune lungă) (lung i, j; t x; pentru (i \u003d 0; i< size; i++) { // i - un număr de trecere pentru (J \u003d Dimensiune-1; J\u003e I; J-) ( // Ciclul de trecere internă dacă (a\u003e a [j]) (x \u003d a; a \u003d a [j]; un [j] \u003d x;)))))

Numărul mediu de comparații și schimburi are o ordine de creștere quadratic: Theta (n 2), de aici puteți concluziona că algoritmul bubble este foarte lent și este ineficient.
Cu toate acestea, el are un plus imens: el este simplu și poate fi îmbunătățit în vreun fel. Ceea ce vom merge acum.

În primul rând, luați în considerare situația în care nu sa întâmplat niciun schimb în niciunul dintre treceri. Ce înseamnă?

Aceasta înseamnă că toate perechile sunt situate în ordinea corectă, astfel încât matricea este deja sortată. Și pentru a continua procesul nu are sens (mai ales dacă matricea a fost sortată de la început!).

Deci, prima îmbunătățire a algoritmului este de a-și aminti dacă s-a făcut un schimb în acest pasaj. Dacă nu, algoritmul termină munca.

Procesul de îmbunătățire poate fi continuat dacă vă amintiți nu numai de schimbul, ci și indicele ultimului schimb de k. Într-adevăr: toate perechile pachetului de elemente cu indexuri, mai mici K, sunt deja situate în ordinea dorită. Pasajele ulterioare pot fi finalizate pe indicele K, în loc să se deplaseze la versiunea superioară de limitare I instalată în avans.

În mod calitativ, o altă îmbunătățire a algoritmului poate fi obținută de la următoarea observație. Deși bulele de lumină din partea de jos se va ridica într-o singură trecere, bulele grele sunt coborâte la o viteză minimă: un pas pentru iterație. Astfel, matricea 2 3 4 5 6 1 va fi sortată în 1 trepte, iar sortarea secvenței 6 1 2 3 4 5 va necesita 5 treceri.

Pentru a evita un efect similar, puteți schimba direcția următoarei prin alte treceri. Algoritmul rezultat este uneori numit " sortare cu agitare".

Șablon. Void Shakersort (t A, Dimensiune lungă) (Long J, K \u003d Dimensiune-1, Long LB \u003d 1, UB \u003d Dimensiune-1; // limitele părții nesustenate a matricei T x; ( // treceți înapoi Pentru (j \u003d ub; j\u003e 0; j-) (dacă (a\u003e A [j]) (x \u003d a; a \u003d a [j]; a [j] \u003d x; k \u003d j;)) lb \u003d k + 1; // treceți de sus în jos pentru (J \u003d 1; j<=ub; j++) { if (a > a [J]) (x \u003d a; a \u003d a [j]; un [j] \u003d x; k \u003d j;)))) ub \u003d k-1; ) În timp ce (lb< ub); }

Cum au fost descrise modificările au afectat eficacitatea metodei? Numărul mediu de comparații, deși a scăzut, dar rămâne O (n 2), în timp ce numărul de schimburi nu sa schimbat în nici un fel. Media (este cel mai rău) numărul operațiunilor rămâne patratic.

Memoria suplimentară nu este evident necesară. Comportamentul unei metode îmbunătățite (dar nu inițiale) este destul de natural, o matrice aproape sortate va fi sortate mult mai repede aleator. Sortați după Bubble este stabil, dar sortarea agitatorului pierde această calitate.

În practică, metoda bubble, chiar și cu îmbunătățiri, lucrări, din păcate, prea lentă. Și, prin urmare, aproape nu se aplică.

Metoda bubble.

Triere simpleuri simple , sortați după Bubble. (eng. sortare bubble.) - Un simplu algoritm de sortare. Pentru a înțelege și a implementa acest algoritm - cel mai simplu, dar este eficient numai pentru matrice mici. Complexitatea algoritmului: o ( n.²).

Algoritmul este considerat educativ și practic nu se aplică în afara literaturii educaționale, în locul acesteia, se aplică inserții.

Algoritm.

Exemplu de sortare printr-o listă de bule de numere aleatorii.

Algoritmul constă din culoar repetitiv pe matrice sortate. Pentru fiecare trecere, elementele sunt în comparație în mod constant în perechi și, dacă ordinul este incorect, este îndeplinit schimbul de elemente. Passele de matrice se repetă până când următorul pasaj se dovedește că schimburile nu mai sunt necesare, ceea ce înseamnă - o matrice este sortată. Cu trecerea algoritmului, elementul, care nu este în locul său, "apare" în poziția dorită ca un balon în apă, de aici numele algoritmului.

Uneori la fiecare pas, matricea este vizibilă de la început, apoi de la capăt. Aceasta se numește sortarea agitatorului.

Exemple de implementare

Piton

Def swap (arr, i, j): arr [i], arr [j] \u003d arr [j], arr [i] def bubble_sort (arr): i \u003d len (arr) în timp ce i\u003e 1: pentru j în xrange (I - 1): Dacă arr [J]\u003e Arr [J + 1]: Swap (ARR, J, J + 1) I - \u003d 1

VBA.

Sub sort (Mus () atâta timp) Dim n atâta timp, i cât de mult, tmp cât de mult am \u003d 1 face în timp ce (i< UBound (Mus) ) If Mus(i) > Mus (I + 1) atunci tmp \u003d mus (i) \u003d mus (i + 1) mus (i + 1) \u003d tmp dacă i\u003e 1 apoi i \u003d i - 1 altceva i \u003d i + 1 capăt dacă Altceva i \u003d i + 1 capăt în cazul în care se termină loop

Algoritmul îmbunătățit de sortare în Pascal

P: \u003d adevărat; (Există o permutare) K: \u003d 1; (Numărul de vizualizare) În timp ce P nu începe P: \u003d FALSE; Pentru i: \u003d 1 la n - k dacă x [i]\u003e x [I + 1] Începeți A: \u003d x [i]; X [i]: \u003d x [I + 1]; X [I + 1]: \u003d A; P: \u003d adevărat; Sfârșit; K: \u003d K + 1; Sfârșit;

PHP.

$ Size \u003d numără ($ arr) -1; Pentru ($ i \u003d dimensiune $; $ i\u003e \u003d 0; $ i -) (pentru ($ 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;))

Nu numai că nu este considerată cea mai rapidă metodă, în plus, închide lista celor mai lente modalități de comandă. Cu toate acestea, ea are avantajele sale. Deci, sortarea prin metoda de bule - cel mai mult încât nici nu există o soluție logică și naturală la această problemă, dacă este necesar să plasați elementele într-o anumită ordine. O persoană obișnuită manual, de exemplu, va profita de ei - doar pe intuiție.

De unde a venit un astfel de nume neobișnuit?

Numele metodei a fost inventat folosind o analogie cu bulele de aer în apă. Aceasta este o metaforă. Așa cum se ridică bulele de aer mici - la urma urmei, densitatea lor este mai mare decât orice lichid (în acest caz - apă) și fiecare element al matricei, cu atât mai puțin el el, cu atât mai mult își face treptat căile spre începutul Numărul de numere.

Descrierea algoritmului

Sortați după bule se efectuează după cum urmează:

primul pasaj: Elementele matricei de numere sunt luate două și au comparat și perechile. Dacă în unele elemente, prima valoare este mai mare decât cea de-a doua, programul își produce partajarea pe teren;
În consecință, matricea se încadrează în cele din urmă. În timp ce toate celelalte elemente rămân, așa cum erau, în ordine haotică și necesită mai multe sortare;
prin urmare, este necesară a doua trecere: se face prin analogie cu precedentul (deja descris) și are o serie de comparații - minus unul;
pasajul numărul trei comparații pe unitate mai mică decât a doua și de două ori mai mică decât prima. Etc;
să rezumăm că fiecare pasaj are (valori totale într-o matrice, un număr specific) minus (numărul de trecere) al comparațiilor.

Pe scurt, algoritmul viitorului program poate fi scris după cum urmează:

o serie de numere este verificată până când se găsesc două numere, al doilea dintre ele trebuie să fie mai mult decât primul;
incorect situate în raport cu elementele de alte ale modificărilor programului de matrice în locuri.

Pseudocode pe baza algoritmului descris

Cea mai simplă implementare se efectuează după cum urmează:

Procedură Sortirovka_puzirkom.;

start

ciclu pentru j. din nachalnii_index. inainte de konechii_index.;

ciclu pentru i. din nachalnii_index. inainte de konechii_index-1.;

în cazul în care un masiv [i]\u003e masiv

(schimbați valorile în locuri);

sfarsit

Desigur, aici simplitatea agravează situația: cu cât este mai simplu algoritmul, în special în toate, toate defectele se manifestă. Costul timpului este prea mare chiar și pentru o matrice mică (există o chestiune de relativitate: pentru cea medie, cantitatea de timp poate părea mic, dar în programatorul programatorului, fiecare secundă sau chiar milisecundă în cont).

A luat realizarea mai bună. De exemplu, luând în considerare schimbul de valori în matrice în funcție de locuri:

Procedură Sortirovka_puzirkom.;

start

sortirovka. \u003d adevăr;

ciclu sortirovka. \u003d adevăr;

sortirovka. \u003d FALSE;

ciclu pentru i. din nachalnii_index. inainte de konechii_index-1.;

în cazul în care un masiv [i]\u003e masiv (Primul element este mai mare decât al doilea), apoi:

(Schimbarea elementelor în locuri);

sortirovka. \u003d adevăr; (Denotă că schimbul a fost produs).

Sfarsit.

Dezavantaje ale metodei

Principalul minus este durata procesului. Cât timp este efectuat de un balon?

Timpul de execuție este calculat din pătratul numărului de numere din matrice - rezultatul final este proporțional cu acesta.

În cazul celei mai grave versiuni, matricea va fi trecută de câte ori este în elementele IT minus o valoare. Acest lucru se datorează faptului că în cele din urmă există un singur element care nu are nimic de comparat, iar ultimul pasaj al masivului devine inutil.

În plus, metoda de sortare prin schimburi simple, așa cum se numește, de asemenea, numai pentru matrice mici. Volumele mari de date cu acesta nu vor fi procesate: rezultatul va fi fie erori, fie eșecul programului.

Demnitate

Sortați după balon este foarte simplu pentru înțelegere. În programele de curriculum ale universităților tehnice, atunci când studiați gama de elemente de matrice, este nevoie de primul. Metoda este ușor de implementat ca în limba. programarea Delphi. (D (Delphi) și C / C ++ (Si Plus), un algoritm incredibil de simplu pentru localizarea valorilor în ordinea corectă și de sortare de către bubble este ideal pentru începători.

Datorită deficiențelor, algoritmul nu se aplică în scopuri extrașcolare.

Principiul vizitatorului de sortare

Vizualizarea inițială a matricei 8 22 4 74 44 37 1 7

Pasul 1 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

Pasul 2. 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 4 22 7 74 44 37

1 4 8 22 7 74 44 37

Pasul 3. 1 4 8 22 7 74 37 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

Pasul 4. 1 4 7 8 22 37 44 74

1 4 7 8 22 37 44 74

Pasul 5. 1 4 7 8 22 37 44 74

1 4 7 8 22 37 44 74

Pasul 6. 1 4 7 8 22 37 44 74

1 4 7 8 22 37 44 74

Pasul 7. 1 4 7 8 22 37 44 74

Exemplu de sortare cu bule în Pascal

Exemplu:

const kol_mas \u003d 10;

vAR MASSIV: Gama de integrați;

a, B, K: Integer;

scrie ("intrare", kol_mas, "elemente de matrice");

pentru A: \u003d 1 până la Kol_mas face Readln (masiv [a]);

pentru A: \u003d 1 până la Kol_mas-1 începe

Pentru B: \u003d A + 1 până la Kol_mas începe

dacă Massiv [A]\u003e Massiv [B] începe apoi

k: \u003d masiv [a]; Masiv [a]: \u003d masiv [b]; Masiv [b]: \u003d k;

sfârșit;

wrideln ("după fel");

pentru A: \u003d 1 până la Kol_mas do wrideln (masiv [a]);

Exemplu de sortare de către un balon într-o limbă cu (SI)

#Include.

int principal (int argc, char * argv)

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

pentru (;) (

ff \u003d 0;

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

Dacă (masiv [i]< massiv) {

Swap (masiv [i], masiv);

dacă (ff \u003d\u003d 0);

getch (); // întârzierea ecranului

Etichete: Sortați după Bubble Si, Si sortare cu buleSortați după matricea bubble bidimensională

Sortați după Bubble.

Iar actul algoritmului este foarte simplu. Mergem prin gama de numere și verificăm comanda (următorul număr ar trebui să fie mai mult și mai egal cu cel precedent), de îndată ce au dat o încălcare a ordinului, schimbă imediat elemente în locuri, ajungem la sfârșitul anului Array, apoi începeți mai întâi.

Sortați matricea (1, 5, 2, 7, 6, 3)
Mergem pe masiv, verifică primul număr și al doilea, merg în ordine ascendentă. Apoi, există o încălcare a comenzii, schimbăm aceste elemente
1, 2, 5, 7, 6, 3
Continuăm să trecem prin matrice, 7 mai mult de 5, dar 6 mai puțin, așa că schimbăm locurile
1, 2, 5, 6, 7, 3
3 încalcă ordinea, schimbați locurile de la 7
1, 2, 5, 6, 3, 7
Ne întoarcem la începutul matricei și facem același lucru

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

Se spune că acest lucru este similar cu "plutirea" a mai multor elemente "plămâni", cum ar fi bulele, motiv pentru care algoritmul și a primit un astfel de nume. vid bubblesort (int * A, dimensiune_t dimensiune) (size_t i, j; int tmp; pentru (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;))))))

Acest algoritm va face întotdeauna (N-1) 2 pași, indiferent de datele de intrare. Chiar dacă matricea este sortată, aceasta va fi încă trecută (N-1) de 2 ori. Mai mult, datele deja sortate vor fi verificate din nou.

Să fie necesar să sortați matricea 1, 2, 4, 3

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

După ce a fost schimbată în locuri de element A și nu mai trebuie să treacă această secțiune a matricei. Luăm în considerare și presupus algoritm

Vid bubblesort2 (int * a, size_t dimensiune) (size_t i, j; int tmp; pentru (i \u003d 1; i< size; i++) { for (j = i; j > 0; j--) (dacă (a [j]< a) { tmp = a[j]; a[j] = a; a = tmp; } } } }

O altă implementare

Vid bubblesort2b (int * a, dimensiune_t dimensiune) (size_t i, j; int tmp; pentru (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; } } } }

În acest caz, vor exista o jumătate de pași, dar totuși problema de sortare a matricei deja sortate rămâne: trebuie să faceți acest lucru ca matricea sortată să fie văzută o dată. Pentru a face acest lucru, introduceți variabila de pavilion: va fi omisă (steag \u003d 0) dacă matricea este sortată. De îndată ce mergem pe o încălcare a ordinului, steagul va fi ridicat (Steag \u003d 1) și vom începe să sortăm matricea ca de obicei.

Vid bubblesort3 (int * a, dimensiune_t dimensiune) (size_t i; int tmp; char pavilion; face (pavilion \u003d 0; pentru (i \u003d 1; i< size; i++) { if (a[i] < a) { tmp = a[i]; a[i] = a; a = tmp; flag = 1; } } } while (flag); }

În acest caz, complexitatea este, de asemenea, despre N2, dar în cazul unei matrice sortate, va fi doar un pasaj.

Acum îmbunătățiți algoritmul. Vom scrie funcția formei generale, astfel încât să sorteze o gamă de tipul gol. Deoarece tipul de variabilă nu este cunoscut, va fi necesar să transmităm în continuare dimensiunea unui element de matrice și funcția de comparare.

INT INTSORT (CONST VOID * A, Const Void * B) (RETURN * ((INT *) A)\u003e * ((Int *) b); ((int *) b); CMP) (Const Void *, Const Void *) (size_t i; void * tmp \u003d null; char pavilion; tmp \u003d malloc (element); faceți (pavilionul \u003d 0; pentru (i \u003d 1; i< 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); }

Funcția arată urât - adesea se calculează adresa elementului curent și anterior. Subliniem variabile separate pentru acest lucru.

Vid bubblesort3gi (void * a, element de dimensiune_t, dimensiune_t dimensiune, int (* cmp) (const vid *, const goid *)) (size_t i; void * tmp \u003d null; vid * prev, * cur; char pavilion; TMP \u003d malloc (element); faceți (pavilionul \u003d 0; i \u003d 1; prev \u003d (char *) A; cur \u003d (char *) prev + element; în timp ce (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); }

Acum, cu aceste funcții, puteți sorta marginea oricărui tip, de exemplu

Vid principal () (int A \u003d (1, 0, 9, 8, 7, 6, 2, 3, 4, 5); int i; bubblesort3gi (a, dimensiunea (int), 10, intsort); pentru (i \u003d 0; i< 10; i++) { printf("%d ", a[i]); } _getch(); }

Sortarea matricei multidimensionale.

O matrice multidimensională statică nu este în esență diferită de sortarea unidimensională. Puteți utiliza proprietatea că marginea statică unidimensională și multidimensională au aceeași vedere în memorie.

Vid principal () (INT A \u003d (1, 9, 2, 8, 3, 7, 4, 6, 5); INT I, J; bubblesort3gi (a, dimensiunea (int), 9, intraort); pentru (i \u003d 0; i< 3; i++) { for (j = 0; j < 3; j++) { printf("%d ", a[i][j]); } } } Сортировка динамически созданного двумерного массива может быть произведена двумя способами. Во-первых, можно по определённому алгоритму находить индекс i-го и j-го элемента по порядковому номеру k от 0 до n * m. #include #Include. #Include. #Include. vid bubblesort2d (int ** a, size_t m, size_t n) (int tmp; size_t i, j, k, jp, ip; size_t dimensiune \u003d m * n; char steag; face (steag \u003d 0; pentru (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; steag \u003d 1;)) în timp ce (pavilionul); ) #Define size_x 3 #define size_y 4 goid principal (int ** a \u003d null; int i, j; a \u003d (int **) malloc (dimensiunea (int *) * size_x); pentru (i \u003d 0; I.< 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(); }

În al doilea rând, puteți să mutați mai întâi matricea la una unidimensională, sortați matricea unidimensională, apoi mutați-o înapoi în cea bidimensională.

Void Bubblesort3gi2D (VOID ** A, Size_T item, Size_T M, Size_T N, INT (* CMP) (CONST VOID *, CONST VOID *)) (Size_T Dimensiune \u003d M * N, Sub_Size \u003d N * Element; Size_t I, J , k; Void * arr \u003d malloc (dimensiune * element); char * p1d \u003d (char *) arr; char * p2d \u003d (char *) A; // copiați un tip gol tridimensional în o singură dimensiune pentru (i \u003d 0; i< 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); } }

Dacă această caracteristică vă confundă, utilizați apoi tastatura. Apelați din exemplul anterior

Sa estimat că până la un sfert de timp calculatoare centralizate Se plătește sortarea datelor. Acest lucru se datorează faptului că este mult mai ușor să găsiți o valoare într-o matrice care a fost sortată în avans. În caz contrar, căutarea este un pic ca o căutare a acului într-o haystack.

Există programatori care au efectuat toate orele de lucru în studiul și implementarea algoritmilor de sortare. Acest lucru se datorează faptului că majoritatea covârșitoare a programelor de afaceri includ gestionarea bazelor de date. Oamenii caută informații în baze de date tot timpul. Aceasta înseamnă că algoritmii de căutare sunt foarte solicitați.

Dar există unul "dar". Algoritmii de căutare funcționează mult mai repede cu bazele de date deja sortate. În acest caz, este necesară doar o căutare liniară.

În timp ce computerele sunt fără utilizatori la anumite momente de timp, algoritmii de sortare continuă să lucreze cu baze de date. Din nou, utilizatorii căutând, iar baza de date este deja sortată, pe baza unui anumit scop de căutare.

Acest articol oferă exemple de implementare a algoritmilor standard de sortare.

SIGURANȚA SELECȚIE (SELECTION SORT)

Pentru a sorta matricea în ordine ascendentă, urmați fiecare iterație pentru a găsi elementul cu cea mai mare valoare. Cu ea trebuie să schimbați ultimul element. Următorul element cu cea mai mare valoare devine locul penultim. Acest lucru ar trebui să se întâmple până când elementele care se află în primele locuri din arie nu vor fi în mod corespunzător.

Codul C ++.

void Sortalgo :: Selectsort (INT Date, Int Lend) (int j \u003d 0; int tmp \u003d 0; pentru (int i \u003d 0; i datele [K]) (J \u003d K;)) TMP \u003d Date [i]; Date [i] \u003d date [j]; Date [j] \u003d tmp; ))

BUBBLE SORT.

Cu sortarea bubble, elementele adiacente sunt comparate și se schimbă în locuri dacă elementul următor este mai mic decât cel precedent. Sunt necesare mai multe pasaje. În timpul primei treceri, primele două elemente din matrice se luptă. Dacă nu sunt în ordine, schimbă locurile și apoi comparați elementele din următoarea pereche. Cu aceeași condiție, ei schimbă și locurile. Astfel, sortarea are loc în fiecare ciclu până când se va realiza sfârșitul matricei.

Codul C ++.

void Sortalgo :: Bubblesort (INT Date, Int Lend) (int tmp \u003d 0; pentru (int i \u003d 0; i \u003d (i + 1); j -) (dacă (date [j]

Sortare de inserție (sortare de inserție)

La introducerea inserțiilor, matricea este împărțită în două zone: comandate și dezordonate. Inițial, întreaga matrice este o zonă neordonată. La prima trecere, primul element dintr-o regiune neordonată este acoperit și plasat în poziția corectă într-o zonă comandată.

La fiecare pasaj, dimensiunea unei zone ordonate crește cu 1, iar dimensiunea regiunii neordonate este redusă cu 1.

Ciclul principal operează în intervalul de la 1 la N-1. Pe iterația J-Th, elementul [I] este introdus în poziția corectă din zona comandată. Acest lucru se face prin schimbarea tuturor elementelor unei zone ordonate, care sunt mai mari decât [I], o poziție în dreapta. [i] este introdus în intervalul dintre acele elemente care sunt mai mici decât [I] și cele care sunt mai mari [i].

Codul C ++.

vOID SOFTALGO :: INFORMAȚII (INT DATA, INT LEND) (Int Key \u003d 0; Int I \u003d 0; pentru (int J \u003d 1; J \u003d 0 && date [i]\u003e cheie) (date \u003d date [i]; i \u003d i-1; date \u003d cheie;)))

Merge Sortare (Merge Sortare)

Codul C ++.

void Sortalgo :: Mergesort (INT Date, Int Lend) (dacă (Lend\u003e 1) (INT MIDDLED \u003d LEND / 2; INT REM \u003d LEND-MIDDLED; INT * L \u003d Nou Int; INT * R \u003d Nou int; pentru ( int i \u003d 0; i

Sortare rapida

Sortarea rapidă utilizează algoritmul "divizi și cuceri". Începe cu despicarea matricei originale în două zone. Aceste părți sunt situate în partea stângă și la dreapta elementului marcat numit referință. La sfârșitul procesului, o parte va conține elemente mai mici decât suportul, iar cealaltă parte va conține elemente mai multe referințe.

Codul C ++.

void Sortalgo :: Quicksort (INT * Date, 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; dacă (Lend\u003e 1) (int * l \u003d nou int; int * r \u003d nou int; pivot \u003d date; pentru (i \u003d 0; i