Question

Using the provided table interface table.h and the sample linked list code linkedList.c, complete an implementation of the Table ADT. Make sure that you apply the concepts of design by contract (DbC) to your implementation.

Once you have fully implemented the table, create a main.c file that implements a testing framework for your table.

Your table implementation must ensure that values inserted are unique, and internally sorted within a linked list.

table.h

#ifndef _TABLE_H
#define _TABLE_H

//-----------------------------------------------------------------------------
// CONSTANTS AND TYPES
//-----------------------------------------------------------------------------

typedef enum BOOL { false, true } Boolean;

//-----------------------------------------------------------------------------
// PROTOTYPES
//-----------------------------------------------------------------------------

// add an element to the table 
Boolean insertItem( int item );
// removes the int from the table
Boolean removeItem( int item );
// empty the table so that we clear all memory and can start a fresh table
void clearTable( );
// tells us whether or not the given item is in the table
Boolean search( int item );
// table iterators
Boolean firstItem( int * const item );
Boolean nextItem( int * const item );

#endif

linkedList.c

#include <stdio.h>
#include <stdlib.h>

typedef enum BOOL { false, true } bool;

// Linked list node definition
typedef struct Node node;

struct Node
{
        int   number;
        node  *next;
};

static node *top = NULL;
 
// used to track where we are for the list traversal methods
static node *traverseNode = NULL;
    
// "destroy" will deallocate all nodes in a linked list object
// and will set "top" to NULL.
void destroy()
{
  node *curr = top;
  node *temp = NULL;

  while ( curr != NULL )
  {
    // flip order to see it blow up...
    temp = curr;
    curr = curr->next;

    free( temp );
  }

  top = NULL;
}


// "build" will create an ordered linked list consisting
// of the first "size" even integers.
void build( int size )
{
  node *newNode = NULL;
  int i = 0;

  // make sure we don't have a list yet
  destroy();

  for ( i=size ; i>0 ; i-- )
  {
    newNode = malloc( sizeof( node ) );
    newNode->number = i*2;
    newNode->next = top;

    top = newNode;
  }
}


// starts a list traversal by getting the data at top.
// returns false if top == NULL.
bool firstNode( int *item )
{
  bool result = false;
  
  if ( top )
  {
    *item = top->number;
    
    traverseNode = top->next;
  
    result = true;
  }  
  
  return result;
}


// gets the data at the current traversal node and increments the traversal.
// returns false if we're at the end of the list.
bool nextNode( int *item )
{
  bool result = false;
  
  if ( traverseNode )
  {
    *item = traverseNode->number;
    
    traverseNode = traverseNode->next;
    
    result = true;
  }
  
  return result;
}


// "print" will output an object's entire linked list 
// to the standard output device -- one "number" per line.
void print()
{
  int value;
  
  if ( firstNode( &value ) )
  {
    do
    {
      printf( "%d\n", value );
    } while ( nextNode( &value ) );
  }
}

int main( int argc, char *argv[] )
{
  build( 10 );
  print();
  destroy();
  build( 5 );
  build( 20 );
  print();
  destroy();
  
  return 0;
}

Answer 1

khsdg

#include <stdio.h>
#include <stdlib.h>

typedef enum BOOL { false, true } bool;

// Linked list node definition

typedef struct Node node;

struct Node

{

int number;

node *next;

};

static node *top = NULL;

// used to track where we are for the list traversal methods

static node *traverseNode = NULL;

// "destroy" will deallocate all nodes in a linked list object

// and will set "top" to NULL.

void destroy()

{

node *curr = top;

node *temp = NULL;

while ( curr != NULL )

{

// flip order to see it blow up...

temp = curr;

curr = curr->next;

free( temp );

}

top = NULL;

}

// "build" will create an ordered linked list consisting

// of the first "size" even integers.

void build( int size )

{

node *newNode = NULL;

int i = 0;

// make sure we don't have a list yet

destroy();

for ( i=size ; i>0 ; i-- )

{

newNode = malloc( sizeof( node ) );

newNode->number = i*2;

newNode->next = top;

top = newNode;

}

}

// starts a list traversal by getting the data at top.

// returns false if top == NULL.

bool firstNode( int *item )

{

bool result = false;

if ( top )

{

*item = top->number;

traverseNode = top->next;

result = true;

}

return result;

}

// gets the data at the current traversal node and increments the traversal.

// returns false if we're at the end of the list.

bool nextNode( int *item )

{

bool result = false;

if ( traverseNode )

{

*item = traverseNode->number;

traverseNode = traverseNode->next;

result = true;

}

return result;

}

// "print" will output an object's entire linked list

// to the standard output device -- one "number" per line.

void print()

{

int value;

if ( firstNode( &value ) )

{

do

{
printf( "%d\n", value );

} while ( nextNode( &value ) );

}

}

int main( int argc, char *argv[] )

{

build( 10 );

print();

destroy();

build( 5 );

build( 20 );

print();

destroy();

return 0;

}