చొప్పించడం క్రమబద్ధీకరణ అల్గోరిథంకు పరిచయం

చొప్పించడం క్రమబద్ధీకరణ అల్గోరిథంకు పరిచయం

చొప్పించడం క్రమబద్ధీకరించడం అనేది క్రమబద్ధీకరించబడిన సబ్‌లిస్ట్‌ను ఉపయోగించడం ద్వారా మరియు క్రమీకరించని జాబితా నుండి మొత్తం జాబితాను క్రమబద్ధీకరించే వరకు నిరంతరం దానికి విలువను జోడించడం ద్వారా పనిచేసే ఒక టెక్నిక్.





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



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





చొప్పించడం క్రమబద్ధీకరణకు దగ్గరగా చూడండి

పై వివరణ మీకు అర్ధం కాకపోవచ్చు. ఒక ఉదాహరణ మీకు బాగా అర్థం చేసుకోవడానికి సహాయపడుతుంది.

మీ వద్ద జాబితా ఉందని అనుకుందాం: [39, 6, 2, 51, 30, 42, 7].



క్రమబద్ధీకరించిన సబ్‌లిస్ట్ యొక్క మొదటి విలువగా అల్గోరిథం 39 ని గుర్తిస్తుంది. మూల్యాంకనం రెండవ స్థానానికి చేరుకుంటుంది.

సంబంధిత: డైనమిక్ ప్రోగ్రామింగ్: ఉదాహరణలు, సాధారణ సమస్యలు మరియు పరిష్కారాలు



6 అప్పుడు 39 తో పోల్చబడింది. 6 39 కంటే తక్కువ కాబట్టి, మొదటి స్థానంలో 6 మరియు రెండవ స్థానంలో 39 చేర్చబడ్డాయి. మొదటి పాస్ ఉత్తర్వు తర్వాత కొత్త జాబితా ఆర్డర్:

[6, 39, 2, 51, 30, 42, 7]



మూల్యాంకనం ఇప్పుడు మూడవ స్థానానికి మారుతుంది. 2 చివరి రెండు సంఖ్యలతో పోల్చబడింది మరియు తరువాత సరైన స్థానంలో చేర్చబడుతుంది. ఇప్పుడు రెండవ పాస్ అయిన తర్వాత కొత్త జాబితా ఆర్డర్:

[2, 6, 39, 51, 30, 42, 7]

మూడవ పాస్ కోసం, జాబితా ఆర్డర్:

[2, 6, 39, 51, 30, 42, 7]

మొత్తం జాబితా క్రమబద్ధీకరించబడే వరకు ప్రక్రియ పునరావృతమవుతుంది.

ఈ కార్యకలాపాలను సంగ్రహించే దిగువ రేఖాచిత్రాన్ని చూడండి:

అల్గోరిథం విశ్లేషణ

చొప్పించే క్రమీకరణ యొక్క సమయ సంక్లిష్టత O (n2), లాగానే బుడగ క్రమం . చెత్త దృష్టాంతంలో పోలికల సంఖ్య 1 నుండి (n-1) వరకు ఉన్న పూర్ణాంకాల మొత్తం, ఇది చతురస్ర మొత్తాన్ని ఇస్తుంది.

కోడ్ అమలు

దిగువ ఉన్న పైథాన్ మరియు జావా కోడ్ మీరు చొప్పించే క్రమీకరణ పద్ధతిని ఎలా అమలు చేయవచ్చో చూపుతుంది.

పైథాన్:

def insertionSort(mylist):
for step in range(1, len(mylist)):
current_element = mylist[step]
position = step
while position > 0 and mylist[position - 1] > current_element:
mylist[position] = mylist[position - 1]
position = position - 1
mylist[position] = current_element

జావా:

void insertionSort(int[] myarray) {
int n = myarray.length;
for (int x = 1; x int key = myarray[x];
int y = x-1;
while ( (y > -1) && ( myarray [y] > key ) ) {
myarray [y+1] = myarray [y];
y--;
}
myarray[y+1] = key;
}
}

సూడోకోడ్‌తో మెరుగైన కోడింగ్

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

ప్రోగ్రామ్ లాజిక్ మరింత క్లిష్టంగా మారడంతో ఈ విధానం దురదృష్టవశాత్తు లోపాలకు గురవుతుంది. సూడోకోడ్‌ను ఎలా ఉపయోగించాలో నేర్చుకోవడం ద్వారా మీ ప్రోగ్రామింగ్ గేమ్‌ని ఎలా సమం చేయాలనుకుంటున్నారు?

షేర్ చేయండి షేర్ చేయండి ట్వీట్ ఇమెయిల్ సూడోకోడ్ అంటే ఏమిటి మరియు అది మిమ్మల్ని మెరుగైన డెవలపర్‌గా ఎలా చేస్తుంది?

ప్రోగ్రామింగ్ నేర్చుకోవడానికి కష్టపడుతున్నారా? సూడోకోడ్ నేర్చుకోవడం ద్వారా కోడ్‌తో పట్టు సాధించండి. అయితే సూడోకోడ్ అంటే ఏమిటి మరియు ఇది నిజంగా సహాయపడుతుందా?

తదుపరి చదవండి సంబంధిత అంశాలు
  • ప్రోగ్రామింగ్
  • జావా
  • పైథాన్
  • కోడింగ్ ట్యుటోరియల్స్
రచయిత గురుంచి జెరోమ్ డేవిడ్సన్(22 కథనాలు ప్రచురించబడ్డాయి)

జెరోమ్ MakeUseOf లో స్టాఫ్ రైటర్. అతను ప్రోగ్రామింగ్ మరియు లైనక్స్ గురించి కథనాలను కవర్ చేస్తాడు. అతను క్రిప్టో iత్సాహికుడు మరియు క్రిప్టో పరిశ్రమపై ఎల్లప్పుడూ ట్యాబ్‌లను ఉంచుతాడు.

హార్డ్ డ్రైవ్ వైఫల్యం కోసం ఎలా తనిఖీ చేయాలి
జెరోమ్ డేవిడ్సన్ నుండి మరిన్ని

మా వార్తాలేఖకు సభ్యత్వాన్ని పొందండి

టెక్ చిట్కాలు, సమీక్షలు, ఉచిత ఈబుక్‌లు మరియు ప్రత్యేకమైన డీల్స్ కోసం మా వార్తాలేఖలో చేరండి!

సభ్యత్వం పొందడానికి ఇక్కడ క్లిక్ చేయండి