Index

## Binary Tree

Binary trees are a type of tree data structure in which each node has at most two children, referred to as the left child and the right child. Here are some key points about binary trees:

**Root Node**: The topmost node in a binary tree is called the root node. It serves as the starting point for accessing the tree’s data.**Parent and Child Nodes**: Each node in a binary tree can have at most two children: a left child and a right child. Nodes with children are referred to as parent nodes.**Leaf Nodes**: Nodes that do not have any children are called leaf nodes. They are the nodes at the bottom of the tree.**Binary Tree Properties**:- At each level of the tree, the number of nodes can double. For example, the root level has one node, the next level can have two nodes, and so on.
- In a binary tree, the maximum number of nodes at a given level is 2h.
- The maximum number of nodes in a binary tree of height ℎ
*h*is 2ℎ+1−12*h*+1−1.

**Types of Binary Trees**:**Full Binary Tree**: A binary tree in which every node other than the leaves has two children.**Complete Binary Tree**: A binary tree in which every level, except possibly the last, is completely filled, and all nodes are as left as possible.**Perfect Binary Tree**: A binary tree in which all interior nodes have two children and all leaves have the same depth or level.**Balanced Binary Tree**: A binary tree in which the height of the left and right subtrees of any node differ by at most one.

**Applications**: Binary trees are widely used in various applications such as binary search trees (BSTs), expression trees, Huffman coding trees, and more.

Binary trees offer several advantages in terms of understanding, implementation, and efficiency of algorithms due to their structured nature:

**Traversing, Searching, Insertion, and Deletion**: Binary trees provide a clear hierarchical structure, which simplifies the understanding and implementation of algorithms for traversing, searching, insertion, and deletion operations. These operations can be efficiently performed by following the tree’s structure and rules.**Binary Search Trees (BST)**: Binary search trees maintain data in a sorted order, making searching operations highly efficient. With each node’s left child containing a value smaller than the node and the right child containing a value greater than the node, binary search allows for quick searching by narrowing down the search space in a logarithmic manner.**Balancing**: Balancing trees, such as AVL Binary Trees, becomes easier with binary trees due to their limited number of child nodes. AVL trees are self-balancing binary search trees where the heights of the left and right subtrees of any node differ by at most one. This balance ensures efficient searching, insertion, and deletion operations.**Memory Efficiency**: Binary trees can be represented as arrays, which enhances memory efficiency. By using arrays to represent binary trees, memory allocation and access become more streamlined and optimized. This representation allows for efficient storage and retrieval of tree elements, contributing to overall memory management.

### Binary tree Implentation

```
#include <stdio.h>
#include <stdlib.h>
// Define the structure for a binary tree node
struct TreeNode {
int data;
struct TreeNode* left;
struct TreeNode* right;
};
// Function to create a new binary tree node
struct TreeNode* createNode(int data) {
struct TreeNode* newNode = (struct TreeNode*)malloc(sizeof(struct TreeNode));
if (newNode == NULL) {
printf("Memory allocation failed!\n");
exit(1);
}
newNode->data = data;
newNode->left = NULL;
newNode->right = NULL;
return newNode;
}
// Main function
int main() {
// Create the root node and some sample nodes
struct TreeNode* root = createNode(1);
root->left = createNode(2);
root->right = createNode(3);
root->left->left = createNode(4);
root->left->right = createNode(5);
// Print out the values of the nodes
printf("Value of root node: %d\n", root->data);
printf("Value of left child of root: %d\n", root->left->data);
printf("Value of right child of root: %d\n", root->right->data);
printf("Value of left child of left child of root: %d\n", root->left->left->data);
printf("Value of right child of left child of root: %d\n", root->left->right->data);
// Clean up memory
free(root->left->left);
free(root->left->right);
free(root->left);
free(root->right);
free(root);
return 0;
}
```

Output:

```
Value of root node: 1
Value of left child of root: 2
Value of right child of root: 3
Value of left child of left child of root: 4
Value of right child of left child of root: 5
```