C இல் பைனரி மரம்
C இல், ஏ பைனரி மரம் அதிகபட்சமாக இரண்டு சைல்டு நோட்களைக் கொண்டிருக்கக்கூடிய பெற்றோர் முனையுடன் கூடிய மரத் தரவுக் கட்டமைப்பின் ஒரு நிகழ்வாகும்; 0, 1, அல்லது 2 சந்ததி முனைகள். a இல் உள்ள ஒவ்வொரு முனையும் பைனரி மரம் அதன் சொந்த மதிப்பையும் அதன் குழந்தைகளுக்கு இரண்டு சுட்டிகளையும் கொண்டுள்ளது, இடது குழந்தைக்கு ஒரு சுட்டி மற்றும் மற்றொன்று வலது குழந்தைக்கு.
பைனரி மரத்தின் பிரகடனம்
ஏ பைனரி மரம் எனப்படும் ஒரு பொருளைப் பயன்படுத்தி C இல் அறிவிக்கலாம் கட்டமைக்க இது மரத்தில் உள்ள முனைகளில் ஒன்றை சித்தரிக்கிறது.
கட்டமைக்க முனை {
தரவு வகை var_name ;
கட்டமைக்க முனை * விட்டு ;
கட்டமைக்க முனை * சரி ;
} ;
மேலே ஒரு பிரகடனம் உள்ளது பைனரி மரம் ஒரு முனையாக முனை பெயர். இது மூன்று மதிப்புகளைக் கொண்டுள்ளது; ஒன்று தரவு சேமிப்பு மாறி மற்றும் மற்ற இரண்டு குழந்தைக்கு சுட்டிகள். (பெற்றோர் முனையின் இடது மற்றும் வலது குழந்தை).
பைனரி மரத்தின் உண்மைகள்
பெரிய அளவிலான தரவுகளுக்கு கூட, a ஐப் பயன்படுத்துகிறது பைனரி மரம் தேடலை எளிதாகவும் விரைவாகவும் செய்கிறது. மரக் கிளைகளின் எண்ணிக்கை மட்டுப்படுத்தப்படவில்லை. ஒரு வரிசைக்கு மாறாக, ஒரு தனிநபருக்கு என்ன தேவையோ அதன் அடிப்படையில் எந்த வகையான மரங்களையும் உருவாக்கலாம் மற்றும் அதிகரிக்கலாம்.
C இல் பைனரி மரம் செயல்படுத்தல்
பின்வரும் ஒரு படி-படி-படி-செயல்படுத்துவதற்கான வழிகாட்டி பைனரி மரம் C இல்
படி 1: பைனரி தேடல் மரத்தை அறிவிக்கவும்
தரவு, *left_child மற்றும் *right_child போன்ற மூன்று வகையான தரவைக் கொண்ட ஒரு struct nodeஐ உருவாக்கவும், அங்கு தரவு முழு எண் வகையாக இருக்கலாம், மேலும் *left_child மற்றும் *right_child ஆகிய இரண்டும் NULL என அறிவிக்கப்படலாம் அல்லது இல்லை.
கட்டமைக்க முனை{
முழு எண்ணாக தகவல்கள் ;
கட்டமைக்க முனை * வலது_குழந்தை ;
கட்டமைக்க முனை * இடது_குழந்தை ;
} ;
படி 2: பைனரி தேடல் மரத்தில் புதிய முனைகளை உருவாக்கவும்
ஒரு முழு எண்ணை ஒரு வாதமாக ஏற்றுக்கொண்டு, அந்த மதிப்புடன் உருவாக்கப்பட்ட புதிய முனைக்கு சுட்டியை வழங்கும் செயல்பாட்டை உருவாக்குவதன் மூலம் ஒரு புதிய முனையை உருவாக்கவும். உருவாக்கப்பட்ட முனைக்கான டைனமிக் நினைவக ஒதுக்கீட்டிற்கு, சி இல் malloc() செயல்பாட்டைப் பயன்படுத்தவும். இடது மற்றும் வலது குழந்தையை NULL க்கு துவக்கி, nodeName ஐ திரும்பவும்.
கட்டமைக்க முனை * உருவாக்க ( தரவு வகை தரவு )
{
கட்டமைக்க முனை * முனை பெயர் = malloc ( அளவு ( கட்டமைக்க முனை ) ) ;
முனை பெயர் -> தகவல்கள் = மதிப்பு ;
முனை பெயர் -> இடது_குழந்தை = முனை பெயர் -> வலது_குழந்தை = ஏதுமில்லை ;
திரும்ப முனை பெயர் ;
}
படி 3: பைனரி மரத்தில் வலது மற்றும் இடது குழந்தைகளைச் செருகவும்
இரண்டு உள்ளீடுகளை ஏற்கும் insert_left மற்றும் insert_right செயல்பாடுகளை உருவாக்கவும், அவை செருகப்பட வேண்டிய மதிப்பு மற்றும் இரு குழந்தைகளும் இணைக்கப்படும் முனைக்கு சுட்டிக்காட்டி. ஒரு புதிய முனையை உருவாக்க உருவாக்கு செயல்பாட்டை அழைக்கவும் மற்றும் திரும்பிய சுட்டியை இடது குழந்தையின் இடது சுட்டிக்காட்டி அல்லது ரூட் பெற்றோரின் வலது குழந்தையின் வலது சுட்டிக்காட்டிக்கு ஒதுக்கவும்.
கட்டமைக்க முனை * insert_left ( கட்டமைக்க முனை * வேர் , தரவு வகை தரவு ) {வேர் -> விட்டு = உருவாக்க ( தகவல்கள் ) ;
திரும்ப வேர் -> விட்டு ;
}
கட்டமைக்க முனை * செருகு_வலது ( கட்டமைக்க முனை * வேர் , தரவு வகை தரவு ) {
வேர் -> சரி = உருவாக்க ( தகவல்கள் ) ;
திரும்ப வேர் -> சரி ;
}
படி 4: டிராவர்சல் முறைகளைப் பயன்படுத்தி பைனரி மரத்தின் முனைகளைக் காண்பி
C இல் பயணிக்கும் மூன்று முறைகளைப் பயன்படுத்தி நாம் மரங்களைக் காட்டலாம். இந்த டிராவர்சல் முறைகள்:
1: முன்-ஆர்டர் டிராவர்சல்
இந்த டிராவர்சல் முறையில், நாம் ஒரு திசையில் முனைகள் வழியாக செல்வோம் parent_node->left_child-> right_child .
வெற்றிடமானது முன்பதிவு ( முனை * வேர் ) {என்றால் ( வேர் ) {
printf ( '%d \n ' , வேர் -> தகவல்கள் ) ;
காட்சி_முன்_வரிசை ( வேர் -> விட்டு ) ;
காட்சி_முன்_வரிசை ( வேர் -> சரி ) ;
}
}
2: போஸ்ட் ஆர்டர் டிராவர்சல்
இந்த டிராவர்சல் முறையில், நாம் ஒரு திசையில் முனைகளின் வழியாக செல்வோம் left_child->right_child->parent_node-> .
வெற்றிடமானது காட்சி_போஸ்ட்_ஆர்டர் ( முனை * வேர் ) {என்றால் ( பைனரி_மரம் ) {
காட்சி_போஸ்ட்_ஆர்டர் ( வேர் -> விட்டு ) ;
காட்சி_போஸ்ட்_ஆர்டர் ( வேர் -> சரி ) ;
printf ( '%d \n ' , வேர் -> தகவல்கள் ) ;
}
}
3: இன்-ஆர்டர் டிராவர்சல்
இந்த டிராவர்சல் முறையில், நாம் ஒரு திசையில் முனைகள் வழியாக செல்வோம் left_node->root_child-> right_child .
வெற்றிடமானது காட்சி_வரிசையில் ( முனை * வேர் ) {என்றால் ( பைனரி_மரம் ) {
காட்சி_வரிசையில் ( வேர் -> விட்டு ) ;
printf ( '%d \n ' , வேர் -> தகவல்கள் ) ;
காட்சி_வரிசையில் ( வேர் -> சரி ) ;
}
}
படி 5: பைனரி மரத்தில் நீக்குதலைச் செய்யவும்
உருவாக்கியதை நீக்கலாம் பைனரி மரம் C இல் பெற்றோர் முனை செயல்பாட்டைக் கொண்ட இரு குழந்தைகளையும் பின்வருமாறு நீக்குவதன் மூலம்.
வெற்றிடமானது delete_t ( முனை * வேர் ) {என்றால் ( வேர் ) {
delete_t ( வேர் -> விட்டு ) ;
delete_t ( வேர் -> சரி ) ;
இலவசம் ( வேர் ) ;
}
}
பைனரி தேடல் மரத்தின் சி திட்டம்
பின்வருபவை சி நிரலாக்கத்தில் பைனரி தேடல் மரத்தின் முழுமையான செயலாக்கம்:
#உள்படுத்து# அடங்கும்
கட்டமைக்க முனை {
முழு எண்ணாக மதிப்பு ;
கட்டமைக்க முனை * விட்டு , * சரி ;
} ;
கட்டமைக்க முனை * முனை1 ( முழு எண்ணாக தகவல்கள் ) {
கட்டமைக்க முனை * tmp = ( கட்டமைக்க முனை * ) malloc ( அளவு ( கட்டமைக்க முனை ) ) ;
tmp -> மதிப்பு = தகவல்கள் ;
tmp -> விட்டு = tmp -> சரி = ஏதுமில்லை ;
திரும்ப tmp ;
}
வெற்றிடமானது அச்சு ( கட்டமைக்க முனை * வேர்_முனை ) // முனைகளைக் காட்டுகிறது!
{
என்றால் ( வேர்_முனை != ஏதுமில்லை ) {
அச்சு ( வேர்_முனை -> விட்டு ) ;
printf ( '%d \n ' , வேர்_முனை -> மதிப்பு ) ;
அச்சு ( வேர்_முனை -> சரி ) ;
}
}
கட்டமைக்க முனை * செருகு_முனை ( கட்டமைக்க முனை * முனை , முழு எண்ணாக தகவல்கள் ) // முனைகளைச் செருகுகிறது!
{
என்றால் ( முனை == ஏதுமில்லை ) திரும்ப முனை1 ( தகவல்கள் ) ;
என்றால் ( தகவல்கள் < முனை -> மதிப்பு ) {
முனை -> விட்டு = செருகு_முனை ( முனை -> விட்டு , தகவல்கள் ) ;
} வேறு என்றால் ( தகவல்கள் > முனை -> மதிப்பு ) {
முனை -> சரி = செருகு_முனை ( முனை -> சரி , தகவல்கள் ) ;
}
திரும்ப முனை ;
}
முழு எண்ணாக முக்கிய ( ) {
printf ( 'பைனரி தேடல் மரத்தின் C செயல்படுத்தல்! \n \n ' ) ;
கட்டமைக்க முனை * பெற்றோர் = ஏதுமில்லை ;
பெற்றோர் = செருகு_முனை ( பெற்றோர் , 10 ) ;
செருகு_முனை ( பெற்றோர் , 4 ) ;
செருகு_முனை ( பெற்றோர் , 66 ) ;
செருகு_முனை ( பெற்றோர் , நான்கு. ஐந்து ) ;
செருகு_முனை ( பெற்றோர் , 9 ) ;
செருகு_முனை ( பெற்றோர் , 7 ) ;
அச்சு ( பெற்றோர் ) ;
திரும்ப 0 ;
}
மேலே உள்ள குறியீட்டில், நாம் முதலில் அறிவிக்கிறோம் a முனை பயன்படுத்தி கட்டமைக்க . பின்னர் நாம் ஒரு புதிய முனையை துவக்குகிறோம் ' முனை1 ” மற்றும் நினைவகத்தை மாறும் வகையில் ஒதுக்கவும் malloc() C இல் தரவு மற்றும் இரண்டு சுட்டிகளுடன் குழந்தைகள் அறிவிக்கப்பட்ட முனையைப் பயன்படுத்தி தட்டச்சு செய்க. இதற்குப் பிறகு, நாம் முனையைக் காட்டுகிறோம் printf() செயல்பாடு மற்றும் அதை அழைக்கவும் முக்கிய() செயல்பாடு. பின்னர் தி செருகும்_முனை() செயல்பாடு உருவாக்கப்படுகிறது, அங்கு முனை தரவு NULL ஆக இருந்தால் முனை1 ஓய்வு பெற்றவர், இல்லையெனில் தரவு வைக்கப்படும் முனை (பெற்றோர்) இடது மற்றும் வலது குழந்தையின். நிரல் இலிருந்து செயல்படுத்தத் தொடங்குகிறது முக்கிய() செயல்பாடு, இது குழந்தைகளாக சில மாதிரி முனைகளைப் பயன்படுத்தி ஒரு முனையை உருவாக்குகிறது, பின்னர் முனை உள்ளடக்கங்களை அச்சிட இன்-ஆர்டர் டிராவர்சல் முறைகளைப் பயன்படுத்துகிறது.
வெளியீடு
முடிவுரை
தரவுகளை நேரியல் அல்லாத வடிவத்தில் வைத்திருக்க மரங்கள் அடிக்கடி பயன்படுத்தப்படுகின்றன. பைனரி மரங்கள் ஒவ்வொரு முனையிலும் (பெற்றோர்) இடது குழந்தை மற்றும் வலது குழந்தை என இரண்டு சந்ததிகள் இருக்கும் மரங்களின் வகைகள். ஏ பைனரி மரம் தரவு பரிமாற்றம் மற்றும் சேமிப்பதற்கான ஒரு பல்துறை முறையாகும். C இல் உள்ள Linked-List உடன் ஒப்பிடும்போது இது மிகவும் திறமையானது. மேலே உள்ள கட்டுரையில், ஒரு கருத்தைப் பார்த்தோம். பைனரி மரம் ஒரு படி-படி-படி செயல்படுத்துதலுடன் பைனரி தேடல் மரம் C இல்