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

366
data_structures/binary_trees/Threaded_Binary_Tree.c
View File

@ -1,236 +1,219 @@
#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;
{
node *ptr=(node*) malloc(sizeof(node));
ptr->rlink=ptr->llink=NULL;
ptr->data=data;
return ptr; 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;
temp=temp->llink;
}
else
{
return; 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) {
if (temp->data == ele) {
break; break;
} } else if (ele > temp->data) {
else if(ele>temp->data) temp = temp->rlink;
{ } else {
temp=temp->rlink; 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
{ */
void inorder_display(node *curr) {
if (curr != NULL) {
inorder_display(curr->llink); inorder_display(curr->llink);
printf("%d\t",curr->data ); printf("%d\t", curr->data);
inorder_display(curr->rlink); 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
{ */
void postorder_BT(node *curr) {
if (curr != NULL) {
postorder_BT(curr->llink); postorder_BT(curr->llink);
postorder_BT(curr->rlink); postorder_BT(curr->rlink);
printf("%d\t",curr->data); 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) {
if (curr != NULL) {
printf("%d\t", curr->data);
preorder_BT(curr->llink); preorder_BT(curr->llink);
preorder_BT(curr->rlink); 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
* param[in] ele value to be deleted from the tree
*/
void delete_BT(node **root, int ele) {
node *temp;
node *prev; node *prev;
if(*root==NULL) return; if (*root == NULL)
else
{
temp=*root;
prev=NULL;
// search
while(temp!=NULL)
{
if(temp->data==ele)
{
break;
}
else if(ele>temp->data)
{
prev=temp;
temp=temp->rlink;
}
else
{
prev=temp;
temp=temp->llink;
}
}
}
if(temp==NULL)
return; return;
else else {
{ temp = *root;
node *replacement; //deleted node's replacement prev = NULL;
// search
while (temp != NULL) {
if (temp->data == ele) {
break;
} else if (ele > temp->data) {
prev = temp;
temp = temp->rlink;
} else {
prev = temp;
temp = temp->llink;
}
}
}
if (temp == NULL)
return;
else {
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;
replacement=NULL; } else if (temp->llink == NULL && temp->rlink != NULL) {
replacement = temp->rlink;
} else if (temp->llink != NULL && temp->rlink == NULL) {
replacement = temp->llink;
} else {
replacement = temp->rlink; // replaced with inorder successor
t = replacement;
while (t->llink != NULL) {
t = t->llink;
} }
else if(temp->llink==NULL && temp->rlink!=NULL) t->llink = temp->llink; // leftmost node of the replacement is linked to
{ // the left child of the deleted node
replacement=temp->rlink;
}
else if(temp->llink!=NULL && temp->rlink==NULL)
{
replacement=temp->llink;
}
else
{
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) {
else if(prev->llink==temp)
{
free(prev->llink); free(prev->llink);
prev->llink=replacement; prev->llink = replacement;
} } else if (prev->rlink == temp) {
else if(prev->rlink==temp)
{
free(prev->rlink); free(prev->rlink);
prev->rlink=replacement; prev->rlink = replacement;
}
} }
} }
}
/*
* main function
*/
void main() {
printf("BINARY THREADED TREE: \n");
node *root = NULL;
int choice, n;
do {
printf("%s\n", "1. Insert into BT");
printf("%s\n", "2. Print BT - inorder");
printf("%s\n", "3. Print BT - preorder");
printf("%s\n", "4. print BT - postorder");
printf("%s\n", "5. delete from BT");
printf("%s\n", "6. search in BT");
printf("%s\n", "Type 0 to exit");
scanf("%d", &choice);
void main() switch (choice) {
{
printf("BINARY TREE: \n");
node *root=NULL;
int choice,n;
do
{
printf("%s\n","1. Insert into BT" );
printf("%s\n","2. Print BT - inorder" );
printf("%s\n","3. Print BT - preorder" );
printf("%s\n","4. print BT - postorder" );
printf("%s\n","5. delete from BT" );
printf("%s\n","6. search in BT" );
scanf("%d",&choice);
switch(choice)
{
case 1: case 1:
printf("%s\n","Enter a no:" ); printf("%s\n", "Enter a no:");
scanf("%d",&n); scanf("%d", &n);
insert_BT(&root,n); insert_BT(&root, n);
break; break;
case 2: case 2:
inorder_display(root); inorder_display(root);
@ -245,16 +228,15 @@ void main()
printf("\n"); printf("\n");
break; break;
case 5: case 5:
printf("%s\n","Enter a no:" ); printf("%s\n", "Enter a no:");
scanf("%d",&n); scanf("%d", &n);
delete_BT(&root,n); delete_BT(&root, n);
break; break;
case 6: case 6:
printf("%s\n","Enter a no:" ); printf("%s\n", "Enter a no:");
scanf("%d",&n); scanf("%d", &n);
search(root,n); search(root, n);
break; break;
} }
} while (choice != 0);
}while(choice!=0);
} }