ok, let me try to put it again

Code:
////////////////////
main.c
////////////////////
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "coll_a.h"     /* import the specification */ 


int (*private_print)(void *item);
int (*ItemCmp)(void *a, void *b);
  
int main();
{ 
  collection myCollection;
  int max_items;
  FILE *f1;
  int i;
  int j;
  j=100000000;
  int intData[1000];
  f1=fopen("out3.txt","wt");   

/* Generating 1000 integers from 100,000,001 to 100,001,000 */
  for (i =0; i <1000; i++)
  {
    intData[i] = ++j;
   } 

  printf("Testing Part A....\n\n");
  max_items = 1000;
  j = 0;
  myCollection = ConsCollection(max_items,ItemCmp);
  printf("adding 500 items\n");
  for (i = 0; i <500; i++) 
  {
    AddToCollection(myCollection, (void *)&intData[j ++]);
  }

  printf("deleting 400 items\n");
  for (i = 0; i <400; i++)
  {
    DeleteFromCollection(myCollection, (void *)&intData[--j]);
  }

  printf("adding the rest of 500 items\n");
  j+=400;
  for (i = 0; i <500; i++) 
  {
    AddToCollection(myCollection, (void *)&intData[++j]);
  }
  
  for (i=0;i <100;i++)
  {
   if((intData[i]%2)!=0)
      {
	   DeleteFromCollection(myCollection, (void *)&intData[i]);
      }
  }
  for (i=500;i<1000;i++)
  {
   if((intData[i]%2)!=0)
       { 
	   DeleteFromCollection(myCollection, (void *)&intData[i]);
       }
  } 
  InOrderTraversal(c,private_print);
}

  int ItemCmp(void *a, void *b)
 {
    long *d1,*d2;
   *d1=(long *)a;
   *d2=(long *)b;
   if(*d1>*d2)
     return -1; 
   else if(*d1<*d2)
     return 1;
   else
     return 0; 
  }

  int private_print(void *item)
 {  long *t;
   *t=(long *)item;
   if(t!=NULL)
     {printf("%d",*t ); 
      fprintf (f1, "\n%d",*t);
      }
   else
     {
	return 0;
      }
  }
Code:
/////////////////////////////////////
coll_at.c
////////////////////////////////
#include <stdlib.h>    /* calloc */
#include <stdio.h>      /* NULL */

#include <assert.h>     /* Needed for assertions */
#include "coll_a.h"     /* import the specification */ 


struct t_node
{
       void *item;
       struct t_node *left;
       struct t_node *right;
} node;

struct t_collection
{
       /* Note that size is not needed any longer! */
       int (*ItemCmp)( void *, void * ); 
       struct t_node *node;
};

collection ConsCollection(int max_items, int (*ItemCmp)(void *,void *))
/* Construct a data collection
       Pre-condition: (max_items > 0) && (item_size > 0) 
       Post-condition: returns a pointer to an empty
collection
*/
       {
       collection c;
       /* Although redundant, this assertion should be
               retained as it tests compliance with the formal 
                         specification */
       assert( max_items > 0 );
       c = (collection)calloc( 1, sizeof(struct t_collection) );
       c->node = (struct t_node *)0; 
       c->ItemCmp = ItemCmp;
       return c;
       }

static void AddToTree( struct t_node **t, struct t_node *data,
                       int (*ItemCmp)(void *, void *) )
       {
       struct t_node *base; 
       base = *t;
       /* If it's a null tree, just add it here */
       if ( base == NULL )
               {
               *t = data;
               return;
               }
       else
               {
               if ( ItemCmp( base->item, data ) < 0 )
                       {
                       AddToTree( &(base->left), data, ItemCmp );
                       }
               else 
                       AddToTree( &(base->right), data, ItemCmp );
               }
       }

void AddToCollection( collection c, void *item )
/* Add an item to a collection
       Pre-condition: (c is a collection created by a call to 
                                        ConsCollection) &&
                                               (existing item count < max_items) &&
                                               (item != NULL) 
       Post-condition: item has been added to c
*/
       {
       struct t_node *data, *node_p;
       assert( c != NULL );
       assert( item != NULL );
       /* Allocate space for a node for the data item */ 
       data = (struct t_node *)malloc(sizeof(struct t_node));
       /* Attach the item to the node */
       data->item = item;
       data->left = data->right = (struct t_node *)0;
       node_p = c->node; 
       AddToTree( &node_p, data, c->ItemCmp );
       c->node=node_p;
       }



void DeleteFromTree( struct t_node **t, void *item )
{
                                struct t_node *temp, *prev, *succ;
                                prev=temp=*t; 
                                void *val;
		*val=(void*)item;
										if(*t==NULL)
                                       printf("NO NODES TO BE DELETED");
                               else
                                       { 
                                        while(temp->item!=val && temp!=NULL)  //define val
                                                       {
                                                               prev=temp; 
                                                               if(temp->item >val)
                                                               temp=temp->left;
                                                               else 
                                                               temp=temp->right;
                                                       }            
                                                       if(temp==NULL)
                                                       {
                                                                       printf("the value could not be found\n");
                                                                       return; 
                                                       }                                     
                                                       if(temp->left!=NULL && temp->right!=NULL)
                                                       { 
                                                               prev=temp;
                                                               succ=temp->right;
                                                               while(succ->left!=NULL) 
                                                               {
                                                                       prev=succ;
                                                                       succ=succ->left; 
                                                               }
                                                               temp->item=succ->item;
                                                               temp=succ; 
                                                       }
                                                       if(temp->left!=NULL && temp->right==NULL)
                                                       { 
                                                                               if(prev->left==temp)
                                                                               prev->left=temp->left;
                                                                               else
                                                                               prev->right=temp->left;
                                                       } 
                                                       if(temp->left==NULL && temp->right!=NULL)
                                                       {
                                                                               if(prev->left==temp) 
                                                                               prev->left=temp->right;
                                                                               else
                                                                               prev->right=temp->right; 
                                                       }
                                                       if(temp->left==NULL && temp->right==NULL)
                                                       { 
                                                                       if(prev->left==temp)
                                                                       prev->left=NULL;
                                                                       else 
                                                                       prev->right=NULL;
                                                       }
                                                     /*  if(temp==*root)                      // define root
                                                       {
                                                               if(temp->left!=NULL)
                                                               *root=temp->left; 
                                                               else
                                                               *root=temp->right;
                                                       }*/
                       free(temp);
}


void DeleteFromCollection( collection c, void *item )
/* Delete an item from a collection
       Pre-condition: (c is a collection created by a call to
                                                       ConsCollection) && 
                                               (existing item count >= 1) &&
                                               (item != NULL)
       Post-condition: item has been deleted from c
*/
       {
       struct t_node *node;
       assert( c != NULL );
                 /* The requirement that the collection has at least
                         one item is expressed a little differently */
       assert( c->node != NULL ); 
       assert( item != NULL);
       /* Select node at head of list */
       node = c->node;
       DeleteFromTree( &node, item );
       c->node=node;
       }

void *FindInTree( struct t_node *t, void *key )
       {
                               if(t==NULL)
                                return;
                               else if(t->item==key)
                                return t;
                               else if ( ItemCmp( t->item, key ) < 0 ) 
                                return FindInTree( (t->left), key );
                               else
                                return FindInTree( (t->right), key );
               }

void *FindInCollection( collection c, void *key )
/* Find an item in a collection
       Pre-condition: (c is a collection created by a call to
ConsCollection) &&
                                               (key != NULL) 
       Post-condition: returns an item identified by key if
                                                 one exists, otherwise returns NULL
*/
       {
       struct t_node *node;
       assert( c != NULL ); 
       assert( key != NULL );
       /* Select node at head of list */
       node = c->node;
       return FindInTree( node, key );
       }
}

 
 void InOrderTreeTraversal(struct t_node *t, int(*private_print)(void *item))
{
       if(t != NULL)
       {
               InOrderTreeTraversal(t->left,private_print);
               private_print(t->item);
               InOrderTreeTraversal(t->right, private_print);
       }
}

void InOrderTraversal(collection c, int(*private_print)(void *item))
{
       assert(c != NULL);
       InOrderTreeTraversal(c->node,private_print);
}
Code:
//////////////////////////////////////
coll_a.h
/////////////////////////////////
/* Specification for collection */

typedef struct t_collection *collection;

collection ConsCollection( int max_items, 
		int (*ItemCmp)(void *, void *) );
/* Construct a new collection
   Pre-condition: max_items > 0
   Post-condition: returns a pointer to an empty collection
*/

void AddToCollection( collection c, void *item );
/* Add an item to a collection
   Pre-condition: (c is a collection created by a call to
                       ConsCollection) &&
                  (existing item count < max_items) &&
                  (item != NULL)
   Post-condition: item has been added to c
*/

void DeleteFromCollection( collection c, void *item );
/* Delete an item from a collection
   Pre-condition: (c is a collection created by a call to
                     ConsCollection) &&
                  (existing item count >= 1) &&
         	  (item != NULL)
   Post-condition: item has been deleted from c
*/

void *FindInCollection( collection c, void *key );
/* Find an item in a collection
   Pre-condition: c is a collection created by a call to
                     ConsCollection
                  key != NULL
   Post-condition: returns an item identified by key if one
                   exists, otherwise returns NULL
*/

void InOrderTraversal(collection c, int(*private_print)(void *item))
/////////////////////////////////////////////////////////
the compile time errors which I am unable to solve

ont> gcc -c main.c coll_at.c
main.c: In function `InOrderTraversal':
main.c:15: error: old-style parameter declarations in prototyped function definition
main.c:34: error: `ItemCmp' undeclared (first use in this function)
main.c:34: error: (Each undeclared identifier is reported only once
main.c:34: error: for each function it appears in.)
main.c: In function `ItemCmp':
main.c:73: warning: assignment makes integer from pointer without a cast
main.c:74: warning: assignment makes integer from pointer without a cast
main.c: In function `private_print':
main.c:85: warning: assignment makes integer from pointer without a cast
main.c:88: error: `f1' undeclared (first use in this function)
main.c:93: error: syntax error at end of input
coll_at.c: In function `InOrderTraversal':
coll_at.c:13: warning: structure defined inside parms
coll_at.c:20: warning: structure defined inside parms
coll_at.c:20: warning: empty declaration
coll_at.c:29: error: syntax error before '{' token
coll_at.c:92: error: syntax error before '*' token

i hope the code is now acceptable for a review
thanks a lot

Last edited by shabbir; 23Mar2007 at 09:15.. Reason: Code formating.