Pagbubukod-bukod ng mga diskarte sa programming: pagbubukod-bukod ng "bubble"

bubble-uuri ay hindi lamang itinuturing na ang pinakamabilis na paraan, bukod doon, ito magsasara ang listahan ng mga pinakamabagal na paraan upang ayusin. Gayunman, ito ay may pakinabang. Kaya, ang mga paraan ng pagbubukod-bukod ng bubble - ang pinaka-na wala ay isang natural at lohikal na solusyon sa problema, kung nais mo upang ayusin ang mga item sa isang tiyak na pagkakasunod-sunod. Isang ordinaryong tao nang manu-mano, halimbawa, ito ay gamitin ang mga ito - sa pamamagitan lamang ng intuwisyon.

Saan ginawa tulad ng isang hindi karaniwang pangalan?

Pamamaraan pangalan ko ay dumating up, gamit ang pagkakatulad ng mga naka bula sa tubig. Ito ay isang metapora. Tulad ng maliit na hangin mga bula tumaas paitaas - dahil ang kanilang density ay mas malaki kaysa sa isang tuluy-tuloy (sa kasong ito - ang tubig), at ang bawat element ng array, ang mas maliit na ito ay ang halaga, ang mas banayad na paraan upang ang tuktok ng mga numero ng listahan.

Paglalarawan ng algorithm

bubble sort ay ginanap tulad ng sumusunod:

• unang pass: ang mga elemento ng array numero ay nakuha sa pamamagitan ng dalawang mga pares at din kung ikukumpara. Kung ang ilang mga elemento ng unang halaga koponan ng dalawang tao ay mas malaki kaysa sa pangalawa, ang programa ay gumagawa ng mga ito exchange lugar;
• dahil dito, ang pinakamalaking bilang ng mga misses sa dulo ng array. Habang ang lahat ng iba pang mga elemento ay mananatiling bilang sila ay, sa isang magulong paraan, at nangangailangan ng mas uuri-uri;
• at sa gayon ay nangangailangan ng isang pangalawang pass: ito ay ginawa sa pamamagitan ng pagkakatulad sa nakaraang (na inilarawan) at may isang bilang ng mga paghahambing - minus isa;
• sa pagpasa number tatlong mga paghahambing, isa mas mababa kaysa sa pangalawa, at ang dalawa, kaysa sa una. At iba pa;
• ibuod ang bawat talata ay may (lahat ng mga halaga sa array, ang partikular na numero) minus (pagpasa number) paghahambing.

Mas maikli algorithm ng programa ay maaaring nakasulat bilang:

• isang array ng mga numero ay naka-check hangga't anumang dalawang numero ay natagpuan, ang pangalawang ng mga ito ay nakasalalay sa maging mas malaki kaysa sa una;
• hindi tama nakaposisyon may kaugnayan sa bawat iba pang mga elemento ng swaps array software.

Pseudocode batay sa mga algorithm ng inilarawan

Ang pinakasimpleng pagpapatupad ay natupad tulad ng sumusunod:

Sortirovka_Puzirkom pamamaraan;

simula

cycle para sa j mula nachalnii_index na konechii_index;

cycle para i mula nachalnii_index na konechii_index-1;

kung massiv [i]> massiv [i + 1] (unang elemento mas malaki kaysa sa isang segundo), pagkatapos ay:

(Baguhin naglalagay values);

katapusan

Of course, ito simple lang lalala ang sitwasyon: ang mas simpleng algorithm, mas ito manifests ang lahat ng mga flaws. Investment ratio ng panahon ay masyadong malaki kahit na para sa isang maliit na array (dito lumapit sa kapamanggitan: Ang halaga ng oras para sa karaniwang tao ay maaaring mukhang maliit, ngunit sa katunayan ng isang programmer bawat segundo o kahit millisecond counts).

Kinuha ito ang mas mahusay na pagpapatupad. Halimbawa, nang isinasaalang-alang ang exchange ng mga halaga sa mga lokasyon array:

Sortirovka_Puzirkom pamamaraan;

simula

sortirovka = true;

cycle hanggang sortirovka = true;

sortirovka = false;

cycle para i mula nachalnii_index na konechii_index-1;

kung massiv [i]> massiv [i + 1] (unang elemento mas malaki kaysa sa isang segundo), pagkatapos ay:

(Baguhin ang mga elemento lugar);

sortirovka = true; (Kinilala na ang exchange ay ginawa).

End.

limitasyon

Ang pangunahing kasahulan - ang tagal ng proseso. Gaano karaming oras ay ginanap sa pag-uuri algorithm bubble?

Lead ng panahon ay kinakalkula mula sa bilang ng mga parisukat na mga numero sa array - ang resulta ng mga ito ay proporsyonal.

Kung ang pinakamasama kaso ng array ay naipasa bilang maraming beses hangga't ito ay may mga elemento minus one halaga. Nangyayari ito dahil sa katapusan mayroon lamang isang sangkap, na kung saan ay wala na ihambing, at ang huling pass sa pamamagitan ng array ay nagiging walang silbi pagkilos.

Sa karagdagan, ang mga epektibong paraan ng pag-uuri ng isang simpleng exchange, tulad ng ito ay tinatawag na, lamang para sa arrays ng mga maliliit na laki. Malaking halaga ng data sa tulong ng mga proseso ay hindi gumagana: ang resulta ay alinman sa isang error o pagkabigo ng programa.

dignidad

bubble-uuri ay mas madali upang maunawaan. Ang curricula ng teknikal na unibersidad sa pag-aaral ng mga elemento sa pag-order ng kanyang array pumasa sa unang lugar. Ang pamamaraan ay madaling ipatupad ang parehong mga Delphi programming language (L (Delphi), at ang C / C ++ (C / C plus plus), isang hindi kapani-paniwalang simpleng mga halaga ng algorithm lokasyon sa tamang pagkakasunod-sunod at sa Pascal (Pascal). Bubble-uri-uriin ay perpekto para sa mga nagsisimula.

Dahil sa mga drawbacks ng algorithm ay hindi na ginagamit sa mga ekstrakurikular na mga layunin.

Visual na pag-uuri prinsipyo

Ang unang view ng array 8 22 4 74 44 37 1 7

Hakbang 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

Hakbang 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 22 4 7 74 44 37

1 8 4 22 7 74 44 37

1 4 8 22 7 74 44 37

Hakbang 3 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

Hakbang 4 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

Hakbang 5 1 4 7 8 22 37 44 74

1 4 7 8 22 37 44 74

1 4 7 8 22 37 44 74

Hakbang 6 1 4 7 8 22 37 44 74

1 4 7 8 22 37 44 74

Hakbang 7 1 4 7 8 22 37 44 74

bubble sort halimbawa sa Pascal

halimbawa:

const kol_mas = 10;

var massiv: array [1..kol_mas] ng integer;

a, b, k: integer;

magsimula

writeln ( 'input', kol_mas, 'elemento ng array');

para sa isang: = 1 sa kol_mas gawin readln (massiv [a ]);

para sa isang: = 1 sa kol_mas-1 gawin magsisimulang

para sa b: = isang + 1 upang kol_mas ko sisimulan

kung massiv [a]> massiv [ b] at pagkatapos ay magsisimulang

k: = massiv [a]; massiv [a]: = massiv [ b]; massiv [b]: = k;

end;

end;

end;

writeln ( 'pagkatapos-uri-uriin');

para sa isang: = 1 sa kol_mas gawin writeln (massiv [a ]);

dulo.

EXAMPLE bubble-uuri-uri sa C wika (C)

halimbawa:

#include

#include

int main (int argc, magpasinda * argv [])

{

int massiv [8] = {36, 697, 73, 82, 68, 12, 183, 88}, i, ff;

para sa (;;) {

ff = 0;

para sa (i = 7; i> 0; i -) {

kung (massiv [i] [i- 1]) {

swap (massiv [i], massiv [i- 1]);

ff ++;

}

}

kung (ff == 0) break;

}

getch (); // display pagkaantala

bumalik 0;

}.