పైథాన్‌లో బబుల్ సార్టింగ్‌ను ఎలా అమలు చేయాలి?

క్రమబద్ధీకరించడం అంటే మూలకాల మధ్య కొంత సరళ సంబంధం ప్రకారం ఏదైనా డేటాను పెరుగుతున్న లేదా తగ్గుతున్న క్రమంలో అమర్చడం. బబుల్ క్రమబద్ధీకరణపై ఈ వ్యాసం ఈ భావనను వివరంగా అర్థం చేసుకోవడానికి మీకు సహాయం చేస్తుంది.

మేము ఈ బ్లాగులో ఈ క్రింది అంశాలను కవర్ చేస్తాము:

• బబుల్ సార్ట్ అంటే ఏమిటి?
• బబుల్ సార్టింగ్ చేయడానికి దశలు
• బబుల్ క్రమబద్ధీకరణ అల్గోరిథం
• పైథాన్ ప్రోగ్రామ్ అమలు చేయడానికి ent బబుల్ క్రమబద్ధీకరించు

బబుల్ క్రమబద్ధీకరణ అంటే ఏమిటి?

బబుల్ సార్ట్‌ను సింకింగ్ సార్ట్ అని కూడా అంటారు. ఇది సరళమైన సార్టింగ్ అల్గోరిథం, క్రమబద్ధీకరించాల్సిన జాబితా ద్వారా నిరంతరం అడుగులు వేస్తుంది, ప్రతి జత ప్రక్కనే ఉన్న వస్తువులను పోల్చి, సరైన క్రమంలో లేకపోతే వాటిని మార్చుకుంటుంది. ఎక్కువ మార్పిడులు అవసరం వరకు దశలు పునరావృతమవుతాయి, ఇది జాబితా క్రమబద్ధీకరించబడినప్పుడు.

బబుల్ సార్టింగ్ చేయడానికి దశలు

• జాబితాలోని మొదటి మరియు రెండవ మూలకాన్ని సరిపోల్చండి మరియు అవి తప్పు క్రమంలో ఉంటే స్వాప్ చేయండి.
• రెండవ మరియు మూడవ మూలకాన్ని సరిపోల్చండి మరియు అవి తప్పు క్రమంలో ఉంటే వాటిని మార్చుకోండి.
• ఇదే తరహాలో జాబితా యొక్క చివరి మూలకం వరకు అదే విధంగా కొనసాగండి.
• జాబితా క్రమబద్ధీకరించబడే వరకు పై దశలన్నింటినీ పునరావృతం చేయండి.

పై దశలు క్రింది విజువలైజేషన్ల ద్వారా మరింత స్పష్టంగా కనిపిస్తాయి -

జావాలో సంఖ్యను ఎలా రివర్స్ చేయాలి

బబుల్ క్రమబద్ధీకరణ అల్గోరిథం

ఇప్పుడు బబుల్ సార్ట్ వెనుక ఉన్న అల్గోరిథం చూద్దాం.

మొదటి పాస్:

( 16.19 , 11,15,10) -> ( 16.19 , 11,15,10) - అల్గోరిథం మొదటి రెండు మూలకాలను పోల్చి 19> 16 నుండి మార్పిడి చేస్తుంది

(16, 19.11 , 15.10) -> (16, 11.19 , 15.10) - 19> 11 నుండి మార్చుకోండి

(16.11, 19.15 , 10) -> (16,11, 15.19 , 10) - 19> 15 నుండి మార్చుకోండి

(16,11,15, 19.10 ) -> (16,11,15, 10.19 ) - ఇప్పుడు, ఈ అంశాలు ఇప్పటికే సరైన క్రమంలో ఉన్నందున (19> 10), అల్గోరిథం వాటిని మార్చుకోదు.

రెండవ పాస్:

( 16.11 , 15,10,19) -> ( 11.16 , 15,10,19) - 16> 11 నుండి మార్చుకోండి

(పదకొండు, 16.15 , 10.19) -> (11, 15.16 , 10,19) - 16> 15 నుండి మార్చుకోండి

(11.15, 16.10 , 19) -> (11,15, 10.16 , 19) - 16> 10 నుండి మార్చుకోండి

(11,15,10,16,19) -> (11,15,10,16,19)

ది క్రమబద్ధీకరించబడింది, కానీ అది పూర్తయిందో మా ఆల్గోకు తెలియదు. అందువల్ల, ఇది క్రమబద్ధీకరించబడిందని తెలుసుకోవడానికి ఎటువంటి స్వాప్ లేకుండా మరొక మొత్తం పాస్ అవసరం.

జావాలో ఇటరేటర్ ఎలా ఉపయోగించాలి

మూడవ పాస్:

(పదకొండు, 15.10 , 16,19) -> (11, 15.10 , 16,19)

(పదకొండు, 15.10 , 16,19) -> (11, 10.15 , 16,19) - 15> 10 నుండి మార్చుకోండి

(11,10,15,16,19) -> (11,10,15,16,19)

(11,10,15,16,19) -> (11,10,15,16,19)

నాల్గవ పాస్:

( 11.10 , 15,16,19) -> ( 10.11 , 15,16,19) - 11> 10 నుండి మార్చుకోండి

తుది ఉత్పత్తి (10,11,15,16,19)

ఇప్పుడు దీనిని కోడ్ చేద్దాం -

బబుల్ క్రమబద్ధీకరణను అమలు చేయడానికి పైథాన్ ప్రోగ్రామ్

a = [16, 19, 11, 15, 10, 12, 14]

# రిపీటింగ్ లూప్ లెన్ (ఎ) (మూలకాల సంఖ్య) పరిధిలో j కోసం ఎన్నిసార్లు (లెన్ (ఎ)): # ప్రారంభంలో ఇచ్చిపుచ్చుకోవడం తప్పుడు మార్పిడి = తప్పు i = 0 అయితే ia [i + 1]: # ఒక [i ], a [i + 1] = a [i + 1], a [i] # ఇచ్చిపుచ్చుకున్న విలువను మార్చడం = నిజం i = i + 1 # ఇచ్చిపుచ్చుకోవడం అబద్ధం అప్పుడు జాబితా క్రమబద్ధీకరించబడుతుంది # మేము లూప్‌ను ఆపవచ్చు మార్చుకుంటే == తప్పు: బ్రేక్ ప్రింట్ (ఎ)

 అవుట్పుట్: 

పై కోడ్‌లో, మేము ప్రక్కనే ఉన్న సంఖ్యలను పోల్చి, అవి సరైన క్రమంలో లేకపోతే వాటిని మార్చుకుంటాము. అదే విధానాన్ని లెన్ (ఎ) ఎన్నిసార్లు చేయండి. మేము ఒక వేరియబుల్ ‘ఇచ్చిపుచ్చుకున్నది’ కేటాయించాము మరియు ఏదైనా రెండు మూలకాలను పునరావృతంలో మార్చుకుంటే దాన్ని ‘ట్రూ’ చేసాము. మూలకాల యొక్క పరస్పర మార్పిడి లేకపోతే, జాబితా ఇప్పటికే క్రమబద్ధీకరించబడింది మరియు అందువల్ల, ‘మార్పిడి’ విలువలో ఎటువంటి మార్పు లేదు మరియు మేము లూప్‌ను విచ్ఛిన్నం చేయవచ్చు.

దీనితో, “పైథాన్‌లో బబుల్ సార్టింగ్‌ను ఎలా అమలు చేయాలి” అనే శీర్షికతో బ్లాగు ముగింపుకు వచ్చాము. మీ పైథాన్ జ్ఞానానికి కంటెంట్ అదనపు విలువను ఇస్తుందని నేను ఆశిస్తున్నాను.

మాకు ప్రశ్న ఉందా? దయచేసి ఈ “పైథాన్‌లో బబుల్ క్రమబద్ధీకరణను ఎలా అమలు చేయాలి” బ్లాగులోని వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.

సి ++ కోడ్‌ను విలీనం చేయండి

పైథాన్‌తో పాటు దాని వివిధ అనువర్తనాలతో లోతైన జ్ఞానం పొందడానికి, మీరు ప్రత్యక్ష ప్రసారం కోసం నమోదు చేసుకోవచ్చు 24/7 మద్దతు మరియు జీవితకాల ప్రాప్యతతో.