సి లో రాడిక్స్ సార్ట్ ప్రోగ్రామ్‌ను ఉత్తమంగా ఎలా అమలు చేయాలి?

ఈ వ్యాసం మీకు రాడిక్స్ క్రమబద్ధీకరణను పరిచయం చేస్తుంది మరియు రాడిక్స్ క్రమబద్ధీకరణను ఎలా అమలు చేయాలో మీకు తెలియజేస్తుంది C. లో ఈ వ్యాసంలో క్రింది పాయింటర్లు కవర్ చేయబడతాయి,

• రాడిక్స్ క్రమబద్ధీకరణ అల్గోరిథం
• రాడిక్స్ క్రమబద్ధీకరణ ఫంక్షన్
• కౌంట్ క్రమబద్ధీకరణ ఫంక్షన్

కాబట్టి అప్పుడు ప్రారంభిద్దాం,

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

రాడిక్స్ సార్ట్ అనేది తులనాత్మక కాని పూర్ణాంక సార్టింగ్ అల్గోరిథం. ఇది కనీసం ముఖ్యమైన అంకె (అనగా కుడి వైపున ఉన్న అంకె) నుండి చాలా ముఖ్యమైన అంకె (అంటే ఎడమ వైపున ఉన్న అంకె) నుండి అంకెల క్రమబద్ధీకరణ ద్వారా అంకెను చేస్తుంది. రాడిక్స్ సార్ట్ క్రమబద్ధీకరించడానికి సబ్‌ట్రౌటిన్‌గా లెక్కింపు క్రమాన్ని ఉపయోగిస్తుంది.
పోలిక ఆధారిత సార్టింగ్ అల్గోరిథం (హీప్ సార్ట్, క్విక్ సార్ట్, మెర్జ్ సార్ట్ వంటివి) & ఒమేగా (ఎన్ లాగ్న్) యొక్క తక్కువ పరిమితి, మరియు అవి n లాగ్‌కి మించి మెరుగుపరచబడవు. మేము లెక్కింపు క్రమబద్ధీకరణ గురించి మాట్లాడితే, ఇది O (n + k) సమయ సంక్లిష్టతతో సరళ సమయ క్రమబద్ధీకరణ అల్గోరిథం, ఇక్కడ పరిధి 1 నుండి k మధ్య ఉంటుంది. ఇప్పుడు, లెక్కింపు క్రమబద్ధీకరణలో సమస్య ఏమిటంటే, మూలకాలు 1 నుండి n2 వరకు ఉన్నప్పుడు O (n2) పడుతుంది.

కాబట్టి, సరళ సమయంలో 1 నుండి n2 వరకు ఉండే మూలకాలతో శ్రేణిని క్రమబద్ధీకరించడానికి, మాకు రాడిక్స్ క్రమబద్ధీకరణ అవసరం. రాడిక్స్ క్రమబద్ధీకరణ శ్రేణి అంకెను అంకె ద్వారా కనీసం ముఖ్యమైన అంకె నుండి చాలా ముఖ్యమైన అంకె వరకు క్రమబద్ధీకరిస్తుంది. రాడిక్స్ సార్ట్ క్రమబద్ధీకరించడానికి సబ్‌ట్రౌటిన్‌గా లెక్కింపు క్రమాన్ని ఉపయోగిస్తుంది.

సి, రాడిక్స్ సార్ట్ ప్రోగ్రామ్ పై ఈ కథనంతో ముందుకు సాగుతోంది,

పైథాన్ డెఫ్ __init__

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

కుడి వైపున ఉన్న అతి ముఖ్యమైన అంకె నుండి మొదలుకొని, ఎడమ వైపున ఉన్న చాలా ముఖ్యమైన అంకె వైపు కదులుతున్న అన్ని అంకెలకు ఈ క్రింది దశలను చేయండి.

ప్రస్తుత అంకె ప్రకారం లెక్కింపు క్రమాన్ని ఉపయోగించి మూలకాలను క్రమబద్ధీకరించండి.
ఉదాహరణ:

అసలు శ్రేణి:
140, 65, 85, 110, 612, 54, 12, 86

అతి ముఖ్యమైన అంకెను క్రమబద్ధీకరించడం అంటే ఒకరి స్థలంలో ఇస్తుంది

140, 110, 612, 12, 54, 65, 85, 86

గమనిక: 12 కి ముందు 612 కనిపిస్తుంది, మరియు సార్టింగ్ ఒకరి అంకెకు మాత్రమే జరుగుతుంది, కాబట్టి ఈ పునరావృతం తర్వాత 12 కి ముందు 612 కనిపిస్తుంది.

తదుపరి అంకెల ప్రకారం క్రమబద్ధీకరించడం, అనగా 10 సె స్థానంలో, ఇస్తుంది:

110, 612, 12, 140, 54, 65, 85, 86

జావా ఉదాహరణలో యాదృచ్ఛిక తరగతి

చాలా ముఖ్యమైన అంకెల ప్రకారం క్రమబద్ధీకరించడం, అనగా 100 ల స్థానంలో ఉంది,

012, 054, 065, 085, 086, 110, 140, 612

సి, రాడిక్స్ సార్ట్ ప్రోగ్రామ్ పై ఈ కథనంతో ముందుకు సాగుతోంది,

సి లో రాడిక్స్ క్రమబద్ధీకరణ కార్యక్రమం

రాడిక్స్ సార్టింగ్ ఫంక్షన్‌ను మొదట చూడండి

జావాలో గరిష్ట కుప్ప అమలు

రాడిక్స్ క్రమబద్ధీకరణ ఫంక్షన్:

void radixsort (int array [], int n) {// గరిష్ట సంఖ్యల సంఖ్యను తెలుసుకోవడానికి అతిపెద్ద సంఖ్యను పొందండి int m = getMax (array, n) int dig // ప్రతి అంకెకు లెక్కింపు క్రమబద్ధీకరణ జరుగుతుంది (dig = 1 m / dig> 0 dig * = 10) countSort (శ్రేణి, n, డిగ్)}

సి, రాడిక్స్ సార్ట్ ప్రోగ్రామ్ పై ఈ కథనంతో ముందుకు సాగుతోంది,

కౌంట్ క్రమబద్ధీకరణ ఫంక్షన్:

void countSort (int array [], int n, int dig) {int అవుట్పుట్ [n] int i, count [10] = {0} // (i = 0 i= 0 i--) {అవుట్పుట్ [కౌంట్ [(అర్రే [i] / డిగ్)% 10] - 1] = అర్రే [i] కౌంట్ [(అర్రే [i] / డిగ్)% 10] -} // కాపీ చేయండి అవుట్పుట్ అర్రే [] కు, కాబట్టి అర్ర్ [] ఇప్పుడు // ప్రస్తుత అంకె ప్రకారం క్రమబద్ధీకరించిన సంఖ్యలను కలిగి ఉంటుంది (i = 0 i
ముందుకు సాగడం, రాడిక్స్ క్రమబద్ధీకరణను అమలు చేయడానికి సి ప్రోగ్రామ్‌ను వ్రాద్దాం.
 ఉదాహరణ: 
# చేర్చండి // అతిపెద్ద సంఖ్యను కనుగొనే ఫంక్షన్ int getMax (int array [], int n) {int max = array [0] int i for (i = 1 i max) max = array [i] return max} // కౌంట్ సార్ట్ శూన్యమైన కౌంట్‌సోర్ట్ (Int శ్రేణి [], int n, int dig) {int output [n] int i, count [10] = {0} // గణనలో సంభవించిన సంఘటనల సంఖ్య [] కోసం (i = 0 i= 0 i--) {అవుట్పుట్ [కౌంట్ [(అర్రే [i] / డిగ్)% 10] - 1] = అర్రే [i] కౌంట్ [(అర్రే [i] / డిగ్)% 10] -} // కాపీ చేయండి (i = 0 i 0 dig * = 10) countSort (array, n, dig) for // ప్రస్తుత అంకె ప్రకారం క్రమబద్ధీకరించిన సంఖ్యలను arr [] ఇప్పుడు // కలిగి ఉంది. ప్రింట్ (int arr [], int n) {int i for (i = 0 i
 అవుట్పుట్ 
 
ఇప్పుడు పై ప్రోగ్రామ్‌ను అమలు చేసిన తర్వాత మీరు సి లో రాడిక్స్ సార్ట్ ప్రోగ్రామ్‌ను అర్థం చేసుకున్నారు. అందువల్ల మేము ‘క్విసోర్ట్ ఇన్ జావా’ పై ఈ వ్యాసం ముగింపుకు వచ్చాము. మీరు మరింత తెలుసుకోవాలనుకుంటే, చూడండి  , విశ్వసనీయ ఆన్‌లైన్ అభ్యాస సంస్థ. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు కోర్ మరియు అధునాతన జావా భావనలతో పాటు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది.
మాకు ప్రశ్న ఉందా? దయచేసి ఈ బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో దీనిని ప్రస్తావించండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.