592 lines
No EOL
19 KiB
C
592 lines
No EOL
19 KiB
C
// header files
|
|
#include "BST_Utility.h"
|
|
|
|
/* Data Structures
|
|
typedef struct stateDataStruct
|
|
{
|
|
char state[ MIN_STR_LEN ];
|
|
double avgTemp;
|
|
double lowestTemp;
|
|
double highestTemp;
|
|
|
|
struct stateDataStruct *leftChildPtr;
|
|
struct stateDataStruct *rightChildPtr;
|
|
} StateDataType;
|
|
Data Structures */
|
|
|
|
// function implementations
|
|
|
|
/*
|
|
Name: clearTree
|
|
Process: recursively returns dynamically allocated data to the OS
|
|
Function input/parameters: working pointer for recursion (StudentDataType *)
|
|
Function output/parameters: none
|
|
Function output/returned: empty tree (NULL)
|
|
Device input/ ---: none
|
|
Device output/ ---: none
|
|
Dependencies: free, clearTree (recursively)
|
|
*/
|
|
StateDataType *clearTree( StateDataType *wkgPtr )
|
|
{
|
|
// recurse through the left children
|
|
if(wkgPtr->leftChildPtr != NULL)
|
|
{
|
|
clearTree(wkgPtr->leftChildPtr);
|
|
}
|
|
// recurse through the right children
|
|
if(wkgPtr->rightChildPtr != NULL)
|
|
{
|
|
clearTree(wkgPtr->rightChildPtr);
|
|
}
|
|
// otherwise, free the working pointer if at end of getting to bottom tree
|
|
free(wkgPtr);
|
|
// return NULL since no tree left
|
|
return NULL;
|
|
} //DONE
|
|
|
|
/*
|
|
Name: privateCompareStrings
|
|
Process: compares two strings as follows:
|
|
- if left string is alphabetically greater than the right string,
|
|
returns value greater than zero
|
|
- if left string is alphabetically less than the right string,
|
|
returns value less than zero
|
|
- if strings are alphabetically equal but one is longer,
|
|
longer one is greater
|
|
- otherwise, returns zero
|
|
Function input/parameters: two strings to be compared (const char *)
|
|
Function output/parameters: none
|
|
Function output/returned: result as specified above (int)
|
|
Device input/ ---: none
|
|
Device output/ ---: none
|
|
Dependencies: privateGetStringLen
|
|
*/
|
|
int privateCompareStrings( const char *leftStr, const char *rightStr )
|
|
{
|
|
int diff, index = 0;
|
|
int leftStrLen = privateGetStringLen(leftStr);
|
|
int rightStrLen = privateGetStringLen(rightStr);
|
|
|
|
while(index < leftStrLen && index < rightStrLen)
|
|
{
|
|
diff = leftStr[index] - rightStr[index];
|
|
if(diff != 0)
|
|
{
|
|
return diff;
|
|
}
|
|
index = index + 1;
|
|
}
|
|
return leftStrLen - rightStrLen;
|
|
} //DONE
|
|
|
|
/*
|
|
Name: privateCopyString
|
|
Process: copies one string into another,
|
|
assumes destination string has appropriate capacity
|
|
Function input/parameters: source string (const char *)
|
|
Function output/parameters: destination string (const char *)
|
|
Function output/returned: none
|
|
Device input/ ---: none
|
|
Device output/ ---: none
|
|
Dependencies: none
|
|
*/
|
|
void privateCopyString( char *dest, const char *source )
|
|
{
|
|
int characterCount = 0;
|
|
// use a while loop, check for !NULL_CHAR
|
|
while(source[characterCount] != NULL_CHAR)
|
|
{
|
|
// copy the character accessed into dest string
|
|
dest[characterCount] = source[characterCount];
|
|
// iterate the number of characters
|
|
characterCount = characterCount + 1;
|
|
}
|
|
// add a NULL_CHAR once done, characterCount is in the right place for \0
|
|
dest[characterCount] = NULL_CHAR;
|
|
// no return, void
|
|
} //DONE
|
|
|
|
/*
|
|
Name: copyTree
|
|
Process: recursively duplicates the provided tree
|
|
using a pre order traversal strategy
|
|
Function input/parameters: working pointer for recursion (StateDataType *)
|
|
Function output/parameters: none
|
|
Function output/returned: pointer to duplicate tree (StateDataType *)
|
|
Device input/ ---: none
|
|
Device output/ ---: none
|
|
Dependencies: initializeStateNodeFromNode, copyTree (recursively)
|
|
*/
|
|
StateDataType *copyTree( StateDataType *wkgPtr )
|
|
{
|
|
// make a storage pointer
|
|
StateDataType *copyPtr = NULL;
|
|
// check for not equal to null
|
|
if(wkgPtr != NULL)
|
|
{
|
|
// create the pointer given data
|
|
copyPtr = initializeStateNodeFromNode(*wkgPtr);
|
|
// recurse left child
|
|
copyPtr->leftChildPtr = copyTree(wkgPtr->leftChildPtr);
|
|
// recurse right child
|
|
copyPtr->rightChildPtr = copyTree(wkgPtr->rightChildPtr);
|
|
}
|
|
// return copyPtr
|
|
return copyPtr;
|
|
}//DONE
|
|
|
|
/*
|
|
Name: displayInOrder
|
|
Process: recursively displays tree using in order traversal
|
|
Function input/parameters: working pointer for recursion (StateDataType *)
|
|
Function output/parameters: none
|
|
Function output/returned: none
|
|
Device input/ ---: none
|
|
Device output/ ---: none
|
|
Dependencies: stateDataToString, printf
|
|
*/
|
|
void displayInOrder( StateDataType *sdtPtr, int *itemNum )
|
|
{
|
|
// create empty string
|
|
char displayString[STD_STR_LEN];
|
|
if(sdtPtr != NULL)
|
|
{
|
|
// recurse to left node in tree
|
|
displayInOrder(sdtPtr->leftChildPtr, itemNum);
|
|
// increment the item
|
|
*itemNum = *itemNum + 1;
|
|
// setup the string
|
|
stateDataToString(*sdtPtr, displayString);
|
|
// print out the string
|
|
printf("%2d) %s", *itemNum, displayString);
|
|
// recurse to right node in tree
|
|
displayInOrder(sdtPtr->rightChildPtr, itemNum);
|
|
}
|
|
// no return, void
|
|
} //DONE
|
|
|
|
/*
|
|
Name: displayPostOrder
|
|
Process: recursively displays tree using post order traversal
|
|
Function input/parameters: working pointer for recursion (StateDataType *)
|
|
Function output/parameters: none
|
|
Function output/returned: none
|
|
Device input/ ---: none
|
|
Device output/ ---: none
|
|
Dependencies: stateDataToString, printf
|
|
*/
|
|
void displayPostOrder( StateDataType *sdtPtr, int *itemNum )
|
|
{
|
|
// create empty string
|
|
char displayString[STD_STR_LEN];
|
|
if(sdtPtr != NULL)
|
|
{
|
|
// recurse to left node in tree
|
|
displayPostOrder(sdtPtr->leftChildPtr, itemNum);
|
|
// recurse to right node in tree
|
|
displayPostOrder(sdtPtr->rightChildPtr, itemNum);
|
|
// increment the item
|
|
*itemNum = *itemNum + 1;
|
|
// setup the string
|
|
stateDataToString(*sdtPtr, displayString);
|
|
// print out the string
|
|
printf("%2d) %s", *itemNum, displayString);
|
|
}
|
|
// no return, void
|
|
} //DONE
|
|
|
|
/*
|
|
Name: displayPreOrder
|
|
Process: recursively displays tree using pre order traversal
|
|
Function input/parameters: working pointer for recursion (StateDataType *)
|
|
Function output/parameters: none
|
|
Function output/returned: none
|
|
Device input/ ---: none
|
|
Device output/ ---: none
|
|
Dependencies: stateDataToString, printf
|
|
*/
|
|
void displayPreOrder( StateDataType *sdtPtr, int *itemNum )
|
|
{
|
|
// create empty string
|
|
char displayString[STD_STR_LEN];
|
|
if(sdtPtr != NULL)
|
|
{
|
|
// increment the item
|
|
*itemNum = *itemNum + 1;
|
|
// setup the string
|
|
stateDataToString(*sdtPtr, displayString);
|
|
// print out the string
|
|
printf("%2d) %s", *itemNum, displayString);
|
|
// recurse to left node in tree
|
|
displayPostOrder(sdtPtr->leftChildPtr, itemNum);
|
|
// recurse to right node in tree
|
|
displayPostOrder(sdtPtr->rightChildPtr, itemNum);
|
|
}
|
|
// no return, void
|
|
} //DONE
|
|
|
|
/*
|
|
Name: privateGetStringLen
|
|
Process: finds length of string
|
|
Function input/parameters: string (const char *)
|
|
Function output/parameters: none
|
|
Function output/returned: calculated length of string (int)
|
|
Device input/ ---: none
|
|
Device output/ ---: none
|
|
Dependencies: none
|
|
*/
|
|
int privateGetStringLen( const char *str )
|
|
{
|
|
int strLen = 0;
|
|
// while through string until hit null.
|
|
while(str[strLen] != NULL_CHAR)
|
|
{
|
|
// increment the length string iterator
|
|
strLen = strLen + 1;
|
|
}
|
|
// return strLen
|
|
return strLen;
|
|
} //DONE
|
|
|
|
/*
|
|
Name: initializeBST
|
|
Process: sets BST root pointer to NULL, root pointer is returned by address
|
|
Function input/parameters: address of working pointer (StateDataType **)
|
|
Function output/parameters: address of updated working pointer
|
|
(StateDataType **)
|
|
Function output/returned: none
|
|
Device input/ ---: none
|
|
Device output/ ---: none
|
|
Dependencies: none
|
|
*/
|
|
void initializeBST( StateDataType **bstPtr )
|
|
{
|
|
// initialize the address of the BST to null
|
|
*bstPtr = NULL;
|
|
// no return, void
|
|
} //DONE
|
|
|
|
/*
|
|
Name: initializeStateNodeFromData
|
|
Process: captures data from individual data items,
|
|
dynamically creates new node,
|
|
copies data, and returns pointer to new node
|
|
Function input/parameters: data to be copied
|
|
name (const char *)
|
|
temperatures (double)
|
|
Function output/parameters: none
|
|
Function output/returned: pointer to new node as specified (StateDataType *)
|
|
Device input/ ---: none
|
|
Device output/ ---: none
|
|
Dependencies: malloc, sizeof, privateCopyString
|
|
*/
|
|
StateDataType *initializeStateNodeFromData( const char *state, double avgTemp,
|
|
double lowTemp, double highTemp )
|
|
{
|
|
// declare node
|
|
StateDataType *initNode;
|
|
// create the node using malloc
|
|
initNode = malloc(sizeof(StateDataType));
|
|
// copy the state into the node
|
|
privateCopyString(initNode->state, state);
|
|
// copy the avgTemp, lowTemp, and highTemp into node
|
|
initNode->avgTemp = avgTemp;
|
|
initNode->lowestTemp = lowTemp;
|
|
initNode->highestTemp = highTemp;
|
|
// return the node
|
|
return initNode;
|
|
} //DONE
|
|
|
|
/*
|
|
Name: initializeStateNodeFromNode
|
|
Process: captures data from source node pointer, dynamically creates new node,
|
|
copies data, and returns pointer to new node
|
|
Function input/parameters: node to be copied (StateDataType)
|
|
Function output/parameters: none
|
|
Function output/returned: pointer to new node as specified (StateDataType *)
|
|
Device input/ ---: none
|
|
Device output/ ---: none
|
|
Dependencies: initializeStateNodeFromData
|
|
Notes: one line of code
|
|
*/
|
|
StateDataType *initializeStateNodeFromNode( const StateDataType source )
|
|
{
|
|
// return the initializeStateNodeFromData function with correct data
|
|
return initializeStateNodeFromData(source.state, source.avgTemp,
|
|
source.lowestTemp, source.highestTemp);
|
|
} //DONE
|
|
|
|
/*
|
|
Name: insert
|
|
Process: recursively searches for available node in BST,
|
|
creates new node and returns it to the calling function,
|
|
if node is already in tree, data is overwritten
|
|
Function input/parameters: working pointer for recursion (StateDataType *),
|
|
node to be inserted (const StateDataType)
|
|
Function output/parameters: none
|
|
Function output/returned: pointer to new node as specified (StateDataType *)
|
|
Device input/ ---: none
|
|
Device output/ ---: none
|
|
Dependencies: privateCompareStrings,
|
|
setStateNodeData, initializeStateNodeFromNode
|
|
Notes: No redundant code permitted
|
|
*/
|
|
StateDataType *insert( StateDataType *wkgPtr, const StateDataType inData )
|
|
{
|
|
// define space for node
|
|
StateDataType *insertNode;
|
|
int stringComparator;
|
|
// check to see if the working pointer is not null
|
|
if(wkgPtr != NULL)
|
|
{
|
|
// set string comparator
|
|
stringComparator = privateCompareStrings(inData.state, wkgPtr->state);
|
|
// compare the value less than
|
|
if(stringComparator < 0)
|
|
{
|
|
// workingPtr -> nextPtr = insert(workingPtr->nextPtr, data);
|
|
wkgPtr->leftChildPtr = insert(wkgPtr->leftChildPtr, inData);
|
|
}
|
|
// compare the value greater than
|
|
if(stringComparator > 0)
|
|
{
|
|
// workingPtr -> nextPtr = insert(workingPtr->nextPtr, data);
|
|
wkgPtr->rightChildPtr = insert(wkgPtr->rightChildPtr, inData);
|
|
}
|
|
// compare the value equal to
|
|
if(stringComparator == 0)
|
|
{
|
|
// replaces the data (using setStateNodeData?)
|
|
setStateNodeData(wkgPtr, inData);
|
|
}
|
|
}
|
|
// otherwise, create node
|
|
else
|
|
{
|
|
// create the node using function
|
|
insertNode = initializeStateNodeFromNode(inData);
|
|
// return created node
|
|
return insertNode;
|
|
}
|
|
// return working pointer to prev recursion
|
|
return wkgPtr;
|
|
} //DONE
|
|
|
|
/*
|
|
Name: isEmpty
|
|
Process: tests root node for NULL, returns result
|
|
Function input/parameters: pointer to root node (StateDataType *)
|
|
Function output/parameters: none
|
|
Function output/returned: result of test as specified (bool)
|
|
Device input/ ---: none
|
|
Device output/ ---: none
|
|
Dependencies: none
|
|
*/
|
|
bool isEmpty( StateDataType *sdtPtr)
|
|
{
|
|
// return check for rootNode being NULL
|
|
return sdtPtr == NULL;
|
|
} //DONE
|
|
|
|
/*
|
|
Name: removeFromMin
|
|
Process: recursively searches for min node,
|
|
when found, node is unlinked from tree, and returned
|
|
Function input/parameters: pointers to parent and child nodes (StateDataType *)
|
|
Function output/parameters: none
|
|
Function output/returned: pointer to removed node (StateDataType *)
|
|
Device input/ ---: none
|
|
Device output/ ---: none
|
|
Dependencies: removeFromMin (recursively)
|
|
*/
|
|
StateDataType *removeFromMin( StateDataType *parentPtr,
|
|
StateDataType *childPtr )
|
|
{
|
|
// check to see if the left child pointer is null
|
|
if(childPtr->leftChildPtr != NULL)
|
|
{
|
|
// keep going left until end
|
|
childPtr->leftChildPtr = removeFromMin(childPtr, childPtr->leftChildPtr);
|
|
}
|
|
else
|
|
{
|
|
// once found, delink between the parent and child
|
|
parentPtr->leftChildPtr = childPtr->rightChildPtr;
|
|
}
|
|
// return removed ptr
|
|
return childPtr;
|
|
} //DONE
|
|
|
|
/*
|
|
Name: removeItem
|
|
Process: searches for item, if found, creates new node from search pointer,
|
|
then removes item from tree using helper function,
|
|
otherwise returns NULL
|
|
Function input/parameters: address of pointer to root node (StateDataType *),
|
|
node to be removed with at least state name key
|
|
(const StateDataType)
|
|
Function output/parameters: address of updated root node pointer
|
|
(StateDataType **)
|
|
Function output/returned: pointer to removed item node (StateDataType *)
|
|
Device input/ ---: none
|
|
Device output/ ---: none
|
|
Dependencies: search, initializeStateNodeFromNode, removeItemHelper
|
|
*/
|
|
bool removeItem( StateDataType **rootPtr,
|
|
StateDataType *removedData, const StateDataType outData )
|
|
{
|
|
// return false (temp)
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
Name: removeItemHelper
|
|
Process: recursively searches for item, removes node,
|
|
returns dynamic memory of removed node to OS,
|
|
returns updated link to parent (at each recursive level),
|
|
only one return at end of function
|
|
Function input/parameters: pointer to working node (StateDataType *),
|
|
node to be removed with at least state name key
|
|
(const StateDataType)
|
|
Function output/parameters: none
|
|
Function output/returned: link to recursive parent
|
|
Device input/ ---: none
|
|
Device output/ ---: none
|
|
Dependencies: privateCompareStrings, setStateDataNode, removeFromMin,
|
|
free, removeItemHelper (recursively)
|
|
Notes: No redundant code permitted
|
|
*/
|
|
StateDataType *removeItemHelper( StateDataType *wkgPtr,
|
|
const StateDataType outData )
|
|
{
|
|
// return NULL (temp)
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
Name: search
|
|
Process: recursively searches for item, if found, returns pointer to node,
|
|
otherwise, returns NULL
|
|
Function input/parameters: pointer to working node (StateDataType *),
|
|
node to be found with at least state name key
|
|
(const StateDataType)
|
|
Function output/parameters: none
|
|
Function output/returned: link to found node, or NULL, as specified
|
|
Device input/ ---: none
|
|
Device output/ ---: none
|
|
Dependencies: compareStrings
|
|
Notes: No redundant code permitted
|
|
*/
|
|
StateDataType *search( StateDataType *wkgPtr, const StateDataType searchData )
|
|
{
|
|
// define space for node
|
|
StateDataType *searchNode;
|
|
int stringComparator;
|
|
// check to see if the working pointer is not null
|
|
if(wkgPtr != NULL)
|
|
{
|
|
// set string comparator
|
|
stringComparator = privateCompareStrings(searchData.state, wkgPtr->state);
|
|
// compare the value less than
|
|
if(stringComparator < 0)
|
|
{
|
|
// workingPtr -> nextPtr = search(workingPtr->nextPtr, data);
|
|
wkgPtr->leftChildPtr = search(wkgPtr->leftChildPtr, searchData);
|
|
}
|
|
// compare the value greater than
|
|
if(stringComparator > 0)
|
|
{
|
|
// workingPtr -> nextPtr = search(workingPtr->nextPtr, data);
|
|
wkgPtr->rightChildPtr = search(wkgPtr->rightChildPtr, searchData);
|
|
}
|
|
// compare the value equal to
|
|
if(stringComparator == 0)
|
|
{
|
|
searchNode = wkgPtr;
|
|
// returns the data, finishes find.
|
|
return searchNode;
|
|
}
|
|
}
|
|
// otherwise, the data was not found, and must fail.
|
|
else
|
|
{
|
|
// return NULL
|
|
return NULL;
|
|
}
|
|
// return working pointer to prev recursion
|
|
return wkgPtr;
|
|
} //DONE
|
|
|
|
/*
|
|
Name: setStateNodeToEmpty
|
|
Process: sets state node to empty or default values
|
|
Function input/parameters: pointer to node (StateDataType *)
|
|
Function output/parameters: pointer to updated node (StateDataType *)
|
|
Function output/returned: none
|
|
Device input/ ---: none
|
|
Device output/ ---: none
|
|
Dependencies: none
|
|
*/
|
|
void setStateNodeToEmpty( StateDataType *node )
|
|
{
|
|
// set the state to null character
|
|
node->state[0] = '\0';
|
|
// set the average temp to 0
|
|
node->avgTemp = 0;
|
|
// set the lowest temp to 0
|
|
node->lowestTemp = 0;
|
|
// set the highest temp to 0
|
|
node->highestTemp = 0;
|
|
// (not sure if messing with pointers)
|
|
node->leftChildPtr = NULL;
|
|
node->rightChildPtr = NULL;
|
|
// no return, void
|
|
} //DONE
|
|
|
|
/*
|
|
Name: setStateNodeData
|
|
Process: copies data from source node to destination pointer
|
|
Function input/parameters: node to be copied (StateDataType)
|
|
Function output/parameters: destination pointer (StateDataType *)
|
|
Function output/returned: none
|
|
Device input/ ---: none
|
|
Device output/ ---: none
|
|
Dependencies: copyString
|
|
*/
|
|
void setStateNodeData( StateDataType *destPtr, const StateDataType source )
|
|
{
|
|
// copy the state from source to dest with privateCopyString
|
|
privateCopyString(destPtr->state, source.state);
|
|
// copy the average temp from source to dest
|
|
destPtr->avgTemp = source.avgTemp;
|
|
// copy the lowest temp from source to dest
|
|
destPtr->lowestTemp = source.lowestTemp;
|
|
// copy the highest temp from source to dest
|
|
destPtr->highestTemp = source.highestTemp;
|
|
// (not sure if messing with pointers)
|
|
// destPtr->leftChildPtr = source.leftChildPtr;
|
|
// destPtr->rightChildPtr = source.rightChildPtr;
|
|
// no return, void
|
|
} //DONE
|
|
|
|
/*
|
|
Name: stateDataToString
|
|
Process: sets data from node to formatted string
|
|
Function input/parameters: node with data to be set (StateDataType)
|
|
Function output/parameters: string array with result (char [])
|
|
Function output/returned: none
|
|
Device input/ ---: none
|
|
Device output/ ---: none
|
|
Dependencies: sprintf
|
|
*/
|
|
void stateDataToString( StateDataType stateData, char str[] )
|
|
{
|
|
// use sprintf to load the state name into str
|
|
// use sprintf to load the average temp into str
|
|
// use sprintf to load the lowest temp into str
|
|
// use sprintf to load the highest temp into str
|
|
// this is done all at once to avoid many lines
|
|
sprintf(str, "%s/%0.2f/%0.2f/%0.2f\n", stateData.state, stateData.avgTemp,
|
|
stateData.lowestTemp, stateData.highestTemp);
|
|
// no return, void
|
|
} //DONE
|