Mohit

  #include   <stdio.h> #include   <stdlib.h> //Insertion in Binary Search Tree struct  node{      int  data;      struct  node  * left;      struct  node  * right; }; struct  node  * create_tree ( int   data ){      struct  node  * n  =  ( struct  node  * ) malloc ( sizeof ( struct  node));     n->data  =  data;     n->left  =  n->right  =   NULL ;      return  n; } void   InOrder ( struct  node  * root ){      if  (root  !=   NULL ){          InOrder (root->left);          printf ( " %d  " , root->data);          InOrder (root->right);     } } void   insertion_bst ( struct  node  * root ,  int   key ){      struct  node  * ptr  =  root;      struct  node  * prev  =   NULL ;      struct  node  * new_node  =   create_tree (key);      while  (ptr  !=   NULL ){         prev  =  ptr;          if  (key  ==  ptr->data){              printf ( " %d  is a duplicate ! \n " , key);              return ;         }          if  (key  <  ptr-&g

  #include   <stdio.h> #include   <stdlib.h> //Searching in Binary Search Tree using Iterative Method struct  node{      int  data;      struct  node  * left;      struct  node  * right; }; struct  node  * create_tree ( int   data ){      struct  node  * n  =  ( struct  node  * ) malloc ( sizeof ( struct  node));     n->data  =  data;     n->left  =  n->right  =   NULL ;      return  n; } void   InOrder ( struct  node  * root ){      if  (root  !=   NULL ){          InOrder (root->left);          printf ( " %d  " , root->data);          InOrder (root->right);     } } struct  node  * search_bst ( struct  node  * root ,  int   key ){      struct  node  * ptr  =  root;      while  (ptr  !=   NULL ){          if  (ptr->data  ==  key)              return  ptr;          if  (key  <  ptr->data)             ptr  =  ptr->left;          else             ptr  =  ptr->right;     }      return   NULL ; } int   main (){      struct  node  * root

  #include   <stdio.h> #include   <stdlib.h> //Searching in Binary Search Tree struct   node {      int  data;      struct   node   * left;      struct   node   * right; }; struct   node   * create_tree ( int   data ){      struct   node   * n  =  ( struct   node   * ) malloc ( sizeof ( struct   node ));     n->data  =   data ;     n->left  =  n->right  =   NULL ;      return  n; } void   InOrder ( struct   node   * root ){      if  ( root   !=   NULL ){          InOrder ( root ->left);          printf ( " %d  " ,  root ->data);          InOrder ( root ->right);     } } struct   node   * search_bst ( struct   node   * root ,  int   key ){      if  ( root   ==   NULL )          return   NULL ;      if  ( root ->data  ==   key )          return   root ;      else   if  ( key   <   root ->data)          return   search_bst ( root ->left,  key );      else   if  ( key   >   root ->data)          return   search_bst ( root ->right

  #include   <stdio.h> #include   <stdlib.h> //Checking if tree is Binary Search Tree or Not! struct  node{      int  data;      struct  node  * left;      struct  node  * right; }; struct  node  * create_tree ( int   data ){      struct  node  * n  =  ( struct  node  * ) malloc ( sizeof ( struct  node  * ));     n->data  =  data;     n->left  =  n->right  =   NULL ; } void   tree_traversal ( struct  node  * root ){      if  (root  !=   NULL ){          tree_traversal (root->left);          printf ( " %d  " , root->data);          tree_traversal (root->right);     } } int   chk_bst ( struct  node  * root ){      static   struct  node  * prev  =   NULL ;      if  (root  !=   NULL ){          if  ( ! chk_bst (root->left))              return   0 ;          if  (prev  !=   NULL   &&  prev->data  >=  root->data)              return   0 ;         prev  =  root;          return   chk_bst (root->right);     }      else          re

  #include   <stdio.h> #include   <stdlib.h> //InOrder Traversal in Binary Tree struct   node {      int  data;      struct   node   * left;      struct   node   * right; }; struct   node   * create_array ( int   data ){      struct   node   * n  =  ( struct   node   * ) malloc ( sizeof ( struct   node ));     n->data  =   data ;     n->left  =  n->right  =   NULL ;      return  n; } void   tree_traversal ( struct   node   * root ){      if  ( root   !=   NULL ){          tree_traversal ( root ->left);          printf ( " %d  " ,  root ->data);          tree_traversal ( root ->right);     } } int   main (){      struct   node   * root  =   create_array ( 3 );      struct   node   * p1  =   create_array ( 1 );      struct   node   * p2  =   create_array ( 4 );      struct   node   * p3  =   create_array ( 0 );      struct   node   * p4  =   create_array ( 2 );      struct   node   * p5  =   create_array ( 5 );     root->left  =  p1;     root-&g

  #include   <stdio.h> #include   <stdlib.h> //Post Order Traversal in Binary Tree struct  node{      int  data;      struct  node  * left;      struct  node  * right; }; struct  node  * create_array ( int   data ){      struct  node  * n  =  ( struct  node  * ) malloc ( sizeof ( struct  node));     n->data  =  data;     n->left  =  n->right  =   NULL ;      return  n; } void   tree_traversal ( struct  node  * root ){      if  (root  !=   NULL ){          tree_traversal (root->left);          tree_traversal (root->right);          printf ( " %d  " , root->data);     } } int   main (){      struct  node  * root  =   create_array ( 5 );      struct  node  * p1  =   create_array ( 4 );      struct  node  * p2  =   create_array ( 3 );      struct  node  * p3  =   create_array ( 2 );      struct  node  * p4  =   create_array ( 1 );      struct  node  * p5  =   create_array ( 0 );     root->left  =  p3;     root->right  =  p2;     p3->right  =

  #include   <stdio.h> #include   <stdlib.h> //Preorder Traversal in Binary Tree struct  node{      int  data;      struct  node  * left;      struct  node  * right; }; struct  node  * create_array ( int   data ){      struct  node  * n  =  ( struct  node  * ) malloc ( sizeof ( struct  node));     n->data  =  data;     n->left  =  n->right  =   NULL ;      return  n; } void   tree_traversal ( struct  node  * root ){      if  (root  !=   NULL ){          printf ( " %d  " , root->data);          tree_traversal (root->left);          tree_traversal (root->right);     } } int   main (){      struct  node  * root  =   create_array ( 0 );      struct  node  * p1  =   create_array ( 1 );      struct  node  * p2  =   create_array ( 2 );      struct  node  * p3  =   create_array ( 3 );      struct  node  * p4  =   create_array ( 4 );      struct  node  * p5  =   create_array ( 5 );     root->left  =  p1;     root->right  =  p5;     p1->left  =  p

  #include   <stdio.h> #include   <stdlib.h> //Linked representation of a binary tree struct   node {      int  data;      struct   node   * left;      struct   node   * right; }; struct   node   * create_node ( int   data ){      struct   node   * n  =  ( struct   node   * ) malloc ( sizeof ( struct   node ));     n->data  =   data ;     n->left  =  n->right  =   NULL ;      return  n; } int   main (){      struct   node   * root  =   create_node ( 2 );      struct   node   * p1  =   create_node ( 3 );      struct   node   * p2  =   create_node ( 1 );      struct   node   * p3  =   create_node ( 7 );     root->left  =  p1;     root->right  =  p2;     p1->left  =  p3;      return   0 ; }

  #include   <stdio.h> //Count Sort Algorithm void   print_array ( int   * arr ,  int   size ){      for  ( int  i  =   0 ; i  <  size; i ++ )          printf ( " %d  " , arr[i]);      printf ( " \n " ); } void   count_sort ( int   * A ,  int   size ){      int  max  =  A[ 0 ];      for  ( int  i  =   0 ; i  <  size; i ++ ){          if  (max  <  A[i])             max  =  A[i];     }      int  count[max  +   1 ];      for  ( int  i  =   0 ; i  <=  max; i ++ )         count[i]  =   0 ;      for  ( int  i  =   0 ; i  <  size; i ++ )         count[A[i]] ++ ;      for  ( int  i  =   0 , j  =   0 ; i  <=  max; i ++ ){          while  (count[i]  !=   0 ){             A[j]  =  i;             count[i] -- ;             j ++ ;         }     } } int   main () {      int  A []   =  { 12 ,  4 ,  1 ,  6 ,  9 ,  15 ,  2 ,  6 ,  18 ,  13 };      int  size  =   10 ;      print_array (A, size);      count_sort (A, size);      print_array (A, size);      return

  #include   <stdio.h> //Merge Sort Algorithm void   print_array ( int   * arr ,  int   size ){      for  ( int  i  =   0 ; i  <   size ; i ++ )          printf ( " %d  " ,  arr [i]);      printf ( " \n " ); } void   merge ( int   * A ,  int   low ,  int   mid ,  int   high ){      int  temp[ high   +   1 ];      int  i  =   low , j  =   mid   +   1 , k  =   low ;      while  (i  <=   mid   &&  j  <=   high ){          if  ( A [i]  <   A [j]){             temp[k]  =   A [i];             i ++ ;             k ++ ;         }          else {             temp[k]  =   A [j];             j ++ ;             k ++ ;         }     }      while  (i  <=   mid ){         temp[k]  =   A [i];         i ++ ;         k ++ ;     }      while  (j  <=   high ){         temp[k]  =   A [j];         j ++ ;         k ++ ;     }      for  ( int  i  =   low ; i  <=   high ; i ++ )          A [i]  =  temp[i]; } void   merge_sort ( int   * A ,  int   low ,  in

  #include   <stdio.h> //Quick Sort Algorithm void   print_array ( int   * arr ,  int   size ){      for  ( int  i  =   0 ; i  <   size ; i ++ )          printf ( " %d  " ,  arr [i]);      printf ( " \n " ); } int   partition ( int   arr [] ,  int   low ,  int   high ){      int  pivot  =   arr [ low ];      int  i  =   low   +   1 , j  =   high ;      int  temp;      do {          while  ( arr [i]  <=  pivot)             i ++ ;          while  ( arr [j]  >  pivot)             j -- ;          if  (i  <  j){             temp  =   arr [i];              arr [i]  =   arr [j];              arr [j]  =  temp;         }     }  while  (i  <  j);     temp  =   arr [ low ];      arr [ low ]  =   arr [j];      arr [j]  =  temp;      return  j; } void   quick_sort ( int   arr [] ,  int   low ,  int   high ){      if  ( low   <   high ){          int  partition_index  =   partition ( arr ,  low ,  high );          quick_sort ( arr ,  low , partition_index 

  #include   <stdio.h> //Selection Sort Algorithm void   print_array ( int   * A ,  int   size ){      for  ( int  i  =   0 ; i  <   size ; i ++ )          printf ( " %d  " ,  A [i]);      printf ( " \n " ); } void   selection_sort ( int   * A ,  int   size ){      for  ( int  i  =   0 , k; i  <   size   -   1 ; i ++ ){          int  minimum  =   A [i];          for  ( int  j  =  i; j  <   size   -   1 ; j ++ ){              if  (minimum  >   A [j  +   1 ]){                 minimum  =   A [j  +   1 ];                 k  =  j  +   1 ;             }         }          int  temp  =   A [i];          A [i]  =  minimum;          A [k]  =  temp;     } } int   main (){      int  A []   =  { 5 ,  4 ,  3 ,  2 ,  1 ,  1 ,  2 ,  3 ,  4 ,  5 };      int  size  =   10 ;      print_array (A, size);      selection_sort (A, size);      print_array (A, size);      return   0 ; }