https://github.com/hackersa3edy/binary_trees
This repository contains C programs for various operations on binary trees, including node manipulation, tree traversal, and property checks (like height, depth, size, and balance factor).
https://github.com/hackersa3edy/binary_trees
algorithms alx-software-engineering binary-tree c c-language c-programming data-structures tree-traversal valgrind
Last synced: about 1 year ago
JSON representation
This repository contains C programs for various operations on binary trees, including node manipulation, tree traversal, and property checks (like height, depth, size, and balance factor).
- Host: GitHub
- URL: https://github.com/hackersa3edy/binary_trees
- Owner: hackerSa3edy
- Created: 2024-01-31T03:53:09.000Z (about 2 years ago)
- Default Branch: master
- Last Pushed: 2024-08-20T06:58:50.000Z (over 1 year ago)
- Last Synced: 2025-01-02T18:49:47.660Z (about 1 year ago)
- Topics: algorithms, alx-software-engineering, binary-tree, c, c-language, c-programming, data-structures, tree-traversal, valgrind
- Language: C
- Homepage:
- Size: 42 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# Binary Tree Project
## Objectives
This project aims to provide a comprehensive understanding of binary trees, including their structure, operations, and various properties. The objectives include:
1. **Understanding Binary Trees**: Clarify the concept of a binary tree and its basic structure.
2. **Difference Between Binary Tree and Binary Search Tree**: Highlight the distinctions between a binary tree and a binary search tree (BST), focusing on their key characteristics and use cases.
3. **Time Complexity Gain Compared to Linked Lists**: Discuss the potential advantages in terms of time complexity that binary trees offer over linked lists for certain operations.
4. **Exploration of Binary Tree Properties**: Introduce essential properties such as depth, height, and size of a binary tree and their significance in analyzing tree structures.
5. **Traversal Methods**: Present various traversal methods used to navigate through binary trees, including pre-order, in-order, and post-order traversals.
6. **Types of Binary Trees**: Define different types of binary trees such as complete, full, perfect, and balanced trees, highlighting their characteristics and applications.
## Subtasks
### 0. New node
**file:**
[0-binary_tree_node.c](./0-binary_tree_node.c)
**Description:**
Create a function that creates a binary tree node.
- Prototype: `binary_tree_t *binary_tree_node(binary_tree_t *parent, int value);`
- Where `parent` is a pointer to the parent node of the node to create
- And `value` is the value to put in the new node
- When created, a node does not have any child
- Your function must return a pointer to the new node, or NULL on failure
```c
alex@/tmp/binary_trees$ cat 0-main.c
#include
#include "binary_trees.h"
/**
* main - Entry point
*
* Return: Always 0 (Success)
*/
int main(void)
{
binary_tree_t *root;
root = binary_tree_node(NULL, 98);
root->left = binary_tree_node(root, 12);
root->left->left = binary_tree_node(root->left, 6);
root->left->right = binary_tree_node(root->left, 16);
root->right = binary_tree_node(root, 402);
root->right->left = binary_tree_node(root->right, 256);
root->right->right = binary_tree_node(root->right, 512);
binary_tree_print(root);
return (0);
}
alex@/tmp/binary_trees$ gcc -Wall -Wextra -Werror -pedantic binary_tree_print.c 0-main.c 0-binary_tree_node.c -o 0-node
alex@/tmp/binary_trees$ ./0-node
.-------(098)-------.
.--(012)--. .--(402)--.
(006) (016) (256) (512)
alex@/tmp/binary_trees$
```
### 1. Insert left
**file:**
[1-binary_tree_insert_left.c](./1-binary_tree_insert_left.c)
**Description:**
Implement a function to insert a node as the left-child of another node.
- Prototype: `binary_tree_t *binary_tree_insert_left(binary_tree_t *parent, int value);`
- Where `parent` is a pointer to the node to insert the left-child in
- And `value` is the value to store in the new node
- Your function must return a pointer to the created node, or `NULL` on failure or if `parent` is `NULL`
- If `parent` already has a left-child, the new node must take its place, and the old left-child must be set as the left-child of the new node.
```c
alex@/tmp/binary_trees$ cat 1-main.c
#include
#include
#include "binary_trees.h"
/**
* main - Entry point
*
* Return: Always 0 (Success)
*/
int main(void)
{
binary_tree_t *root;
root = binary_tree_node(NULL, 98);
root->left = binary_tree_node(root, 12);
root->right = binary_tree_node(root, 402);
binary_tree_print(root);
printf("\n");
binary_tree_insert_left(root->right, 128);
binary_tree_insert_left(root, 54);
binary_tree_print(root);
return (0);
}
alex@/tmp/binary_trees$ gcc -Wall -Wextra -Werror -pedantic binary_tree_print.c 1-main.c 1-binary_tree_insert_left.c 0-binary_tree_node.c -o 1-left
alex@/tmp/binary_trees$ ./1-left
.--(098)--.
(012) (402)
.--(098)-------.
.--(054) .--(402)
(012) (128)
alex@/tmp/binary_trees$
```
### 2. Insert right
**file:**
[2-binary_tree_insert_right.c](./2-binary_tree_insert_right.c)
**Description:**
Develop a function to insert a node as the right-child of another node.
- Prototype: `binary_tree_t *binary_tree_insert_right(binary_tree_t *parent, int value);`
- Where `parent` is a pointer to the node to insert the right-child in
- And `value` is the value to store in the new node
- Your function must return a pointer to the created node, or `NULL` on failure or if `parent` is `NULL`
- If `parent` already has a right-child, the new node must take its place, and the old right-child must be set as the right-child of the new node.
```c
alex@/tmp/binary_trees$ cat 2-main.c
#include
#include
#include "binary_trees.h"
/**
* main - Entry point
*
* Return: Always 0 (Success)
*/
int main(void)
{
binary_tree_t *root;
root = binary_tree_node(NULL, 98);
root->left = binary_tree_node(root, 12);
root->right = binary_tree_node(root, 402);
binary_tree_print(root);
printf("\n");
binary_tree_insert_right(root->left, 54);
binary_tree_insert_right(root, 128);
binary_tree_print(root);
return (0);
}
alex@/tmp/binary_trees$ gcc -Wall -Wextra -Werror -pedantic binary_tree_print.c 2-main.c 2-binary_tree_insert_right.c 0-binary_tree_node.c -o 2-right
alex@/tmp/binary_trees$ ./2-right
.--(098)--.
(012) (402)
.-------(098)--.
(012)--. (128)--.
(054) (402)
alex@/tmp/binary_trees$
```
### 3. Delete
**file:**
[3-binary_tree_delete.c](./3-binary_tree_delete.c)
**Description:**
Write a function to delete an entire binary tree.
- Prototype: `void binary_tree_delete(binary_tree_t *tree);`
- Where `tree` is a pointer to the root node of the tree to delete
- If `tree` is `NULL`, do nothing
```c
alex@/tmp/binary_trees$ cat 3-main.c
#include
#include
#include "binary_trees.h"
/**
* main - Entry point
*
* Return: Always 0 (Success)
*/
int main(void)
{
binary_tree_t *root;
root = binary_tree_node(NULL, 98);
root->left = binary_tree_node(root, 12);
root->right = binary_tree_node(root, 402);
binary_tree_insert_right(root->left, 54);
binary_tree_insert_right(root, 128);
binary_tree_print(root);
binary_tree_delete(root);
return (0);
}
alex@/tmp/binary_trees$ gcc -Wall -Wextra -Werror -pedantic binary_tree_print.c 3-main.c 3-binary_tree_delete.c 0-binary_tree_node.c 2-binary_tree_insert_right.c -o 3-del
alex@/tmp/binary_trees$ valgrind ./3-del
==13264== Memcheck, a memory error detector
==13264== Copyright (C) 2002-2013, and GNU GPL'd, by Julian Seward et al.
==13264== Using Valgrind-3.10.1 and LibVEX; rerun with -h for copyright info
==13264== Command: ./3-del
==13264==
.-------(098)--.
(012)--. (128)--.
(054) (402)
==13264==
==13264== HEAP SUMMARY:
==13264== in use at exit: 0 bytes in 0 blocks
==13264== total heap usage: 9 allocs, 9 frees, 949 bytes allocated
==13264==
==13264== All heap blocks were freed -- no leaks are possible
==13264==
==13264== For counts of detected and suppressed errors, rerun with: -v
==13264== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
alex@/tmp/binary_trees$
```
### 4. Is leaf
**file:**
[4-binary_tree_is_leaf.c](./4-binary_tree_is_leaf.c)
**Description:**
Create a function to check if a node is a leaf.
- Prototype: `int binary_tree_is_leaf(const binary_tree_t *node);`
- Where `node` is a pointer to the node to check
- Your function must return `1` if `node` is a leaf, otherwise `0`
- If `node` is `NULL`, return `0`
```c
alex@/tmp/binary_trees$ cat 4-main.c
#include
#include
#include "binary_trees.h"
/**
* main - Entry point
*
* Return: Always 0 (Success)
*/
int main(void)
{
binary_tree_t *root;
int ret;
root = binary_tree_node(NULL, 98);
root->left = binary_tree_node(root, 12);
root->right = binary_tree_node(root, 402);
binary_tree_insert_right(root->left, 54);
binary_tree_insert_right(root, 128);
binary_tree_print(root);
ret = binary_tree_is_leaf(root);
printf("Is %d a leaf: %d\n", root->n, ret);
ret = binary_tree_is_leaf(root->right);
printf("Is %d a leaf: %d\n", root->right->n, ret);
ret = binary_tree_is_leaf(root->right->right);
printf("Is %d a leaf: %d\n", root->right->right->n, ret);
return (0);
}
alex@/tmp/binary_trees$ gcc -Wall -Wextra -Werror -pedantic binary_tree_print.c 4-binary_tree_is_leaf.c 4-main.c 0-binary_tree_node.c 2-binary_tree_insert_right.c -o 4-leaf
alex@/tmp/binary_trees$ ./4-leaf
.-------(098)--.
(012)--. (128)--.
(054) (402)
Is 98 a leaf: 0
Is 128 a leaf: 0
Is 402 a leaf: 1
alex@/tmp/binary_trees$
```
### 5. Is root
**file:**
[5-binary_tree_is_root.c](./5-binary_tree_is_root.c)
**Description:**
Implement a function to check if a given node is a root.
- Prototype: `int binary_tree_is_root(const binary_tree_t *node);`
- Where `node` is a pointer to the node to check
- Your function must return `1` if `node` is a root, otherwise `0`
- If `node` is `NULL`, return `0`
```c
alex@/tmp/binary_trees$ cat 5-main.c
#include
#include
#include "binary_trees.h"
/**
* main - Entry point
*
* Return: Always 0 (Success)
*/
int main(void)
{
binary_tree_t *root;
int ret;
root = binary_tree_node(NULL, 98);
root->left = binary_tree_node(root, 12);
root->right = binary_tree_node(root, 402);
binary_tree_insert_right(root->left, 54);
binary_tree_insert_right(root, 128);
binary_tree_print(root);
ret = binary_tree_is_root(root);
printf("Is %d a root: %d\n", root->n, ret);
ret = binary_tree_is_root(root->right);
printf("Is %d a root: %d\n", root->right->n, ret);
ret = binary_tree_is_root(root->right->right);
printf("Is %d a root: %d\n", root->right->right->n, ret);
return (0);
}
alex@/tmp/binary_trees$ gcc -Wall -Wextra -Werror -pedantic binary_tree_print.c 5-binary_tree_is_root.c 5-main.c 0-binary_tree_node.c 2-binary_tree_insert_right.c -o 5-root
alex@/tmp/binary_trees$ ./5-root
.-------(098)--.
(012)--. (128)--.
(054) (402)
Is 98 a root: 1
Is 128 a root: 0
Is 402 a root: 0
alex@/tmp/binary_trees$
```
### 6. Pre-order traversal
**file:**
[6-binary_tree_preorder.c](./6-binary_tree_preorder.c)
**Description:**
Develop a function to traverse a binary tree using pre-order traversal.
- Prototype: `void binary_tree_preorder(const binary_tree_t *tree, void (*func)(int));`
- Where `tree` is a pointer to the root node of the tree to traverse
- And `func` is a pointer to a function to call for each node. The value in the node must be passed as a parameter to this function.
- If `tree` or `func` is `NULL`, do nothing
```c
alex@/tmp/binary_trees$ cat 6-main.c
#include
#include
#include "binary_trees.h"
/**
* print_num - Prints a number
*
* @n: Number to be printed
*/
void print_num(int n)
{
printf("%d\n", n);
}
/**
* main - Entry point
*
* Return: Always 0 (Success)
*/
int main(void)
{
binary_tree_t *root;
root = binary_tree_node(NULL, 98);
root->left = binary_tree_node(root, 12);
root->right = binary_tree_node(root, 402);
root->left->left = binary_tree_node(root->left, 6);
root->left->right = binary_tree_node(root->left, 56);
root->right->left = binary_tree_node(root->right, 256);
root->right->right = binary_tree_node(root->right, 512);
binary_tree_print(root);
binary_tree_preorder(root, &print_num);
return (0);
}
alex@/tmp/binary_trees$ gcc -Wall -Wextra -Werror -pedantic binary_tree_print.c 6-main.c 6-binary_tree_preorder.c 0-binary_tree_node.c -o 6-pre
alex@/tmp/binary_trees$ ./6-pre
.-------(098)-------.
.--(012)--. .--(402)--.
(006) (056) (256) (512)
98
12
6
56
402
256
512
alex@/tmp/binary_trees$
```
### 7. In-order traversal
**file:**
[7-binary_tree_inorder.c](./7-binary_tree_inorder.c)
**Description:**
Write a function to traverse a binary tree using in-order traversal.
- Prototype: `void binary_tree_inorder(const binary_tree_t *tree, void (*func)(int));`
- Where `tree` is a pointer to the root node of the tree to traverse
- And `func` is a pointer to a function to call for each node. The value in the node must be passed as a parameter to this function.
- If `tree` or `func` is `NULL`, do nothing
```c
alex@/tmp/binary_trees$ cat 7-main.c
#include
#include
#include "binary_trees.h"
/**
* print_num - Prints a number
*
* @n: Number to be printed
*/
void print_num(int n)
{
printf("%d\n", n);
}
/**
* main - Entry point
*
* Return: Always 0 (Success)
*/
int main(void)
{
binary_tree_t *root;
root = binary_tree_node(NULL, 98);
root->left = binary_tree_node(root, 12);
root->right = binary_tree_node(root, 402);
root->left->left = binary_tree_node(root->left, 6);
root->left->right = binary_tree_node(root->left, 56);
root->right->left = binary_tree_node(root->right, 256);
root->right->right = binary_tree_node(root->right, 512);
binary_tree_print(root);
binary_tree_inorder(root, &print_num);
return (0);
}
alex@/tmp/binary_trees$ gcc -Wall -Wextra -Werror -pedantic binary_tree_print.c 7-main.c 7-binary_tree_inorder.c 0-binary_tree_node.c -o 7-in
alex@/tmp/binary_trees$ ./7-in
.-------(098)-------.
.--(012)--. .--(402)--.
(006) (056) (256) (512)
6
12
56
98
256
402
512
alex@/tmp/binary_trees$
```
### 8. Post-order traversal
**file:**
[8-binary_tree_postorder.c](./8-binary_tree_postorder.c)
**Description:**
Create a function to traverse a binary tree using post-order traversal.
Prototype: `void binary_tree_postorder(const binary_tree_t *tree, void (*func)(int));`
- Where `tree` is a pointer to the root node of the tree to traverse
- And `func` is a pointer to a function to call for each node. The value in the node must be passed as a parameter to this function.
- If `tree` or `func` is `NULL`, do nothing
```c
alex@/tmp/binary_trees$ cat 8-main.c
#include
#include
#include "binary_trees.h"
/**
* print_num - Prints a number
*
* @n: Number to be printed
*/
void print_num(int n)
{
printf("%d\n", n);
}
/**
* main - Entry point
*
* Return: Always 0 (Success)
*/
int main(void)
{
binary_tree_t *root;
root = binary_tree_node(NULL, 98);
root->left = binary_tree_node(root, 12);
root->right = binary_tree_node(root, 402);
root->left->left = binary_tree_node(root->left, 6);
root->left->right = binary_tree_node(root->left, 56);
root->right->left = binary_tree_node(root->right, 256);
root->right->right = binary_tree_node(root->right, 512);
binary_tree_print(root);
binary_tree_postorder(root, &print_num);
return (0);
}
alex@/tmp/binary_trees$ gcc -Wall -Wextra -Werror -pedantic binary_tree_print.c 8-main.c 8-binary_tree_postorder.c 0-binary_tree_node.c -o 8-post
alex@/tmp/binary_trees$ ./8-post
.-------(098)-------.
.--(012)--. .--(402)--.
(006) (056) (256) (512)
6
56
12
256
512
402
98
alex@/tmp/binary_trees$
```
### 9. Height
**file:**
[9-binary_tree_height.c](./9-binary_tree_height.c)
**Description:**
Implement a function to measure the height of a binary tree.
- Prototype: `size_t binary_tree_height(const binary_tree_t *tree);`
- Where `tree` is a pointer to the root node of the tree to measure the height.
- If `tree` is `NULL`, your function must return `0`
```c
alex@/tmp/binary_trees$ cat 9-main.c
#include
#include
#include "binary_trees.h"
/**
* main - Entry point
*
* Return: Always 0 (Success)
*/
int main(void)
{
binary_tree_t *root;
size_t height;
root = binary_tree_node(NULL, 98);
root->left = binary_tree_node(root, 12);
root->right = binary_tree_node(root, 402);
binary_tree_insert_right(root->left, 54);
binary_tree_insert_right(root, 128);
binary_tree_print(root);
height = binary_tree_height(root);
printf("Height from %d: %lu\n", root->n, height);
height = binary_tree_height(root->right);
printf("Height from %d: %lu\n", root->right->n, height);
height = binary_tree_height(root->left->right);
printf("Height from %d: %lu\n", root->left->right->n, height);
return (0);
}
alex@/tmp/binary_trees$ gcc -Wall -Wextra -Werror -pedantic binary_tree_print.c 9-binary_tree_height.c 9-main.c 0-binary_tree_node.c 2-binary_tree_insert_right.c -o 9-height
alex@/tmp/binary_trees$ ./9-height
.-------(098)--.
(012)--. (128)--.
(054) (402)
Height from 98: 2
Height from 128: 1
Height from 54: 0
alex@/tmp/binary_trees$
```
### 10. Depth
**file:**
[10-binary_tree_depth.c](./10-binary_tree_depth.c)
**Description:**
Develop a function to measure the depth of a given node in a binary tree.
- Prototype: `size_t binary_tree_depth(const binary_tree_t *tree);`
- Where `tree` is a pointer to the node to measure the depth
- If `tree` is `NULL`, your function must return `0`
```c
alex@/tmp/binary_trees$ cat 10-main.c
#include
#include
#include "binary_trees.h"
/**
* main - Entry point
*
* Return: Always 0 (Success)
*/
int main(void)
{
binary_tree_t *root;
size_t depth;
root = binary_tree_node(NULL, 98);
root->left = binary_tree_node(root, 12);
root->right = binary_tree_node(root, 402);
binary_tree_insert_right(root->left, 54);
binary_tree_insert_right(root, 128);
binary_tree_print(root);
depth = binary_tree_depth(root);
printf("Depth of %d: %lu\n", root->n, depth);
depth = binary_tree_depth(root->right);
printf("Depth of %d: %lu\n", root->right->n, depth);
depth = binary_tree_depth(root->left->right);
printf("Depth of %d: %lu\n", root->left->right->n, depth);
return (0);
}
alex@/tmp/binary_trees$ gcc -Wall -Wextra -Werror -pedantic binary_tree_print.c 10-binary_tree_depth.c 10-main.c 0-binary_tree_node.c 2-binary_tree_insert_right.c -o 10-depth
alex@/tmp/binary_trees$ ./10-depth
.-------(098)--.
(012)--. (128)--.
(054) (402)
Depth of 98: 0
Depth of 128: 1
Depth of 54: 2
alex@/tmp/binary_trees$
```
### 11. Size
**file:**
[11-binary_tree_size.c](./11-binary_tree_size.c)
**Description:**
Write a function to measure the size of a binary tree (the number of nodes).
- Prototype: `size_t binary_tree_size(const binary_tree_t *tree);`
- Where `tree` is a pointer to the root node of the tree to measure the size
- If `tree` is `NULL`, the function must return `0`
```c
alex@/tmp/binary_trees$ cat 11-main.c
#include
#include
#include "binary_trees.h"
/**
* main - Entry point
*
* Return: Always 0 (Success)
*/
int main(void)
{
binary_tree_t *root;
size_t size;
root = binary_tree_node(NULL, 98);
root->left = binary_tree_node(root, 12);
root->right = binary_tree_node(root, 402);
binary_tree_insert_right(root->left, 54);
binary_tree_insert_right(root, 128);
binary_tree_print(root);
size = binary_tree_size(root);
printf("Size of %d: %lu\n", root->n, size);
size = binary_tree_size(root->right);
printf("Size of %d: %lu\n", root->right->n, size);
size = binary_tree_size(root->left->right);
printf("Size of %d: %lu\n", root->left->right->n, size);
return (0);
}
alex@/tmp/binary_trees$ gcc -Wall -Wextra -Werror -pedantic binary_tree_print.c 11-binary_tree_size.c 11-main.c 0-binary_tree_node.c 2-binary_tree_insert_right.c -o 11-size
alex@/tmp/binary_trees$ ./11-size
.-------(098)--.
(012)--. (128)--.
(054) (402)
Size of 98: 5
Size of 128: 2
Size of 54: 1
alex@/tmp/binary_trees$
```
### 12. Leaves
**file:**
[12-binary_tree_leaves.c](./12-binary_tree_leaves.c)
**Description:**
Create a function to count the leaves in a binary tree.
- Prototype: `size_t binary_tree_leaves(const binary_tree_t *tree);`
- Where `tree` is a pointer to the root node of the tree to count the number of leaves
If `tree` is `NULL`, the function must return 0
- A `NULL` pointer is not a leaf
```c
alex@/tmp/binary_trees$ cat 12-main.c
#include
#include
#include "binary_trees.h"
/**
* main - Entry point
*
* Return: Always 0 (Success)
*/
int main(void)
{
binary_tree_t *root;
size_t leaves;
root = binary_tree_node(NULL, 98);
root->left = binary_tree_node(root, 12);
root->right = binary_tree_node(root, 402);
binary_tree_insert_right(root->left, 54);
binary_tree_insert_right(root, 128);
binary_tree_print(root);
leaves = binary_tree_leaves(root);
printf("Leaves in %d: %lu\n", root->n, leaves);
leaves = binary_tree_leaves(root->right);
printf("Leaves in %d: %lu\n", root->right->n, leaves);
leaves = binary_tree_leaves(root->left->right);
printf("Leaves in %d: %lu\n", root->left->right->n, leaves);
return (0);
}
alex@/tmp/binary_trees$ gcc -Wall -Wextra -Werror -pedantic binary_tree_print.c 12-binary_tree_leaves.c 12-main.c 0-binary_tree_node.c 2-binary_tree_insert_right.c -o 12-leaves
alex@/tmp/binary_trees$ ./12-leaves
.-------(098)--.
(012)--. (128)--.
(054) (402)
Leaves in 98: 2
Leaves in 128: 1
Leaves in 54: 1
alex@/tmp/binary_trees$
```
### 13. Nodes
**file:**
[13-binary_tree_nodes.c](./13-binary_tree_nodes.c)
**Description:**
Implement a function to count the nodes with at least one child in a binary tree.
- Prototype: `size_t binary_tree_nodes(const binary_tree_t *tree);`
- Where `tree` is a pointer to the root node of the tree to count the number of nodes
- If `tree` is `NULL`, the function must return 0
- A `NULL` pointer is not a node
```c
alex@/tmp/binary_trees$ cat 13-main.c
#include
#include
#include "binary_trees.h"
/**
* main - Entry point
*
* Return: Always 0 (Success)
*/
int main(void)
{
binary_tree_t *root;
size_t nodes;
root = binary_tree_node(NULL, 98);
root->left = binary_tree_node(root, 12);
root->right = binary_tree_node(root, 402);
binary_tree_insert_right(root->left, 54);
binary_tree_insert_right(root, 128);
binary_tree_print(root);
nodes = binary_tree_nodes(root);
printf("Nodes in %d: %lu\n", root->n, nodes);
nodes = binary_tree_nodes(root->right);
printf("Nodes in %d: %lu\n", root->right->n, nodes);
nodes = binary_tree_nodes(root->left->right);
printf("Nodes in %d: %lu\n", root->left->right->n, nodes);
return (0);
}
alex@/tmp/binary_trees$ gcc -Wall -Wextra -Werror -pedantic binary_tree_print.c 13-binary_tree_nodes.c 13-main.c 0-binary_tree_node.c 2-binary_tree_insert_right.c -o 13-nodes
alex@/tmp/binary_trees$ ./13-nodes
.-------(098)--.
(012)--. (128)--.
(054) (402)
Nodes in 98: 3
Nodes in 128: 1
Nodes in 54: 0
alex@/tmp/binary_trees$
```
### 14. Balance factor
**file:**
[14-binary_tree_balance.c](./14-binary_tree_balance.c)
**Description:**
Develop a function to measure the balance factor of a binary tree.
- Prototype: `int binary_tree_balance(const binary_tree_t *tree);`
- Where `tree` is a pointer to the root node of the tree to measure the balance factor
- If `tree` is `NULL`, return `0`
```c
alex@/tmp/binary_trees$ cat 14-main.c
#include
#include
#include "binary_trees.h"
/**
* main - Entry point
*
* Return: Always 0 (Success)
*/
int main(void)
{
binary_tree_t *root;
int balance;
root = binary_tree_node(NULL, 98);
root->left = binary_tree_node(root, 12);
root->right = binary_tree_node(root, 402);
binary_tree_insert_right(root->left, 54);
binary_tree_insert_right(root, 128);
binary_tree_insert_left(root, 45);
binary_tree_insert_right(root->left, 50);
binary_tree_insert_left(root->left->left, 10);
binary_tree_insert_left(root->left->left->left, 8);
binary_tree_print(root);
balance = binary_tree_balance(root);
printf("Balance of %d: %+d\n", root->n, balance);
balance = binary_tree_balance(root->right);
printf("Balance of %d: %+d\n", root->right->n, balance);
balance = binary_tree_balance(root->left->left->right);
printf("Balance of %d: %+d\n", root->left->left->right->n, balance);
return (0);
}
alex@/tmp/binary_trees$ gcc -Wall -Wextra -Werror -pedantic binary_tree_print.c 14-binary_tree_balance.c 14-main.c 0-binary_tree_node.c 2-binary_tree_insert_right.c 1-binary_tree_insert_left.c -o 14-balance
alex@/tmp/binary_trees$ ./14-balance
.-------(098)--.
.-------(045)--. (128)--.
.--(012)--. (050) (402)
.--(010) (054)
(008)
Balance of 98: +2
Balance of 128: -1
Balance of 54: +0
alex@/tmp/binary_trees$
```
### 15. Is full
**file:**
[15-binary_tree_is_full.c](./15-binary_tree_is_full.c)
**Description:**
Write a function to check if a binary tree is full (every node has 0 or 2 children).
- Prototype: `int binary_tree_is_full(const binary_tree_t *tree);`
- Where `tree` is a pointer to the root node of the tree to check
- If `tree` is `NULL`, your function must return `0`
```c
alex@/tmp/binary_trees$ cat 15-main.c
#include
#include
#include "binary_trees.h"
/**
* main - Entry point
*
* Return: Always 0 (Success)
*/
int main(void)
{
binary_tree_t *root;
int full;
root = binary_tree_node(NULL, 98);
root->left = binary_tree_node(root, 12);
root->right = binary_tree_node(root, 402);
binary_tree_insert_right(root->left, 54);
binary_tree_insert_right(root, 128);
root->left->left = binary_tree_node(root->left, 10);
binary_tree_print(root);
full = binary_tree_is_full(root);
printf("Is %d full: %d\n", root->n, full);
full = binary_tree_is_full(root->left);
printf("Is %d full: %d\n", root->left->n, full);
full = binary_tree_is_full(root->right);
printf("Is %d full: %d\n", root->right->n, full);
return (0);
}
alex@/tmp/binary_trees$ gcc -Wall -Wextra -Werror -pedantic binary_tree_print.c 15-binary_tree_is_full.c 15-main.c 0-binary_tree_node.c 2-binary_tree_insert_right.c -o 15-full
alex@/tmp/binary_trees$ ./15-full
.-------(098)--.
.--(012)--. (128)--.
(010) (054) (402)
Is 98 full: 0
Is 12 full: 1
Is 128 full: 0
alex@/tmp/binary_trees$
```
### 16. Is perfect
**file:**
[16-binary_tree_is_perfect.c](./16-binary_tree_is_perfect.c)
**Description:**
Create a function to check if a binary tree is perfect (all levels are fully filled).
- Prototype: `int binary_tree_is_perfect(const binary_tree_t *tree);`
- Where `tree` is a pointer to the root node of the tree to check
- If `tree` is `NULL`, your function must return `0`
```c
alex@/tmp/binary_trees$ cat 16-main.c
#include
#include
#include "binary_trees.h"
/**
* main - Entry point
*
* Return: Always 0 (Success)
*/
int main(void)
{
binary_tree_t *root;
int perfect;
root = binary_tree_node(NULL, 98);
root->left = binary_tree_node(root, 12);
root->right = binary_tree_node(root, 402);
binary_tree_insert_right(root->left, 54);
binary_tree_insert_right(root, 128);
root->left->left = binary_tree_node(root->left, 10);
root->right->left = binary_tree_node(root->right, 10);
binary_tree_print(root);
perfect = binary_tree_is_perfect(root);
printf("Perfect: %d\n\n", perfect);
root->right->right->left = binary_tree_node(root->right->right, 10);
binary_tree_print(root);
perfect = binary_tree_is_perfect(root);
printf("Perfect: %d\n\n", perfect);
root->right->right->right = binary_tree_node(root->right->right, 10);
binary_tree_print(root);
perfect = binary_tree_is_perfect(root);
printf("Perfect: %d\n", perfect);
return (0);
}
alex@/tmp/binary_trees$ gcc -Wall -Wextra -Werror -pedantic binary_tree_print.c 16-binary_tree_is_perfect.c 16-main.c 0-binary_tree_node.c 2-binary_tree_insert_right.c -o 16-perfect
alex@/tmp/binary_trees$ ./16-perfect
.-------(098)-------.
.--(012)--. .--(128)--.
(010) (054) (010) (402)
Perfect: 1
.-------(098)-------.
.--(012)--. .--(128)-------.
(010) (054) (010) .--(402)
(010)
Perfect: 0
.-------(098)-------.
.--(012)--. .--(128)-------.
(010) (054) (010) .--(402)--.
(010) (010)
Perfect: 0
alex@/tmp/binary_trees$
```
### 17. Sibling
**file:**
[17-binary_tree_sibling.c](./17-binary_tree_sibling.c)
**Description:**
Create a function to find the sibling of a node
- Prototype: `binary_tree_t *binary_tree_sibling(binary_tree_t *node);`
- Where `node` is a pointer to the node to find the sibling
- Your function must return a pointer to the sibling node
- If `node` is `NULL` or the parent is `NULL`, return `NULL`
- If `node` has no sibling, return `NULL`
```c
alex@/tmp/binary_trees$ cat 17-main.c
#include
#include
#include "binary_trees.h"
/**
* main - Entry point
*
* Return: Always 0 (Success)
*/
int main(void)
{
binary_tree_t *root;
binary_tree_t *sibling;
root = binary_tree_node(NULL, 98);
root->left = binary_tree_node(root, 12);
root->right = binary_tree_node(root, 128);
root->left->right = binary_tree_node(root->left, 54);
root->right->right = binary_tree_node(root->right, 402);
root->left->left = binary_tree_node(root->left, 10);
root->right->left = binary_tree_node(root->right, 110);
root->right->right->left = binary_tree_node(root->right->right, 200);
root->right->right->right = binary_tree_node(root->right->right, 512);
binary_tree_print(root);
sibling = binary_tree_sibling(root->left);
printf("Sibling of %d: %d\n", root->left->n, sibling->n);
sibling = binary_tree_sibling(root->right->left);
printf("Sibling of %d: %d\n", root->right->left->n, sibling->n);
sibling = binary_tree_sibling(root->left->right);
printf("Sibling of %d: %d\n", root->left->right->n, sibling->n);
sibling = binary_tree_sibling(root);
printf("Sibling of %d: %p\n", root->n, (void *)sibling);
return (0);
}
alex@/tmp/binary_trees$ gcc -Wall -Wextra -Werror -pedantic binary_tree_print.c 17-main.c 17-binary_tree_sibling.c 0-binary_tree_node.c -o 17-sibling
alex@/tmp/binary_trees$ ./17-sibling
.-------(098)-------.
.--(012)--. .--(128)-------.
(010) (054) (110) .--(402)--.
(200) (512)
Sibling of 12: 128
Sibling of 110: 402
Sibling of 54: 10
Sibling of 98: (nil)
alex@/tmp/binary_trees$
```
### 18. Uncle
**file:**
[18-binary_tree_uncle.c](./18-binary_tree_uncle.c)
**Description:**
Create a function to find the uncle of a node
- Prototype: `binary_tree_t *binary_tree_uncle(binary_tree_t *node);`
- Where `node` is a pointer to the node to find the uncle
- Your function must return a pointer to the uncle node
- If `node` is `NULL`, return `NULL`
- If `node` has no uncle, return `NULL`
```c
alex@/tmp/binary_trees$ cat 18-main.c
#include
#include
#include "binary_trees.h"
/**
* main - Entry point
*
* Return: Always 0 (Success)
*/
int main(void)
{
binary_tree_t *root;
binary_tree_t *uncle;
root = binary_tree_node(NULL, 98);
root->left = binary_tree_node(root, 12);
root->right = binary_tree_node(root, 128);
root->left->right = binary_tree_node(root->left, 54);
root->right->right = binary_tree_node(root->right, 402);
root->left->left = binary_tree_node(root->left, 10);
root->right->left = binary_tree_node(root->right, 110);
root->right->right->left = binary_tree_node(root->right->right, 200);
root->right->right->right = binary_tree_node(root->right->right, 512);
binary_tree_print(root);
uncle = binary_tree_uncle(root->right->left);
printf("Uncle of %d: %d\n", root->right->left->n, uncle->n);
uncle = binary_tree_uncle(root->left->right);
printf("Uncle of %d: %d\n", root->left->right->n, uncle->n);
uncle = binary_tree_uncle(root->left);
printf("Uncle of %d: %p\n", root->left->n, (void *)uncle);
return (0);
}
alex@/tmp/binary_trees$ gcc -Wall -Wextra -Werror -pedantic binary_tree_print.c 18-main.c 18-binary_tree_uncle.c 0-binary_tree_node.c -o 18-uncle
alex@/tmp/binary_trees$ ./18-uncle
.-------(098)-------.
.--(012)--. .--(128)-------.
(010) (054) (110) .--(402)--.
(200) (512)
Uncle of 110: 12
Uncle of 54: 128
Uncle of 12: (nil)
alex@/tmp/binary_trees$
```
## Authors
- [Abdelrahman Mohamed](https://github.com/hackerSa3edy)
- [Zakaria Aaichaou](https://github.com/Z-Sitawi)