# What is Skewed Binary Tree

To understand the skewed binary tree, we must first understand the concept of a binary tree. A binary is generally the one in which every single node has two further nodes which we also call the child of the nodes because they are enrooting from them. They are also termed as the left child or the right child depending upon the direction of the node. They are most probably implemented with the help of pointers. Now coming to the skewed binary tree, what it is? What use does it portray? We will answer all of these questions in detail in this article.

The skewed binary tree is a typical binary tree with the exception that each and every node of this tree either contains a single child or no child at all. It basically is a subset of the binary tree where there is less requirement of the node implying, we can create the tree with one node or no node at all. Sometimes in this, only one node consists of one and only one child and the rest of the nodes don’t contain any child. These properties should be satisfied when we are figuring or constructing a skewed binary tree.

### HOW TO IMPLEMENT IT?

In this section, we will see a basic algorithm where we will be applying the skewed binary tree:-

```
struct Node{
int num;
struct node *left, *right;
}
Node* newNode(int num) {
Node* J = new node;
J - > num = num;
J - > left = J - > right = NULL;
return(J);
}
```

## TYPES OF SKEWED BINARY TREE

On the basis of the direction of the nodes, the skewed binary tree can be divided into two categories:-

**LEFT SKEWED BINARY TREE**

If all the child nodes coming from the parent nodes are headed or pointed in a left direction then they are called the left-skewed binary tree. It then turns out to be the left-sided influenced tree in which the right ones remain null.

Let us understand the implementation and working of the same in a more precise manner.

```
#include < bits/stdc++.h >
Using namespace std;
// In this, we are creating a tree
Struct Node {
int store;
struct Node *left, *right;
} ;
Node* newNode (int store)
{
Node* temp = new Node;
Temp - > store = store;
Temp - > left = temp - > right = NULL;
Return (temp);
}
int main ( )
{
/ *
4
/
8
/
3
*/
Node* root = newNode(4);
Root - > left = newNode(8);
Root - > left - > left = newNode(3);
return 0;
}
```

**Output:**

**RIGHT SKEWED BINARY TREE**

If all the child nodes coming from the parent nodes are headed or pointed in the right direction then they are called the right-skewed binary tree. It then turns out to be the right-sided influenced tree in which the left ones remain null.

Let us understand the implementation and working of right skewed binary tree in a more precise manner

```
#include < bits/stdc++.h >
Using namespace std;
// In this, we are creating a tree
Struct Node {
int store;
struct Node *left, *right;
} ;
Node* newNode (int store)
{
Node* temp = new Node;
Temp - > store = store;
Temp - > left = temp - > right = NULL;
Return (temp);
}
int main ( )
{
/ *
4
\
8
\
3
*/
Node* root = newNode(4);
Root - > right = newNode(8);
Root - > right - > right = newNode(3);
return 0;
}
```

**Output:**

### ADVANTAGES OF SKEWED BINARY TREE

- They are known for their systematic nature.
- If we maintain and keep a balance between the various functions, deletion and insertion operations provide rather quick results as compared to others.
- They are very basic or simple and easy to maintain as compared to the rest of the trees in data structures.

### DISADVANTAGES OF SKEWED BINARY TREE

- In complex cases, it takes a very large amount of time in searching and therefore provides the result.
- It easily gets degenerated which is why it can increase the complexity and work of the algorithm.
- Approaching the element becomes difficult in this type as compared to arrays.