Insertion, Deletion & searching operation in BST using Code::Blocks

#include
  #include

  struct treeNode {
        int data;
        struct treeNode *left, *right;
  };

  struct treeNode *root = NULL;

  /* create a new node with the given data */
  struct treeNode* createNode(int data) {
        struct treeNode *newNode;
        newNode = (struct treeNode *) malloc(sizeof (struct treeNode));
        newNode->data = data;
        newNode->left = NULL;
        newNode->right = NULL;
        return(newNode);
  }

  /* insertion in binary search tree */
  void insertion(struct treeNode **node, int data) {
        if (*node == NULL) {
                *node = createNode(data);
        } else if (data < (*node)->data) {
                insertion(&(*node)->left, data);
        } else if (data > (*node)->data) {
                insertion(&(*node)->right, data);
        }
  }


  /* deletion in binary search tree */
  void deletion(struct treeNode **node, struct treeNode **parent, int data) {
        struct treeNode *tmpNode, *tmpParent;
        if (*node == NULL)
                return;
        if ((*node)->data == data) {
                /* deleting the leaf node */
                if (!(*node)->left && !(*node)->right) {
                        if (parent) {
                                /* delete leaf node */
                                if ((*parent)->left == *node)
                                        (*parent)->left = NULL;
                                else
                                        (*parent)->right = NULL;
                                free(*node);
                        } else {
                                /* delete root node with no children */
                                free(*node);
                        }
                /* deleting node with one child */
                } else if (!(*node)->right && (*node)->left) {
                        /* deleting node with left child alone */
                        tmpNode = *node;
                        (*parent)->right = (*node)->left;
                        free(tmpNode);
                        *node = (*parent)->right;
                } else if ((*node)->right && !(*node)->left) {
                        /* deleting node with right child alone */
                        tmpNode = *node;
                        (*parent)->left = (*node)->right;
                        free(tmpNode);
                        (*node) = (*parent)->left;
                } else if (!(*node)->right->left) {
                        /*
                         * deleting a node whose right child
                         * is the smallest node in the right
                         * subtree for the node to be deleted.
                         */

                        tmpNode = *node;
                        (*node)->right->left = (*node)->left;
                        (*parent)->left = (*node)->right;
                        free(tmpNode);
                        *node = (*parent)->left;
                } else {
                        /*
                         * Deleting a node with two children.
                         * First, find the smallest node in
                         * the right subtree.  Replace the
                         * smallest node with the node to be
                         * deleted. Then, do proper connections
                         * for the children of replaced node.
                         */
                        tmpNode = (*node)->right;
                        while (tmpNode->left) {
                                tmpParent = tmpNode;
                                tmpNode = tmpNode->left;
                        }
                        tmpParent->left = tmpNode->right;
                        tmpNode->left = (*node)->left;
                        tmpNode->right =(*node)->right;
                        free(*node);
                        *node = tmpNode;
                }
        } else if (data < (*node)->data) {
                /* traverse towards left subtree */
                deletion(&(*node)->left, node, data);
        } else if (data > (*node)->data) {
                /* traversing towards right subtree */
                deletion(&(*node)->right, node, data);
        }
  }

  /* search the given element in binary search tree */
  void findElement(struct treeNode *node, int data) {
        if (!node)
                return;
        else if (data < node->data) {
                findElement(node->left, data);
        } else if (data > node->data) {
                findElement(node->right, data);
        } else
                printf("data found: %d\n", node->data);
        return;

  }

  void traverse(struct treeNode *node) {
        if (node != NULL) {
                traverse(node->left);
                printf("%3d", node->data);
                traverse(node->right);
        }
        return;
  }

  int main() {
        int data, ch;
        while (1) {
                printf("1. Insertion in Binary Search Tree\n");
                printf("2. Deletion in Binary Search Tree\n");
                printf("3. Search Element in Binary Search Tree\n");
                printf("4. Inorder traversal\n5. Exit\n");
                printf("Enter your choice:");
                scanf("%d", &ch);
                switch (ch) {
                        case 1:
                                while (1) {
                                printf("Enter your data:");
                                scanf("%d", &data);
                                insertion(&root, data);
                                printf("Continue Insertion(0/1):");
                                scanf("%d", &ch);
                                if (!ch)
                                        break;
                                }
                                break;
                        case 2:
                                printf("Enter your data:");
                                scanf("%d", &data);
                                deletion(&root, NULL, data);
                                break;
                        case 3:
                                printf("Enter value for data:");
                                scanf("%d", &data);
                                findElement(root, data);
                                break;
                        case 4:
                                printf("Inorder Traversal:\n");
                                traverse(root);
                                printf("\n");
                                break;
                        case 5:
                                exit(0);
                        default:
                                printf("u've entered wrong option\n");
                                break;
                }
        }
        return 0;

  }

Program of traversing a binary tree in inorder, preorder and postorder in C++ Programming

#include
#include
#include
struct btree
{
    struct btree *left;
    struct btree *right;
    int no;
};
void postorder(struct btree *trav);
void inorder(struct btree *trav);
void preorder(struct btree *trav);
struct btree * create(struct btree *trav);
main()
{
    struct btree *root=NULL;
    char c;
    clrscr();
    while(1)
    {
        root=create(root);
        cout<<"Do you want to continue : ";
        cin>>c;
        if(c=='n' ||c=='N')
            break;
    }
    cout<"Inoder is    : "

;inorder(root); cout<"Preorder is : ";preorder(root); cout<"Postorder is : ";postorder(root); getch(); } struct btree * create(struct btree *trav) { if(trav==NULL) { trav=new btree; trav->right=NULL; trav->left=NULL; cout<<"Enter the no : "; cin>>trav->no; return(trav); } char choice; cout<<"Enter the left or right child : "; cin>>choice; if(choice == 'r' || choice == 'R') { trav->right=create(trav->right); } if(choice=='l' || choice=='L') { trav->left=create(trav->left); } return(trav); } void inorder(struct btree *trav) { if(trav==NULL) return ; inorder(trav->left); cout<<" "<no; inorder(trav->right); } void preorder(struct btree *trav) { if(trav==NULL) return; cout<<" "<no; preorder(trav->left); preorder(trav->right); } void postorder(struct btree *trav) { if(trav==NULL) return; postorder(trav->left); postorder(trav->right); cout<<" "<no; }

Implementation of Kruskal's Algorithm using C language

C Program to implement Dijkstra's algorithm. Dijkstra's Algorithm finds the shortest path with the lower cost in a Graph. Dijkstra's Algorithm solves the Single Source Shortest Path problem for a Graph. It is a Greedy algorithm and similar to Prim's algorithm. Read more about C Programming Language .

/***********************************************************

* You can use all the programs on  www.engineercse.blogspot.com

* for personal and learning purposes. For permissions to use the

* programs for commercial purposes,

* contact sm.rumi18@gmail.com

* To find more C programs, do visit www.engineercse.blogspot.com

* and browse!

*

*                       Coding fun

***********************************************************/

#include "stdio.h"

#include "conio.h"

#define infinity 999

void dij(int n,int v,int cost[10][10],int dist[])

{

 int i,u,count,w,flag[10],min;

 for(i=1;i<=n;i++)

  flag[i]=0,dist[i]=cost[v][i];

 count=2;

 while(count<=n)

 {

  min=99;

  for(w=1;w<=n;w++)

   if(dist[w]

    min=dist[w],u=w;

  flag[u]=1;

  count++;

  for(w=1;w<=n;w++)

   if((dist[u]+cost[u][w]

    dist[w]=dist[u]+cost[u][w];

 }

}

void main()

{

 int n,v,i,j,cost[10][10],dist[10];

 clrscr();

 printf("\n Enter the number of nodes:");

 scanf("%d",&n);

 printf("\n Enter the cost matrix:\n");

 for(i=1;i<=n;i++)

  for(j=1;j<=n;j++)

  {

   scanf("%d",&cost[i][j]);

   if(cost[i][j]==0)

    cost[i][j]=infinity;

  }

 printf("\n Enter the source matrix:");

 scanf("%d",&v);

 dij(n,v,cost,dist);

 printf("\n Shortest path:\n");

 for(i=1;i<=n;i++)

  if(i!=v)

   printf("%d->%d,cost=%d\n",v,i,dist[i]);

 getch();

}

Read more Similar C Programs

Data Structures

Prims Algorithm

Learn C Programming