Binært tre i C
I C, a binært tre er en forekomst av en tredatastruktur med en overordnet node som kan ha maksimalt to underordnede noder; 0, 1 eller 2 avkom noder. Hver eneste node i en binært tre har en egen verdi og to pekepinner til sine barn, en peker for venstre barn og den andre for høyre barn.
Erklæring om binært tre
EN binært tre kan deklareres i C ved å bruke et objekt kalt struktur som viser en av nodene i treet.
struktur node {
datatype var_navn ;
struktur node * venstre ;
struktur node * Ikke sant ;
} ;
Ovenfor er en erklæring av en binært tre nodenavn som en node. Den har tre verdier; den ene er datalagringsvariabelen og de to andre er pekere til barnet. (venstre og høyre barn til overordnet node).
Fakta om binært tre
Selv for store sett med data, ved å bruke en binært tre gjør søk enklere og raskere. Antall tregrener er ikke begrenset. I motsetning til en matrise, kan trær av alle slag lages og økes basert på hva som kreves av et individ.
Binær treimplementering i C
Følgende er en trinnvis veiledning for implementering av en Binært tre i C.
Trinn 1: Erklær et binært søketre
Lag en strukturnode som har tre typer data, for eksempel data, *left_child og *right_child, der data kan være av heltallstype, og både *left_child og *right_child noder kan erklæres som NULL eller ikke.
struktur node{
int data ;
struktur node * høyre_barn ;
struktur node * left_child ;
} ;
Trinn 2: Opprett nye noder i binært søketre
Opprett en ny node ved å lage en funksjon som godtar et heltall som et argument og gir pekeren til den nye noden som er opprettet med den verdien. Bruk malloc()-funksjonen i C for dynamisk minneallokering for den opprettede noden. Initialiser venstre og høyre barn til NULL og returner nodeName.
struktur node * skape ( datatypedata )
{
struktur node * nodenavn = malloc ( størrelsen av ( struktur node ) ) ;
nodenavn -> data = verdi ;
nodenavn -> left_child = nodenavn -> høyre_barn = NULL ;
komme tilbake nodenavn ;
}
Trinn 3: Sett inn høyre og venstre barn i binært tre
Lag funksjoner insert_left og insert_right som vil akseptere to innganger, som er verdien som skal settes inn og pekeren til noden som begge barna skal kobles til. Kall opprettingsfunksjonen for å opprette en ny node og tilordne den returnerte pekeren til venstre peker til venstre underordnet eller høyre peker til høyre underordnet til rotforelder.
struktur node * insert_left ( struktur node * rot , datatypedata ) {rot -> venstre = skape ( data ) ;
komme tilbake rot -> venstre ;
}
struktur node * insert_right ( struktur node * rot , datatypedata ) {
rot -> Ikke sant = skape ( data ) ;
komme tilbake rot -> Ikke sant ;
}
Trinn 4: Vis noder av binært tre ved å bruke kryssingsmetoder
Vi kan vise trær ved å bruke tre metoder for traversering i C. Disse traverseringsmetodene er:
1: Forhåndsbestilling
I denne traverseringsmetoden vil vi gå gjennom nodene i retning fra foreldrenode->venstre_barn->høyre_barn .
tomrom forhåndsbestille ( node * rot ) {hvis ( rot ) {
printf ( '%d \n ' , rot -> data ) ;
display_pre_order ( rot -> venstre ) ;
display_pre_order ( rot -> Ikke sant ) ;
}
}
2: Etterbestilling
I denne traverseringsmetoden vil vi gå gjennom nodene i retning fra left_child->right_child->parent_node-> .
tomrom display_post_order ( node * rot ) {hvis ( binært_tre ) {
display_post_order ( rot -> venstre ) ;
display_post_order ( rot -> Ikke sant ) ;
printf ( '%d \n ' , rot -> data ) ;
}
}
3: In-Order Traversal
I denne traverseringsmetoden vil vi gå gjennom nodene i retning fra left_node->root_child->right_child .
tomrom display_in_order ( node * rot ) {hvis ( binært_tre ) {
display_in_order ( rot -> venstre ) ;
printf ( '%d \n ' , rot -> data ) ;
display_in_order ( rot -> Ikke sant ) ;
}
}
Trinn 5: Utfør sletting i binært tre
Vi kan slette det opprettede Binært tre ved å slette begge barna med overordnet nodefunksjon i C som følger.
tomrom delete_t ( node * rot ) {hvis ( rot ) {
delete_t ( rot -> venstre ) ;
delete_t ( rot -> Ikke sant ) ;
gratis ( rot ) ;
}
}
C Program for binært søketre
Følgende er den komplette implementeringen av binært søketre i C-programmering:
#include#include
struktur node {
int verdi ;
struktur node * venstre , * Ikke sant ;
} ;
struktur node * node 1 ( int data ) {
struktur node * tmp = ( struktur node * ) malloc ( størrelsen av ( struktur node ) ) ;
tmp -> verdi = data ;
tmp -> venstre = tmp -> Ikke sant = NULL ;
komme tilbake tmp ;
}
tomrom skrive ut ( struktur node * root_node ) // viser nodene!
{
hvis ( root_node != NULL ) {
skrive ut ( root_node -> venstre ) ;
printf ( '%d \n ' , root_node -> verdi ) ;
skrive ut ( root_node -> Ikke sant ) ;
}
}
struktur node * insert_node ( struktur node * node , int data ) // sette inn noder!
{
hvis ( node == NULL ) komme tilbake node1 ( data ) ;
hvis ( data < node -> verdi ) {
node -> venstre = insert_node ( node -> venstre , data ) ;
} ellers hvis ( data > node -> verdi ) {
node -> Ikke sant = insert_node ( node -> Ikke sant , data ) ;
}
komme tilbake node ;
}
int hoved- ( ) {
printf ( 'C implementering av Binary Search Tree! \n \n ' ) ;
struktur node * forelder = NULL ;
forelder = insert_node ( forelder , 10 ) ;
insert_node ( forelder , 4 ) ;
insert_node ( forelder , 66 ) ;
insert_node ( forelder , Fire fem ) ;
insert_node ( forelder , 9 ) ;
insert_node ( forelder , 7 ) ;
skrive ut ( forelder ) ;
komme tilbake 0 ;
}
I koden ovenfor erklærer vi først en node ved hjelp av struktur . Deretter initialiserer vi en ny node som ' node1 ” og allokere minne dynamisk ved hjelp av malloc() i C med data og to pekere skriv barn ved å bruke den deklarerte noden. Etter dette viser vi noden etter printf() funksjon og kall den inn hoved() funksjon. Og så insertion_node() funksjon opprettes, hvor hvis nodedata er NULL da node1 er trukket tilbake, ellers plasseres data i node (forelder) til venstre og høyre barn. Programmet starter kjøringen fra hoved() funksjon, som genererer en node ved å bruke noen få prøvenoder som underordnede og deretter bruker In-Order-gjennomgangsmetoder for å skrive ut nodeinnholdet.
Produksjon
Konklusjon
Trær brukes ofte for å holde data i en ikke-lineær form. Binære trær er typer trær der hver node (foreldre) har to avkom venstre barn og høyre barn. EN binært tre er en allsidig metode for overføring og lagring av data. Det er mer effektivt sammenlignet med Linked-List i C. I artikkelen ovenfor har vi sett konseptet med en Binært tre med trinnvis implementering av en Binært søketre i C.