Data Structures Tutorial

Data Structures Tutorial Asymptotic Notation Structure and Union Array Data Structure Linked list Data Structure Type of Linked list Advantages and Disadvantages of linked list Queue Data Structure Implementation of Queue Stack Data Structure Implementation of Stack Sorting Insertion sort Quick sort Selection sort Heap sort Merge sort Bucket sort Count sort Radix sort Shell sort Tree Traversal of the binary tree Binary search tree Graph Spanning tree Linear Search Binary Search Hashing Collision Resolution Techniques

Misc Topic:

Priority Queue in Data Structure Deque in Data Structure Difference Between Linear And Non Linear Data Structures Queue Operations In Data Structure About Data Structures Data Structures Algorithms Types of Data Structures Big O Notations Introduction to Arrays Introduction to 1D-Arrays Operations on 1D-Arrays Introduction to 2D-Arrays Operations on 2D-Arrays Strings in Data Structures String Operations Application of 2D array Bubble Sort Insertion Sort Sorting Algorithms What is DFS Algorithm What Is Graph Data Structure What is the difference between Tree and Graph What is the difference between DFS and BFS Bucket Sort Dijkstra’s vs Bellman-Ford Algorithm Linear Queue Data Structure in C Stack Using Array Stack Using Linked List Recursion in Fibonacci Stack vs Array What is Skewed Binary Tree Primitive Data Structure in C Dynamic memory allocation of structure in C Application of Stack in Data Structures Binary Tree in Data Structures Heap Data Structure Recursion - Factorial and Fibonacci What is B tree what is B+ tree Huffman tree in Data Structures Insertion Sort vs Bubble Sort Adding one to the number represented an array of digits Bitwise Operators and their Important Tricks Blowfish algorithm Bubble Sort vs Selection Sort Hashing and its Applications Heap Sort vs Merge Sort Insertion Sort vs Selection Sort Merge Conflicts and ways to handle them Difference between Stack and Queue AVL tree in data structure c++ Bubble sort algorithm using Javascript Buffer overflow attack with examples Find out the area between two concentric circles Lowest common ancestor in a binary search tree Number of visible boxes putting one inside another Program to calculate the area of the circumcircle of an equilateral triangle Red-black Tree in Data Structures Strictly binary tree in Data Structures 2-3 Trees and Basic Operations on them Asynchronous advantage actor-critic (A3C) Algorithm Bubble Sort vs Heap Sort Digital Search Tree in Data Structures Minimum Spanning Tree Permutation Sort or Bogo Sort Quick Sort vs Merge Sort

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:

WHAT IS A SKEWED BINARY TREE?
  • 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:

WHAT IS A SKEWED BINARY TREE?

ADVANTAGES OF SKEWED BINARY TREE

  1. They are known for their systematic nature.
  2. If we maintain and keep a balance between the various functions, deletion and insertion operations provide rather quick results as compared to others.
  3. 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

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



ADVERTISEMENT
ADVERTISEMENT