Code for Printing a Binary Search Tree Vertically

BredT2.c

#include "main.h"
/**
 * Traverse_Breadth2 - same function with more features.
 * 
 * @root: root of tree
*/

void Traverse_Breadth2(treenode *root)
{
	if (root == NULL)
	{
		return;
	}

	int treeHeight = find_depth(root);
	int nodesInLevel, nodesInNextLevel, spaces;
	Queue *q = createQueue();
	treenode *current;

	enqueue(q, root);

	for (int level = 1; level <= treeHeight; level++)
	{
		nodesInLevel = 1 << (level - 1);
		nodesInNextLevel = nodesInLevel;
		spaces = (1 << (treeHeight - level + 1) - 1);

		printSpaces(spaces);

		for (int i = 0; i < nodesInLevel; i++)
		{
			current = dequeue(q);

			if (current != NULL)
			{
				printf("%d", current->data);
				enqueue(q, current->left);
				enqueue(q, current->right);
			}
			else
			{
				printf(" ");
				enqueue(q, NULL);
				enqueue(q, NULL);
			}

			if (i < nodesInLevel - 1) {
				printSpaces(4);
			}
		}
	
		printf("\n");

	for (int i = 0; i < nodesInNextLevel; i++)
	{
		printSpaces(spaces	-	2);

		if (current == NULL)
		{
			printSpaces(2);
			continue;
		}

		if (current->left == NULL && current->right == NULL)
		{
			continue;
		}
		else if (current->left != NULL && current->right == NULL)
		{
			printSpaces(2);
			putchar('/');
		}
		else if (current->left == NULL && current->right != NULL)
		{
			printSpaces(3);
			putchar('\\');
		}else
		{
			printSpaces(2);
			putchar('/');
			printSpaces(2);
			putchar('\\');
		}
	}
		printf("\n");
	}
	free(q);
}

calculatedepth.c

#include "main.h"

/**
 * find_depth - calculates depth of tree
 *
 * @root: root of tree
 *
 * Return: depth value
*/

int find_depth(treenode *root)
{
	int leftdepth, rightdepth;

	leftdepth = rightdepth = 0;

	if (root == NULL)
		return (0);

	leftdepth = find_depth(root->left);
	rightdepth = find_depth(root->right);

	return ((leftdepth > rightdepth ? leftdepth : rightdepth) + 1);
}

free.c

#include "main.h"

/*
 *free_tree - frees tree
 * 
 * @root - tree root
 *
 * */
void free_tree(treenode* root) 
{
	if (root == NULL) 
	{
		return;
	}
	free_tree(root->left);
	free_tree(root->right);
	free(root);
}

insert.c

#include "main.h"

/**
 *insert_tnode - inserts a treenode in a binary search tree
 *
 * @treeroot: root of tree
 * @inserted_data: data to insert
 *
 * Return: pointer to new node
 */

treenode *insert_tnode(treenode *treeroot, int inserted_data)
{
	treenode *navigator = treeroot;

	if (navigator == NULL)
	{
		navigator = (treenode *)malloc(sizeof(treenode));
		if (navigator == NULL)
		{
			exit(98);
		}
		else
		{
		navigator->data = inserted_data;
		navigator->right = NULL;
		navigator->left = NULL;
		return (navigator);
		}
	}

	if (inserted_data > navigator->data)
	{
		navigator->right = insert_tnode(navigator->right, inserted_data);
	}
	else if (inserted_data < navigator->data)
	{
		navigator->left = insert_tnode(navigator->left, inserted_data);
	}
	else
	{
		printf("This number already exists in the tree");
		return (NULL);
	}
	return (navigator);
}

/**
 * newNode - create a new node with given data
 *
 * @address: address of treenode stored in linked list
 *
 * Return: Return a pointer to new node
 */

Node *newNode(treenode *address)
{
	Node *node = (Node *)malloc(sizeof(node));

	node->address = address;
	node->next = NULL;
	return (node);
}

main.c

#include "main.h"

/**
* main - tests code
*
* Return: 0 on success, 1 on failure
*/

int main(void)
{
	treenode *root = NULL;
	Queue q;
	int left1, right2, depth;

	root = insert_tnode(root, 5);
	insert_tnode(root, 45);
	insert_tnode(root, 25);
	insert_tnode(root, 7);
	insert_tnode(root, 10);
	insert_tnode(root, 3);
	insert_tnode(root, 105);
	insert_tnode(root, 2);
	insert_tnode(root, 4);
	insert_tnode(root, 1);

	printf("\n");
	Traverse_Breadth2(root);

	free_tree(root);
	return (0);
}

main.h

#ifndef MAIN_H
#define MAIN_H

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

/**
 * struct treenode - struct for trees
 * @data: data stored inside treenode
 * @right: pointer to right subtree
 * @left: pointer to left subtree
 *
 * Description: The struct I'll be using to make my trees
*/
typedef struct treenode
{
	int data;
	struct treenode *right;
	struct treenode *left;
} treenode;

/**
 * struct Node - struct for linked lists
 * @address: address of treenode stored in node
 * @next: pointer to next node
 *
 * Description: Struct used for simple linked lists
*/
typedef struct Node
{
	treenode *address;
	struct Node *next;
} Node;

/**
 * struct Queue - struct for queues
 * @front: front of queue
 * @rear: back of queue
*/

typedef struct Queue
{
	Node *front, *rear;
} Queue;

treenode *insert_tnode(treenode *treeroot, int inserted_data);
Node *newNode(treenode *data);

Queue *createQueue();
void enqueue(Queue *q, treenode *address);
treenode *dequeue(Queue *q);

void free_tree(treenode *root);
int print_horizontal(treenode *root);
int find_depth(treenode *root);
int ReturnMAX(treenode *root);
int ReturnMIN(treenode *root);

void Traverse_Breadth(treenode *root);

void printSpaces(int numSpaces);
void Traverse_Breadth2(treenode *root);

#endif

printspaces.c

#include "main.h"
/**
 * printSpaces - prints spaces based on input
 *
 * @numSpaces: number of spaces
*/

void printSpaces(int numSpaces)
{
	for (int i = 0; i < numSpaces; i++)
	{
		printf(" ");
	}
}

queuefunctions.c

#include "main.h"

/**
 * createQueue - Function to create an empty queue
 *
 * Return: pointer to Queue
 */

Queue *createQueue()
{
	Queue *q;

	q = (Queue *)malloc(sizeof(Queue));

	q->front = q->rear = NULL;
	return (q);
}

/**
 * enqueue - Function to add an element to the rear of the queue
 *
 * @q: pointer to q
 * @address: ptr to treenode
 */
void enqueue(Queue *q, treenode *address)
{
	Node *node = newNode(address);

	if (q->rear == NULL)
	{
		q->front = q->rear = node;
		return;
	}
	q->rear->next = node;
	q->rear = node;
}

/**
 * dequeue - Function to remove an element from the front of the queue
 *
 * @q: pointer to q
 * Return: treenode at front of queue
 */
treenode *dequeue(Queue *q)
{
	Node *temp;
	treenode *res;

	if (q->front == NULL)
		return (NULL);

	temp = q->front;
	q->front = q->front->next;

	if (q->front == NULL)
		q->rear = NULL;

	res = temp->address;

	free(temp);
	return (res);
}