Madisyn  Lakin

Madisyn Lakin


What Is Balancing A Binary Tree & Why Do We Need Balancing ?

A Binary Tree is called BALANCED binary tree (or binary search tree) IF the difference between the HEIGHT of the Left Sub Tree & Right Sub Tree for every node is not more than k (usually k = 1)
Height of a binary tree is the number of edges/links on the longest path between the root node & leaf node.

In this tutorial we will answer 2 main questions - 
1) What does Balancing a Binary Tree mean ?
2) Why is Balancing a binary Tree Important ? 

#datastructure  #binarytree  #binarysearchtree 

What is GEEK

Buddha Community

What Is Balancing A Binary Tree & Why Do We Need Balancing ?
Lets Cms

Lets Cms


Binary MLM Software Demo | Binary Compensation Plan, MLM Woocommerce

Binary MLM Software Demo | Binary MLM Compensation Plan, MLM Woocommerce Price USA, Philippines : Binary MLM Woocommerce Software is a web application that integrate with the Woo-commerce plugin and helps to manage binary MLM networks. LETSCMS provide worldwide service, such as USA, Hong Kong, China, UK, UAE, Jordan, Saudi Arabia, Pakistan, Philippines, Japan, Singapore, Romania, Vietnam, Canada, Hong Kong, Russia, Hungary, Romania, Poland, Thailand, Laos and many others.

Binary MLM Woo-commerce includes a two legged structure where in a parent Node has two sub nodes where each new distributor or members is placed in either left or right sub-tree. One sub-tree is known as a Power Leg or Profit Leg while the second sub-tree is a Profit Leg or a weak leg.. It  is one of the basic Binary MLM plan which is required by all the MLM organizations be it small or large. The binary MLM plan helps admin managing users or sub nodes in a binary network to keep record of their income, expenses etc.

Admin Demo :

Front Demo :

Admin Features
Payout Reports.
Report to show complete details of an individual payouts.
Affiliate Commission.
Pair Commission .
Bonus Commission.
Specify eligibility criteria in the admin.
Configuration of commission and bonus details in the admin.
Service Charges for payout.
Run payouts manually.
Payout Detail based on user in admin .

Frontend Features
Register a Binary MLM User from provided registration page.
Register new Members using Genealogy.
New Join Network Page for non-Network Members .
MLM registration can happen by the Checkout page also.
Members can view full payout details in their account.

If you want to know more information and any queries regarding Binary MLM Woo-commerce, you can contact our experts through 
Skype: jks0586, 
Call/WhatsApp/WeChat: +91-9717478599.

more information :

Vedio :


#mlm_plan #Binary_mlm #binary_mlm_plan #Binary_mlm_wordpress_plugin #Binary_mlm_woo-commerce #binary_mlm_ecommerce #binary_mlm_software #binary_mlm_wp_plugin #biary_mlm_ecommerce #mlm_plan

Check if all the Nodes in a Binary Tree having common values are at least D distance apart

Given a Binary Tree and an integer D, the task is to check if the distance between all pairs of same node values in the Tree is ? D or not. If found to be true, then print Yes. Otherwise, print No.


Input:_ D = 7 _

              /   \ 
             2     3
            / \   /  \ 
           4   3  4   4

Output:_ Yes _


_The repeated value of nodes are 3 and 4. _

_The distance between the two nodes valued 3, is 3. _

_The maximum distance between any pair of nodes valued 4 is 4. _

Therefore, none of the distances exceed 7

Input:_ D = 1 _

         / \
        3   3

Output:_ No _

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

**Approach: **

The idea is to observe that the problem is similar to finding the distance between two nodes of a tree. But there can be multiple pairs of nodes for which we have to find the distance. Follow the steps below:

  1. Perform the Post Order Traversal of the given tree and find the distance between the repeated pairs of nodes.
  2. Find the nodes that are repeated in the tree using unordered_map.
  3. For each repeated node of a particular value, find the maximum possible distance between any pair.
  4. If that distance is > D, print “No”.
  5. If no such node value is found having a pair containing that value, exceeding **D, **then print “Yes”.

#greedy #recursion #searching #tree #binary tree #frequency-counting #postorder traversal #tree-traversal

Brain  Crist

Brain Crist


Count of Array elements greater than all elements on its left

Given an array A[ ] consisting of N distinct integers, the task is to find the number of elements which are **strictly greater **than all the elements preceding it and strictly greater than at least K elements on its right.


Input:_ A[] = {2, 5, 1, 7, 3, 4, 0}, K = 3_

Output:_ 2_


The only array elements satisfying the given conditions are:

  • 5: Greater than all elements on its left {2} and at least K(= 3) elements on its right {1, 3, 4, 0}
  • 7: Greater than all elements on its left {2, 5, 1} and at least K(= 3) elements on its right {3, 4, 0}

Therefore, the count is 2.

Input:_ A[] = {11, 2, 4, 7, 5, 9, 6, 3}, K = 2_

Output:_ 1_

Naive Approach:

The simplest approach to solve the problem is to traverse the array and for each element, traverse all the elements on its left and check if all of them are smaller than it or not and traverse all elements on its right to check if at least K elements are smaller than it or not. For every element satisfying the conditions, increase count. Finally, print the value of count.

Time Complexity:_ O(N2)_

Auxiliary Space:_ O(1)_

Efficient Approach:

The above approach can be further optimized by using Self-Balancing BST. Follow the steps below:

  • Traverse the array from right to left and insert all elements one by one in an AVL Tree
  • Using the AVL Tree generate an array countSmaller[] which contains the count of smaller elements on the right of every array element.
  • Traverse the array and for every ith element, check if it is the maximum obtained so far and countSmaller[i] is greater than or equal to K.
  • If so, increase count.
  • Print the final value of count as the answer.

Below is the implementation of the above approach:

  • C++

// C++ Program to implement

// the above appraoch

#include <bits/stdc++.h>

**using** **namespace** std;

// Structure of an AVL Tree Node

**struct** node {

**int** key;

**struct** node* left;

**struct** node* right;

**int** height;

// Size of the tree rooted

// with this node

**int** size;


// Utility function to get maximum

// of two integers

**int** max(``**int** a, **int** b);

// Utility function to get height

// of the tree rooted with N

**int** height(``**struct** node* N)


**if** (N == NULL)

**return** 0;

**return** N->height;


// Utility function to find size of

// the tree rooted with N

**int** size(``**struct** node* N)


**if** (N == NULL)

**return** 0;

**return** N->size;


// Utility function to get maximum

// of two integers

**int** max(``**int** a, **int** b)


**return** (a > b) ? a : b;


// Helper function to allocates a

// new node with the given key

**struct** node* newNode(``**int** key)


**struct** node* node

= (``**struct** node*)

**malloc**``(``**sizeof**``(``**struct** node));

node->key = key;

node->left = NULL;

node->right = NULL;

node->height = 1;

node->size = 1;

**return** (node);


// Utility function to right rotate

// subtree rooted with y

**struct** node* rightRotate(``**struct** node* y)


**struct** node* x = y->left;

**struct** node* T2 = x->right;

// Perform rotation

x->right = y;

y->left = T2;

// Update heights

y->height = max(height(y->left),


+ 1;

x->height = max(height(x->left),


+ 1;

// Update sizes

y->size = size(y->left)

+ size(y->right) + 1;

x->size = size(x->left)

+ size(x->right) + 1;

// Return new root

**return** x;


// Utility function to left rotate

// subtree rooted with x

**struct** node* leftRotate(``**struct** node* x)


**struct** node* y = x->right;

**struct** node* T2 = y->left;

// Perform rotation

y->left = x;

x->right = T2;

// Update heights

x->height = max(height(x->left),


+ 1;

y->height = max(height(y->left),


+ 1;

// Update sizes

x->size = size(x->left)

+ size(x->right) + 1;

y->size = size(y->left)

+ size(y->right) + 1;

// Return new root

**return** y;


// Function to obtain Balance factor

// of node N

**int** getBalance(``**struct** node* N)


**if** (N == NULL)

**return** 0;

**return** height(N->left)

- height(N->right);


// Function to insert a new key to the

// tree rooted with node

**struct** node* insert(``**struct** node* node, **int** key,

**int**``* count)


// Perform the normal BST rotation

**if** (node == NULL)

**return** (newNode(key));

**if** (key < node->key)


= insert(node->left, key, count);

**else** {


= insert(node->right, key, count);

// Update count of smaller elements

*count = *count + size(node->left) + 1;


// Update height and size of the ancestor

node->height = max(height(node->left),


+ 1;

node->size = size(node->left)

+ size(node->right) + 1;

// Get the balance factor of the ancestor

**int** balance = getBalance(node);

// Left Left Case

**if** (balance > 1 && key < node->left->key)

**return** rightRotate(node);

// Right Right Case

**if** (balance < -1 && key > node->right->key)

**return** leftRotate(node);

// Left Right Case

**if** (balance > 1 && key > node->left->key) {

node->left = leftRotate(node->left);

**return** rightRotate(node);


// Right Left Case

**if** (balance < -1 && key < node->right->key) {

node->right = rightRotate(node->right);

**return** leftRotate(node);


**return** node;


// Function to generate an array which contains

// count of smaller elements on the right

**void** constructLowerArray(``**int** arr[],

**int** countSmaller[],

**int** n)


**int** i, j;

**struct** node* root = NULL;

**for** (i = 0; i < n; i++)

countSmaller[i] = 0;

// Insert all elements in the AVL Tree

// and get the count of smaller elements

**for** (i = n - 1; i >= 0; i--) {

root = insert(root, arr[i],




// Function to find the number

// of elements which are greater

// than all elements on its left

// and K elements on its right

**int** countElements(``**int** A[], **int** n, **int** K)


**int** count = 0;

// Stores the count of smaller

// elements on its right

**int**``* countSmaller

= (``**int**``*)``**malloc**``(``**sizeof**``(``**int**``) * n);

constructLowerArray(A, countSmaller, n);

**int** maxi = INT_MIN;

**for** (``**int** i = 0; i <= (n - K - 1); i++) {

**if** (A[i] > maxi && countSmaller[i] >= K) {


maxi = A[i];



**return** count;


// Driver Code

**int** main()


**int** A[] = { 2, 5, 1, 7, 3, 4, 0 };

**int** n = **sizeof**``(A) / **sizeof**``(``**int**``);

**int** K = 3;

cout << countElements(A, n, K);

**return** 0;




_Time Complexity: _O(NlogN)

_Auxiliary Space: _O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

#advanced data structure #arrays #binary search tree #mathematical #searching #avl-tree #balanced binary search trees #rotation

Balanced Tree - AVL Tree in Java » grokonez

Balanced Tree – AVL Tree in Java

In this tutorial, we’re gonna look at AVL Tree Data Structure. It is a balanced binary search tree - the heights of given node’s children trees don’t differ more than 1 (with height of node = max of its children node + 1).


AVL Rotations

Four types of unbalanced situations: - Left-Left: doubly left heavy situation => make a right rotation. - Right-Right: doubly right heavy situation => make a left rotation. - Left-Right: => make a left and a right rotation. - Right-Left: => make a right and left rotation.

Right Rotation


Node rightRotation(Node node) { // input C
	Node newParentNode = node.getLeftNode(); // newParentNode = B
	Node mid = newParentNode.getRightNode(); // store B's right node 'mid' (B < mid < C)
newParentNode.setRightNode(node); // C now becomes right node of B
node.setLeftNode(mid); // 'mid' now becomes left node of C

node.setHeight(Math.max(height(node.getLeftNode()), height(node.getRightNode())) + 1);
newParentNode.setHeight(Math.max(height(newParentNode.getLeftNode()), height(newParentNode.getRightNode())) + 1);

return newParentNode; // return B as the parent of A and C


To simplify the sample, we assume that C has no right node. In general, right node of C will not be changed.

Left Rotation


More at:

Balanced Tree – AVL Tree in Java

#balanced tree #java #avl tree

Double Order Traversal of a Binary Tree

Given a Binary Tree consisting of** N** nodes, the task is to print its Double Order Traversal.

Double Order Traversal_ is a tree traversal technique in which every node is traversed twice in the following order: _

  • Visit the Node.
  • Traverse the Left Subtree.
  • Visit the Node.
  • Traverse the Right Subtree.


      /   \
     7     3
    / \   /
   4   5 6
Output: 1 7 4 4 7 5 5 1 3 6 6 3 

      /   \
     7     3
    / \     \
   4   5     6
Output: 1 7 4 4 7 5 5 1 3 3 6 6

Recommended: Please try your approach on {IDE} first, before moving on to the solution.


The idea is to perform Inorder Traversal recursively on the given Binary Tree and print the node value on **visiting a vertex **and after the recursive call to the left subtree during the traversal.

Follow the steps below to solve the problem:

#data structures #recursion #tree #binary tree #inorder traversal #data analysis