Hi, I am trying to implement a binary tree(not sorted) using recursion. I have figured out most of my function however GetMax and GetMin are confusing me.

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

typedef int TreeEntry;

typedef struct binary_tree_node {
TreeEntry item;
struct binary_tree_node * left;
struct binary_tree_node * right;
} BinaryTreeNode;

BinaryTreeNode* CreateNode(TreeEntry entry);
void            DestroyTree(BinaryTreeNode* root);
void            PrintInOrder(BinaryTreeNode* root);
void            PrintPreOrder(BinaryTreeNode* root);
void            PrintPostOrder(BinaryTreeNode* root);
int             GetHeight(BinaryTreeNode* root);

void            PrintReverseOrder(BinaryTreeNode* root);
int             GetSize(BinaryTreeNode* root);
int             GetSum(BinaryTreeNode* root);
int             GetMax(BinaryTreeNode* root);
int             GetMin(BinaryTreeNode* root);

BinaryTreeNode* CreateSampleTree();

void            Error(const char* msg);

int main(void)
{
BinaryTreeNode* tree = CreateSampleTree();

printf("In Order:      ");  PrintInOrder(tree); printf("\n");
printf("Reverse Order: ");  PrintReverseOrder(tree); printf("\n");

printf("Height: %d\n", GetHeight(tree));
printf("Size:   %d\n", GetSize(tree));
printf("Sum:    %d\n", GetSum(tree));
printf("Max:    %d\n", GetMax(tree));
printf("Min:    %d\n", GetMin(tree));

DestroyTree(tree);

return 0;
}

void Error(const char* msg)
{
printf("ERROR: %s\n", msg);
exit(EXIT_FAILURE);
}

BinaryTreeNode* CreateNode(TreeEntry entry)
{
BinaryTreeNode* node = (BinaryTreeNode*)malloc(sizeof(BinaryTreeNode));
if (node == NULL)
Error("Out of memory");
node->item = entry;
node->left = NULL;
node->right = NULL;
return node;
}

BinaryTreeNode* CreateSampleTree()
{
BinaryTreeNode* root = NULL;
BinaryTreeNode* parent = NULL;

/* create root node and its children */

root = CreateNode(2);
root->left = CreateNode(7);
root->right = CreateNode(5);

/* construct the left subtree */

parent = root->left;
parent->left = CreateNode(3);
parent->right = CreateNode(6);

parent = parent->right;
parent->left = CreateNode(5);
parent->right = CreateNode(11);

parent = parent->left;
parent->left = CreateNode(1);

/* construct the right subtree */

parent = root->right;
parent->right = CreateNode(9);

parent = parent->right;
parent->left = CreateNode(4);

return root;
}

void PrintInOrder(BinaryTreeNode* root)
{
if (root != NULL) {
PrintInOrder(root->left);
printf("%d ", root->item);
PrintInOrder(root->right);
}
}

void PrintPreOrder(BinaryTreeNode* root)
{
if (root != NULL) {
printf("%d ", root->item);
PrintPreOrder(root->left);
PrintPreOrder(root->right);
}
}

void PrintPostOrder(BinaryTreeNode* root)
{
if (root != NULL) {
PrintPostOrder(root->left);
PrintPostOrder(root->right);
printf("%d ", root->item);
}
}

void DestroyTree(BinaryTreeNode* root)
{
if (root != NULL) {
DestroyTree(root->left);
DestroyTree(root->right);
free(root);
}
}

int GetHeight(BinaryTreeNode* root)
{
if (root == NULL)
return 0;
else {
int leftHeight = GetHeight(root->left);
int rightHeight = GetHeight(root->right);

if (leftHeight > rightHeight)
return 1 + leftHeight;
else
return 1 + rightHeight;
}
}

void PrintReverseOrder(BinaryTreeNode* root)
{
if (root != NULL) {
PrintReverseOrder(root->right);
printf("%d ", root->item);
PrintReverseOrder(root->left);
}
}

int GetSize(BinaryTreeNode* root)
{
if (root == NULL)
return 0;
else {
return(GetSize(root->left) + 1 + GetSize(root->right));
}
}

int GetSum(BinaryTreeNode* root)
{
if(root == NULL){
return 0;
}
else{
return(GetSum(root->left) + root->item + GetSum(root->right));
}
}

/*
* The functions below here are the ones I can't figure out.
*/

int GetMax(BinaryTreeNode* root)
{
int max;
if(root == NULL){
return INT_MIN;
}
else{
return -1;
}

}

int GetMin(BinaryTreeNode* root)
{
if(root == NULL){
return INT_MAX;
}
else{
return -1;
}
}``````

Right now they return -1 (so that i can compile and test the rest of the code while i was working on it) that needs to be replaced by the recursive code to find the max and min. Thanks for the help.

Never mind I figured it out, here is the code for the GetMax and GetMin function for anyone else who may need it.

``````int GetMax(BinaryTreeNode* root)
{
int nodeItem, leftmax, rightmax, max;
max = -1;

if(root == NULL){
return INT_MIN;
}
else{
nodeItem = root->item;
leftmax = GetMax(root->left);
rightmax = GetMax(root->right);

if (leftmax > rightmax)
max = leftmax;
else
max = rightmax;
if (nodeItem > max)
max = nodeItem;
}

return max;
}

int GetMin(BinaryTreeNode* root)
{
int nodeItem, leftmax, rightmax, min;
min = -1;

if(root == NULL){
return INT_MAX;
}
else{
nodeItem = root->item;
leftmax = GetMin(root->left);
rightmax = GetMin(root->right);

if (leftmax < rightmax)
min = leftmax;
else
min = rightmax;
if (nodeItem < min)
min = nodeItem;
}

return min;
}``````
Be a part of the DaniWeb community

We're a friendly, industry-focused community of 1.18 million developers, IT pros, digital marketers, and technology enthusiasts learning and sharing knowledge.