mirrors/TheAlgorithms-C
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/C synced 2024-11-22 05:21:49 +03:00
Code Issues Packages Projects Releases Wiki Activity

updated documentation and format

Browse Source
This commit is contained in:
Amit 2020-06-11 19:35:59 +05:30
parent 93e1bfc1f9
commit e63c806f25
1 changed files with 222 additions and 240 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

462
data_structures/binary_trees/Threaded_Binary_Tree.c
View File

@ -1,260 +1,242 @@
#include<stdio.h> /**
#include<stdlib.h> * @file
* \brief Threaded Binary Tree is a binary tree variant in which all left child
* pointers that are NULL (in Linked list representation) point to its
* in-order predecessor, and all right child pointers that are NULL
* (in Linked list representation) point to its in-order successor.
* This file is a simple implementation of a Threaded Binary Tree
* with the following functionalities:
* - Insertion
* - Search
* - Deletion
* - Listing of node keys inorder,preorder,postorder
* \author [Amitha Nayak](https://github.com/amitnayakblr)
*/
/*Threaded Binary Tree is a binary tree variant in which all left child #include <stdio.h>
pointers that are NULL (in Linked list representation) point to its #include <stdlib.h>
in-order predecessor, and all right child pointers that are NULL
(in Linked list representation) point to its in-order successor.
This file is a simple implementation of a Threaded Binary Tree /**
with the following functionalities: * Node, the basic data structure of the tree
- Insertion **/
- Search typedef struct Node {
- Deletion int data; /**< stores the number */
- Listing of node keys inorder,preorder, postorder struct Node *llink; /**< link to left child */
*/ struct Node *rlink; /**< link to right child */
} node;
// Node, the basic data structure in the tree /**
typedef struct Node * creates a new node
{ * param[in] data value to be inserted
int data; * \returns a pointer to the new node
struct Node *llink; **/
struct Node *rlink; node *create_node(int data) {
}node; node *ptr = (node *)malloc(sizeof(node));
ptr->rlink = ptr->llink = NULL;
node* create_node(int data) ptr->data = data;
{ return ptr;
node *ptr=(node*) malloc(sizeof(node));
ptr->rlink=ptr->llink=NULL;
ptr->data=data;
return ptr;
} }
void insert_BT(node **root,int data) /**
{ * inserts a node into the tree
node *new_node=create_node(data); * param[in,out] root pointer to node pointer to the topmost node of the tree
node *temp; //to be deleted * param[in] data value to be inserted into the tree
node *prev; //keeps track of the parent of the element deleted */
if(*root==NULL) void insert_BT(node **root, int data) {
{ node *new_node = create_node(data);
*root=new_node; node *temp; // to be deleted
} node *prev; // keeps track of the parent of the element deleted
else if (*root == NULL) {
{ *root = new_node;
temp=*root; } else {
prev=NULL; temp = *root;
while(temp!=NULL) prev = NULL;
{ while (temp != NULL) {
if(new_node->data>temp->data) if (new_node->data > temp->data) {
{ prev = temp;
prev=temp; temp = temp->rlink;
temp=temp->rlink; } else if (new_node->data < temp->data) {
} prev = temp;
else if(new_node->data<temp->data) temp = temp->llink;
{ } else {
prev=temp; return;
temp=temp->llink; }
} }
else
{
return;
}
}
if(new_node->data>prev->data) if (new_node->data > prev->data) {
{ prev->rlink = new_node;
prev->rlink=new_node; } else {
} prev->llink = new_node;
else }
{ }
prev->llink=new_node;
}
}
} }
// returns "Element found" if the search element is present else returns, "Element not found" /**
void search(node *root, int ele) * searches for the element
{ * \param[in] root node pointer to the topmost node of the tree
node *temp=root; * \param[in] ele value searched for
while(temp!=NULL) */
{ void search(node *root, int ele) {
if(temp->data==ele) node *temp = root;
{ while (temp != NULL) {
break; if (temp->data == ele) {
} break;
else if(ele>temp->data) } else if (ele > temp->data) {
{ temp = temp->rlink;
temp=temp->rlink; } else {
} temp = temp->llink;
else }
{ }
temp=temp->llink;
}
}
if(temp==NULL) if (temp == NULL) {
{ printf("%s\n", "Element not found.");
printf("%s\n","Element not found." ); } else
} printf("%s\n", "Element found.");
else printf("%s\n","Element found." );
} }
void inorder_display(node *curr) /*
{ * performs inorder traversal
if(curr!=NULL) * param[in] curr node pointer to the topmost node of the tree
{ */
inorder_display(curr->llink); void inorder_display(node *curr) {
printf("%d\t",curr->data ); if (curr != NULL) {
inorder_display(curr->rlink); inorder_display(curr->llink);
} printf("%d\t", curr->data);
inorder_display(curr->rlink);
}
} }
void postorder_BT(node *curr) /*
{ * performs postorder traversal
if(curr!=NULL) * param[in] curr node pointer to the topmost node of the tree
{ */
postorder_BT(curr->llink); void postorder_BT(node *curr) {
postorder_BT(curr->rlink); if (curr != NULL) {
printf("%d\t",curr->data); postorder_BT(curr->llink);
} postorder_BT(curr->rlink);
printf("%d\t", curr->data);
}
} }
void preorder_BT(node *curr) /*
{ * performs preorder traversal
if(curr!=NULL) * param[in] curr node pointer to the topmost node of the tree
{ */
printf("%d\t",curr->data); void preorder_BT(node *curr) {
preorder_BT(curr->llink); if (curr != NULL) {
preorder_BT(curr->rlink); printf("%d\t", curr->data);
} preorder_BT(curr->llink);
preorder_BT(curr->rlink);
}
} }
// deletes the node if present, else it takes no action. /*
void delete_BT(node **root,int ele) * deletion of a node from the tree
{ * if the node isn't present in the tree, it takes no action.
node* temp; * param[in,out] root pointer to node pointer to the topmost node of the tree
node *prev; * param[in] ele value to be deleted from the tree
if(*root==NULL) return; */
else void delete_BT(node **root, int ele) {
{ node *temp;
temp=*root; node *prev;
prev=NULL; if (*root == NULL)
// search return;
while(temp!=NULL) else {
{ temp = *root;
if(temp->data==ele) prev = NULL;
{ // search
break; while (temp != NULL) {
} if (temp->data == ele) {
else if(ele>temp->data) break;
{ } else if (ele > temp->data) {
prev=temp; prev = temp;
temp=temp->rlink; temp = temp->rlink;
} } else {
else prev = temp;
{ temp = temp->llink;
prev=temp; }
temp=temp->llink; }
} }
}
}
if(temp==NULL) if (temp == NULL)
return; return;
else else {
{ node *replacement; // deleted node's replacement
node *replacement; //deleted node's replacement node *t;
node *t; if (temp->llink == NULL && temp->rlink == NULL) {
if(temp->llink==NULL && temp->rlink==NULL) replacement = NULL;
{ } else if (temp->llink == NULL && temp->rlink != NULL) {
replacement=NULL; replacement = temp->rlink;
} } else if (temp->llink != NULL && temp->rlink == NULL) {
else if(temp->llink==NULL && temp->rlink!=NULL) replacement = temp->llink;
{ } else {
replacement=temp->rlink; replacement = temp->rlink; // replaced with inorder successor
} t = replacement;
else if(temp->llink!=NULL && temp->rlink==NULL) while (t->llink != NULL) {
{ t = t->llink;
replacement=temp->llink; }
} t->llink = temp->llink; // leftmost node of the replacement is linked to
else // the left child of the deleted node
{ }
replacement=temp->rlink; //replaced with inorder successor
t=replacement;
while(t->llink!=NULL)
{
t=t->llink;
}
t->llink=temp->llink; //leftmost node of the replacement is linked to the left child of the deleted node
}
if(temp==*root) if (temp == *root) {
{ free(*root);
free(*root); *root = replacement;
*root=replacement; } else if (prev->llink == temp) {
} free(prev->llink);
else if(prev->llink==temp) prev->llink = replacement;
{ } else if (prev->rlink == temp) {
free(prev->llink); free(prev->rlink);
prev->llink=replacement; prev->rlink = replacement;
} }
else if(prev->rlink==temp) }
{ }
free(prev->rlink);
prev->rlink=replacement; /*
} * main function
} */
} void main() {
printf("BINARY THREADED TREE: \n");
node *root = NULL;
void main() int choice, n;
{ do {
printf("BINARY TREE: \n"); printf("%s\n", "1. Insert into BT");
node *root=NULL; printf("%s\n", "2. Print BT - inorder");
int choice,n; printf("%s\n", "3. Print BT - preorder");
do printf("%s\n", "4. print BT - postorder");
{ printf("%s\n", "5. delete from BT");
printf("%s\n","1. Insert into BT" ); printf("%s\n", "6. search in BT");
printf("%s\n","2. Print BT - inorder" ); printf("%s\n", "Type 0 to exit");
printf("%s\n","3. Print BT - preorder" ); scanf("%d", &choice);
printf("%s\n","4. print BT - postorder" );
printf("%s\n","5. delete from BT" ); switch (choice) {
printf("%s\n","6. search in BT" ); case 1:
scanf("%d",&choice); printf("%s\n", "Enter a no:");
scanf("%d", &n);
insert_BT(&root, n);
switch(choice) break;
{ case 2:
case 1: inorder_display(root);
printf("%s\n","Enter a no:" ); printf("\n");
scanf("%d",&n); break;
insert_BT(&root,n); case 3:
break; preorder_BT(root);
case 2: printf("\n");
inorder_display(root); break;
printf("\n"); case 4:
break; postorder_BT(root);
case 3: printf("\n");
preorder_BT(root); break;
printf("\n"); case 5:
break; printf("%s\n", "Enter a no:");
case 4: scanf("%d", &n);
postorder_BT(root); delete_BT(&root, n);
printf("\n"); break;
break; case 6:
case 5: printf("%s\n", "Enter a no:");
printf("%s\n","Enter a no:" ); scanf("%d", &n);
scanf("%d",&n); search(root, n);
delete_BT(&root,n); break;
break; }
case 6: } while (choice != 0);
printf("%s\n","Enter a no:" );
scanf("%d",&n);
search(root,n);
break;
}
}while(choice!=0);
} }