సార్టింగ్ ప్రోగ్రామింగ్ పద్ధతులు: "బుడగ" సార్టింగ్

బబుల్ సార్ట్ మాత్రమే, వేగవంతమైన పద్ధతిగా పరిగణించబడుతుంది కాదు అంతేకాక, అది నిర్వహించడానికి మందకొడి మార్గాలు జాబితా ముగుస్తాయి ఉంది. అయితే, దాని ప్రయోజనాలను కలిగి ఉంది. అందువలన, బబుల్ సార్టింగ్ పద్ధతి - చాలా ఎవరికీ మీరు ఒక నిర్దిష్ట క్రమంలో అంశాలను ఏర్పాట్లు అనుకుంటే, సమస్యకు ఒక సహజ మరియు తార్కిక పరిష్కారం. కేవలం అంతర్ - ఒక సాధారణ వ్యక్తి మానవీయంగా, ఉదాహరణకు, ఇది వాటిని ఉపయోగిస్తాము.

ఇక్కడ అటువంటి ఒక అసాధారణ పేరు చేసింది?

పద్ధతి పేరు నీటిలో గాలి బుడగలు యొక్క సారూప్యత ఉపయోగించి, ముందుకు వచ్చారు. ఇది ఒక రూపకం వార్తలు. కేవలం కొద్దిగా గాలి బుడగలు పైకి పెరుగుతుంది - వాటి సాంద్రత ఒక ద్రవం (ఈ సందర్భంలో - నీరు) కంటే ఎక్కువగా ఉంటుంది ఎందుకంటే, మరియు ప్రతి శ్రేణి మూలకం, చిన్న అది విలువ, జాబితా సంఖ్యల అగ్ర మరింత క్రమంగా మార్గం.

అల్గోరిథం యొక్క వివరణ

క్రింది బబుల్ సార్ట్ నిర్వహిస్తారు:

• మొదటి పాస్: శ్రేణి సంఖ్యల అంశాలు రెండు జతల తీసుకున్న మరియు కూడా పోల్చబడుతుంది. రెండు మనిషి జట్టు మొదటి విలువ కొన్ని అంశాలు రెండవ కంటే ఎక్కువ ఉంటే, కార్యక్రమం వాటిని మార్పిడి ప్రదేశాలను;
• పర్యవసానంగా, అత్యధిక సంఖ్యలో మిసెస్ శ్రేణి ముగింపు. అన్ని ఇతర మూలకాలను ఒక అస్తవ్యస్తమైన పద్ధతిలో, వారు వంటి ఉంటాయి, మరియు మరింత సార్టింగ్ అవసరం ఉండగా;
• అందువలన రెండవ పాస్ అవసరం: ఇది తో సారూప్యత ద్వారా తయారు చేస్తారు మునుపటి (ఇప్పటికే వివరించిన) మరియు పోలికలు ఉన్నాయి - మైనస్ ఒకటి;
• ప్రకరణము సంఖ్య మూడు పోలికలు, రెండవ కంటే తక్కువ, మరియు రెండు, మొదటి కంటే వద్ద. మరియు;
• గద్యానికి కలిగి (ప్రకరణము సంఖ్య) పోలికలు (అన్ని వ్యూహంలో విలువలు, నిర్దిష్ట సంఖ్య) మైనస్ సంగ్రహించేందుకు.

ఒక కార్యక్రమం కూడా తక్కువ అల్గోరిథం వ్రాయవచ్చు:

• సంఖ్యల వ్యూహం వాటిలో రెండవ మొదటి కంటే ఎక్కువ అని పరిధిలోనే ఉంటుంది, ఏ రెండు సంఖ్యల కనిపిస్తాయి ఉన్నంత పరిశీలించుటకు;
• తప్పుగా శ్రేణి సాఫ్ట్వేర్ మార్పిడులు ప్రతి ఇతర అంశాలు సంబంధించి స్థానంలో.

Pseudocode వివరించిన అల్గోరిథం ఆధారంగా

సరళమైన అమలు క్రింది విధంగా నిర్వహిస్తారు:

Sortirovka_Puzirkom విధానం;

ప్రారంభించి

konechii_index వరకు nachalnii_index నుండి j కోసం చక్రం;

konechii_index -1 nachalnii_index నుండి నేను చక్రం;

ఉంటే massiv [i]> massiv [i + 1] (మొదటి మూలకం రెండవ కంటే ఎక్కువ), అప్పుడు:

(మార్పు ఉంచాడు విలువలు);

ముగింపు

వాస్తవానికి, ఈ సరళత మాత్రమే పరిస్థితి తీవ్రమవుతుంది: సరళమైన అల్గోరిథం, మరింత అది అన్ని లోపాలు విశదపరుస్తుంది. సమయం పెట్టుబడి నిష్పత్తి కూడా ఒక చిన్న శ్రేణి చాలా బాగుంది (ఇక్కడ సాపేక్షత వస్తుంది: ఒక ప్రోగ్రామర్ ప్రతి రెండవ లేదా మిల్లీసెకను గణనలు చదువురాని కోసం మొత్తం సమయం చిన్న అనిపించవచ్చు ఉండవచ్చు, కానీ నిజానికి).

అవసరమైన మంచి అమలు. ఉదాహరణకు, అర్రే స్థానాలను విలువల మార్పిడి పరిగణలోకి తీసుకొని:

Sortirovka_Puzirkom విధానం;

ప్రారంభించి

sortirovka = నిజమైన;

చక్రం sortirovka నిజమైన = వరకు;

sortirovka = తప్పుడు;

konechii_index -1 nachalnii_index నుండి నేను చక్రం;

ఉంటే massiv [i]> massiv [i + 1] (మొదటి మూలకం రెండవ కంటే ఎక్కువ), అప్పుడు:

(మూలకాలు ప్రదేశాలు మార్పు);

sortirovka = నిజమైన; (గుర్తించారు మార్పిడి చేయబడింది).

ముగింపు.

పరిమితులు

ప్రధాన అననుకూలత - ప్రక్రియ వ్యవధి. ఎంత సమయం నిర్వహిస్తారు అల్గోరిథం సార్టింగ్ బబుల్?

ప్రధాన సమయం శ్రేణి లో చదరపు సంఖ్యల సంఖ్య నుండి లెక్కించిన - ఇది యొక్క అంతిమ నిష్పత్తిలో ఉంటుంది.

శ్రేణి సార్లు ముగిసింది చెత్త సందర్భంలో ఉంటే అది ఒక విలువ మైనస్ అంశాలుంటాయి వంటి. ముగింపు లో పోల్చడానికి ఏమీ కలిగి ఒకే మూలకం ఎందుకంటే, ఇది జరుగుతుంది, మరియు శ్రేణి ద్వారా గత పాస్ పనికిరాని చర్య అవుతుంది.

అదనంగా, అది మాత్రమే చిన్న పరిమాణం యొక్క శ్రేణుల కోసం, అంటారు వంటి, ఒక సాధారణ మార్పిడి సార్టింగ్ యొక్క సమర్థవంతమైన పద్ధతి. ప్రక్రియ యొక్క సహాయంతో అధిక మొత్తంలో డేటాను పనిచేయవు: ఫలితంగా ఒక లోపం లేదా ప్రోగ్రామ్ వైఫల్యం గాని ఉంటుంది.

గౌరవం

బబుల్ సార్ట్ అర్థం చాలా సులభం. దాని శ్రేణి రుసుం అంశాల అధ్యయనంలో సాంకేతిక విశ్వవిద్యాలయాలకు సంబంధించి కరికులం మొదటి స్థానంలో పాస్. పద్ధతి డెల్ఫీ ప్రోగ్రామింగ్ భాష రెండింటినీ (L (డెల్ఫీ), మరియు C / C ++ (C / C ప్లస్ ప్లస్), కుడి క్రమంలో మరియు నగర అల్గోరిథం యొక్క ఒక చాలా సాధారణ విలువలు అమలు సులభం పాస్కల్ (పాస్కల్). బబుల్ సార్ట్ ప్రారంభకులకు ఆదర్శ ఉంది.

అల్గోరిథం యొక్క ప్రతికూలతలు కారణంగా బడి ప్రయోజనాల లో ఉపయోగిస్తారు లేదు.

విజువల్ విభజన సూత్రం

శ్రేణి 8 22 4 74 44 37 1 7 యొక్క ప్రారంభ వీక్షణ

దశ 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

దశ 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

దశ 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

దశ 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

దశ 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

6 దశ 4 1 7 8 22 37 44 74

1 4 7 8 22 37 44 74

దశ 7 1 4 7 8 22 37 44 74

పాస్కల్ బబుల్ సార్ట్ ఉదాహరణకు

ఉదాహరణకు:

కాన్స్ట్ kol_mas = 10;

var massiv: శ్రేణి [1..kol_mas] యొక్క పూర్ణాంక;

a, b, K: పూర్ణాంక;

ప్రారంభం

writeln ( 'ఇన్పుట్', kol_mas, 'అర్రే యొక్క మూలకాల');

ఒక: = 1 kol_mas వరకు readln చేయండి (massiv [ఒక ]);

ఒక కోసం: = 1 kol_mas-1 ప్రారంభం చేయాలని

బి కోసం: = a + 1 kol_mas ప్రారంభం లేదు

massiv [ఒక]> massiv [ఉంటే b] అప్పుడు ప్రారంభమవుతుంది

K: = massiv [ఒక]; massiv [ఒక]: = massiv [ b]; massiv [b]: = k;

అంతం;

అంతం;

అంతం;

writeln ( 'ఆలాగున');

ఒక కోసం: = 1 kol_mas వరకు writeln చేయండి (massiv [ఒక ]);

ముగింపు.

ఉదాహరణకు బబుల్ సి భాషలో విభజన (సి)

ఉదాహరణకు:

# ఉన్నాయి

# ఉన్నాయి

Int ప్రధాన (Int argc, చార్ * argv [])

{

పూర్ణాంకానికి massiv [8] = {36, 697, 73, 82, 68, 12, 183, 88} i, ff;

(;;) కోసం {

ff = 0;

కోసం (i = 7; i> 0; i -) {

ఉంటే (massiv [i] [i- 1]) {

స్వాప్ (massiv [i], massiv [i- 1]);

ff ++;

}

}

ఉంటే (FF == 0) బ్రేక్;

}

getch (); // ప్రదర్శన ఆలస్యం

తిరిగి 0;

}.