more

Author: FessorX

0-binary_tree_node.c

@@ -0,0 +1,23 @@
+#include "binary_trees.h"
+
+/**
+ * binary_tree_node - creates a binary tree node
+ * @parent: pointer to the parent node of the node to create
+ * @value: value to put in the new node
+ *
+ * Return: Pointer to the newly created node
+ *         NULL on failure
+ */
+binary_tree_t *binary_tree_node(binary_tree_t *parent, int value)
+{
+	binary_tree_t *new;
+
+	new = malloc(sizeof(binary_tree_t));
+	if (!new)
+		return (NULL);
+	new->n = value;
+	new->parent = parent;
+	new->left = NULL;
+	new->right = NULL;
+	return (new);
+}

1-binary_tree_insert_left.c

@@ -0,0 +1,31 @@
+#include "binary_trees.h"
+
+/**
+ * binary_tree_insert_left - inserts a node as the left-child of another node
+ * @parent: pointer to the node to insert the left-child in
+ * @value: value to store in the new node
+ *
+ * Return: Pointer to the newly created node
+ *         NULL on failure
+ *         NULL if parent is NULL
+ */
+binary_tree_t *binary_tree_insert_left(binary_tree_t *parent, int value)
+{
+	binary_tree_t *new;
+
+	if (!parent)
+		return (NULL);
+
+	new = malloc(sizeof(binary_tree_t));
+	if (!new)
+		return (NULL);
+
+	new->n = value;
+	new->parent = parent;
+	new->right = NULL;
+	new->left = parent->left;
+	parent->left = new;
+	if (new->left)
+		new->left->parent = new;
+	return (new);
+}

10-binary_tree_depth.c

@@ -0,0 +1,24 @@
+#include "binary_trees.h"
+
+/**
+ * binary_tree_depth - measures the depth of a node in a binary tree
+ * @tree: pointer to node to measure the depth of
+ *
+ * Return: depth of the node
+ *         0 if tree is NULL
+ */
+size_t binary_tree_depth(const binary_tree_t *tree)
+{
+	size_t depth = 0;
+
+	if (!tree)
+		return (0);
+
+	while (tree->parent)
+	{
+		depth++;
+		tree = tree->parent;
+	}
+
+	return (depth);
+}

100-binary_trees_ancestor.c

@@ -0,0 +1,40 @@
+#include "binary_trees.h"
+
+/**
+ * binary_trees_ancestor - finds the lowest common ancestor of two nodes
+ * @first: a pointer to the first node to find the ancestor
+ * @second: a pointer to the second node to find the ancestor
+ *
+ * Return: pointer to the ancestor node
+ *         NULL if there is no ancestor node
+ */
+binary_tree_t *binary_trees_ancestor(const binary_tree_t *first,
+				     const binary_tree_t *second)
+{
+	size_t depth_first, depth_second;
+
+	if (!first || !second)
+		return (NULL);
+
+	depth_first = binary_tree_depth(first);
+	depth_second = binary_tree_depth(second);
+
+	while (depth_first > depth_second)
+	{
+		first = first->parent;
+		depth_first--;
+	}
+	while (depth_second > depth_first)
+	{
+		second = second->parent;
+		depth_second--;
+	}
+	while (first && second)
+	{
+		if (first == second)
+			return ((binary_tree_t *)first);
+		first = first->parent;
+		second = second->parent;
+	}
+	return ((binary_tree_t *)first);
+}

101-binary_tree_levelorder.c

@@ -0,0 +1,36 @@
+#include "binary_trees.h"
+
+/**
+ * binary_tree_levelorder - traverse a binary tree using level-order traverse
+ * @tree: tree to traverse
+ * @func: pointer to a function to call for each node
+ */
+void binary_tree_levelorder(const binary_tree_t *tree, void (*func)(int))
+{
+	size_t level, maxlevel;
+
+	if (!tree || !func)
+		return;
+
+	maxlevel = binary_tree_height(tree) + 1;
+
+	for (level = 1; level <= maxlevel; level++)
+		btlo_helper(tree, func, level);
+}
+
+/**
+ * btlo_helper - goes through a binary tree using post-order traverse
+ * @tree: tree to traverse
+ * @func: pointer to a function to call for each node
+ * @level: the level of the tree to call func upon
+ */
+void btlo_helper(const binary_tree_t *tree, void (*func)(int), size_t level)
+{
+	if (level == 1)
+		func(tree->n);
+	else
+	{
+		btlo_helper(tree->left, func, level - 1);
+		btlo_helper(tree->right, func, level - 1);
+	}
+}

102-binary_tree_is_complete.c

@@ -0,0 +1,42 @@
+#include "binary_trees.h"
+
+/**
+ * binary_tree_is_complete - checks if a binary tree is complete
+ * @tree: a pointer to the root node of the tree to check
+ *
+ * Return: 1 if the tree is complete
+ *         0 if the tree is not complete
+ *         0 if tree is NULL
+ */
+int binary_tree_is_complete(const binary_tree_t *tree)
+{
+	size_t size;
+
+	if (!tree)
+		return (0);
+	size = binary_tree_size(tree);
+
+	return (btic_helper(tree, 0, size));
+}
+
+/**
+ * btic_helper - checks if a binary tree is complete
+ * @tree: a pointer to the root node of the tree to check
+ * @index: node index to check
+ * @size: number of nodes in the tree
+ *
+ * Return: 1 if the tree is complete
+ *         0 if the tree is not complete
+ *         0 if tree is NULL
+ */
+int btic_helper(const binary_tree_t *tree, size_t index, size_t size)
+{
+	if (!tree)
+		return (1);
+
+	if (index >= size)
+		return (0);
+
+	return (btic_helper(tree->left, 2 * index + 1, size) &&
+		btic_helper(tree->right, 2 * index + 2, size));
+}

103-binary_tree_rotate_left.c

@@ -0,0 +1,33 @@
+#include "binary_trees.h"
+
+/**
+ * binary_tree_rotate_left - performs a left-rotation on a binary tree
+ * @tree: a pointer to the root node of the tree to check
+ *
+ * Return: Pointer to the new root node of the tree once rotated
+ *         NULL on failure
+ */
+binary_tree_t *binary_tree_rotate_left(binary_tree_t *tree)
+{
+	binary_tree_t *tmp = NULL, *parent;
+
+	if (!tree || !tree->right)
+		return (NULL);
+	tmp = tree;
+	parent = tree->parent;
+	tree = tree->right;
+	tree->parent = NULL;
+	if (tree->left)
+	{
+		tmp->right = tree->left;
+		tree->left->parent = tmp;
+	}
+	else
+		tmp->right = NULL;
+	tmp->parent = tree;
+	tree->left = tmp;
+	if (parent)
+		parent->right = tree;
+	tree->parent = parent;
+	return (tree);
+}

104-binary_tree_rotate_right.c

@@ -0,0 +1,33 @@
+#include "binary_trees.h"
+
+/**
+ * binary_tree_rotate_right - performs a right-rotation on a binary tree
+ * @tree: a pointer to the root node of the tree to check
+ *
+ * Return: Pointer to the new root node of the tree once rotated
+ *         NULL on failure
+ */
+binary_tree_t *binary_tree_rotate_right(binary_tree_t *tree)
+{
+	binary_tree_t *tmp = NULL, *parent;
+
+	if (!tree || !tree->left)
+		return (NULL);
+	tmp = tree;
+	parent = tree->parent;
+	tree = tree->left;
+	tree->parent = NULL;
+	if (tree->right)
+	{
+		tmp->left = tree->right;
+		tree->right->parent = tmp;
+	}
+	else
+		tmp->left = NULL;
+	tmp->parent = tree;
+	tree->right = tmp;
+	if (parent)
+		parent->left = tree;
+	tree->parent = parent;
+	return (tree);
+}

11-binary_tree_size.c

@@ -0,0 +1,16 @@
+#include "binary_trees.h"
+
+/**
+ * binary_tree_size - measures the size of a binary tree
+ * @tree: pointer to root node of tree to measure
+ *
+ * Return: size of the tree
+ *         0 if tree is NULL
+ */
+size_t binary_tree_size(const binary_tree_t *tree)
+{
+	if (!tree)
+		return (0);
+
+	return (binary_tree_size(tree->left) + binary_tree_size(tree->right) + 1);
+}

110-binary_tree_is_bst.c

@@ -0,0 +1,36 @@
+#include "binary_trees.h"
+
+/**
+ * binary_tree_is_bst - checks if a binary tree is a valid Binary Search Tree
+ * @tree: a pointer to the root node of the tree to check
+ *
+ * Return: 1 if tree is a valid BST
+ *         0 otherwise
+ */
+int binary_tree_is_bst(const binary_tree_t *tree)
+{
+	if (!tree)
+		return (0);
+	return (btib_helper(tree, INT_MIN, INT_MAX));
+}
+
+/**
+ * btib_helper - checks if a binary tree is a valid Binary Search Tree
+ * @tree: a pointer to the root node of the tree to check
+ * @min: Lower bound of checked nored
+ * @max: Upper bound of checked nodes
+ *
+ * Return: 1 if tree is a valid BST
+ *         0 otherwise
+ */
+int btib_helper(const binary_tree_t *tree, int min, int max)
+{
+	if (!tree)
+		return (1);
+
+	if (tree->n < min || tree->n > max)
+		return (0);
+
+	return (btib_helper(tree->left, min, tree->n - 1) &&
+		btib_helper(tree->right, tree->n + 1, max));
+}

111-bst_insert.c

@@ -0,0 +1,48 @@
+#include "binary_trees.h"
+
+/**
+ * bst_insert - inserts a value in a Binary Search Tree
+ * @tree: a double pointer to the root node of the BST to insert the value
+ * @value: the value to store in the node to be inserted
+ * Return: A pointer to the created node
+ *         NULL on failure
+ */
+bst_t *bst_insert(bst_t **tree, int value)
+{
+	bst_t *new = NULL;
+	bst_t *second = NULL;
+	bst_t *tmp = NULL;
+
+	if (!tree)
+		return (NULL);
+	if (*tree == NULL)
+		return (*tree = binary_tree_node(NULL, value));
+
+	tmp = *tree;
+	while (tmp)
+	{
+		second = tmp;
+		if (value < tmp->n)
+			tmp = tmp->left;
+		else if (value > tmp->n)
+			tmp = tmp->right;
+		else if (value == tmp->n)
+			return (NULL);
+	}
+
+	new = binary_tree_node(NULL, value);
+	if (second == NULL)
+		second = new;
+	else if (value < second->n)
+	{
+		second->left = new;
+		new->parent = second;
+	}
+	else
+	{
+		second->right = new;
+		new->parent = second;
+	}
+
+	return (new);
+}

112-array_to_bst.c

@@ -0,0 +1,19 @@
+#include "binary_trees.h"
+
+/**
+ * array_to_bst - builds a Binary Search Tree from an array
+ * @array: pointer to the first element of the array 
+ * @size: the number of elements in the array
+ * Return: A pointer to the root node of the created BST
+ *         NULL on failure
+ */
+bst_t *array_to_bst(int *array, size_t size)
+{
+	unsigned int i;
+	bst_t *root = NULL;
+
+	for (i = 0; i < size; i++)
+		bst_insert(&root, array[i]);
+
+	return (root);
+}