Optimal sequence for AVL tree insertion (without any rotations) - GeeksforGeeks

26 Oct, 2021
Given an array of integers, the task is to find the sequence in which these integers should be added to an AVL tree such that no rotations are required to balance the tree.Examples :  
Input : array = {1, 2, 3}
Output : 2 1 3

Input : array = {2, 4, 1, 3, 5, 6, 7}
Output : 4 2 6 1 3 5 7
 
Approach :  
Sort the given array of integers.
Create the AVL tree from the sorted array by following the approach described here.
Now, find the level order traversal of the tree which is the required sequence.
Adding numbers in the sequence found in the previous step will always maintain the height balance property of all the nodes in the tree.
Below is the implementation of the above approach :  
C++
Java
Python3
C#
Javascript
// C++ implementation of the approach#include <bits/stdc++.h>using namespace std; /* A Binary Tree node */struct TNode {    int data;    struct TNode* left;    struct TNode* right;}; struct TNode* newNode(int data); /* Function to construct AVL tree   from a sorted array */struct TNode* sortedArrayToBST(vector<int> arr, int start, int end){    /* Base Case */    if (start > end)        return NULL;     /* Get the middle element       and make it root */    int mid = (start + end) / 2;    struct TNode* root = newNode(arr[mid]);     /* Recursively construct the       left subtree and make it       left child of root */    root->left = sortedArrayToBST(arr, start, mid - 1);     /* Recursively construct the       right subtree and make it       right child of root */    root->right = sortedArrayToBST(arr, mid + 1, end);     return root;} /* Helper function that allocates   a new node with the given data   and NULL to the left and   the right pointers. */struct TNode* newNode(int data){    struct TNode* node = new TNode();    node->data = data;    node->left = NULL;    node->right = NULL;     return node;} // This function is used for testing purposevoid printLevelOrder(TNode *root){    if (root == NULL)  return;     queue<TNode *> q;    q.push(root);       while (q.empty() == false)    {        TNode *node = q.front();        cout << node->data << " ";        q.pop();        if (node->left != NULL)            q.push(node->left);        if (node->right != NULL)            q.push(node->right);    }}   /* Driver program totest above functions */int main(){     // Assuming the array is sorted    vector<int> arr = { 1, 2, 3, 4, 5, 6, 7 };    int n = arr.size();     /* Convert List to AVL tree */    struct TNode* root = sortedArrayToBST(arr, 0, n - 1);    printLevelOrder(root);     return 0;}
   // Java implementation of the approachimport java.util.*;class solution{ /* A Binary Tree node */ static  class TNode {    int data;     TNode left;     TNode right;}  /* Function to con AVL tree   from a sorted array */ static TNode sortedArrayToBST(int arr[], int start, int end){    /* Base Case */    if (start > end)        return null;     /* Get the middle element       and make it root */    int mid = (start + end) / 2;     TNode root = newNode(arr[mid]);     /* Recursively construct the       left subtree and make it       left child of root */    root.left = sortedArrayToBST(arr, start, mid - 1);     /* Recursively construct the       right subtree and make it       right child of root */    root.right = sortedArrayToBST(arr, mid + 1, end);     return root;} /* Helper function that allocates   a new node with the given data   and null to the left and   the right pointers. */static  TNode newNode(int data){     TNode node = new TNode();    node.data = data;    node.left = null;    node.right = null;     return node;} // This function is used for testing purposestatic void printLevelOrder(TNode root){    if (root == null)  return;     Queue<TNode > q= new LinkedList<TNode>();    q.add(root);       while (q.size()>0)    {        TNode node = q.element();        System.out.print( node.data + " ");        q.remove();        if (node.left != null)            q.add(node.left);        if (node.right != null)            q.add(node.right);    }}   /* Driver program totest above functions */public static void main(String args[]){     // Assuming the array is sorted    int arr[] = { 1, 2, 3, 4, 5, 6, 7 };    int n = arr.length;     /* Convert List to AVL tree */     TNode root = sortedArrayToBST(arr, 0, n - 1);    printLevelOrder(root); }}//contributed by Arnab Kundu
# Python3 code to print order of# insertion into AVL tree to# ensure no rotations # Tree Nodeclass Node:    def __init__(self, d):        self.data = d        self.left = None        self.right = None # Function to convert sorted array# to a balanced AVL Tree/BST# Input : sorted array of integers# Output: root node of balanced AVL Tree/BSTdef sortedArrayToBST(arr):         if not arr:        return None     # Find middle and get its floor value    mid = int((len(arr)) / 2)    root = Node(arr[mid])         # Recursively construct the left    # and right subtree    root.left = sortedArrayToBST(arr[:mid])    root.right = sortedArrayToBST(arr[mid + 1:])     # Return the root of the    # constructed tree    return root # A utility function to print the# Level Order Traversal of AVL Tree# using a Queuedef printLevelOrder(root):    if not root:        return         q = []    q.append(root)     # Keep printing the top element and    # adding to queue while it is not empty    while q != []:        node = q.pop(0)        print(node.data, end=" ")         # If left node exists, enqueue it        if node.left:            q.append(node.left)         # If right node exists, enqueue it        if node.right:            q.append(node.right) # Driver Codearr = [1, 2, 3, 4, 5, 6, 7]root = sortedArrayToBST(arr)printLevelOrder(root) # This code is contributed# by Adikar Bharath
// C# implementation of the approachusing System;using System.Collections.Generic; class GFG{ /* A Binary Tree node */public class TNode{    public int data;    public TNode left;    public TNode right;}  /* Function to con AVL treefrom a sorted array */static TNode sortedArrayToBST(int []arr,                    int start, int end){    /* Base Case */    if (start > end)        return null;     /* Get the middle element    and make it root */    int mid = (start + end) / 2;    TNode root = newNode(arr[mid]);     /* Recursively construct the    left subtree and make it    left child of root */    root.left = sortedArrayToBST(arr, start, mid - 1);     /* Recursively construct  the    right subtree and make it    right child of root */    root.right = sortedArrayToBST(arr, mid + 1, end);     return root;} /* Helper function that allocatesa new node with the given dataand null to the left andthe right pointers. */static TNode newNode(int data){    TNode node = new TNode();    node.data = data;    node.left = null;    node.right = null;     return node;} // This function is used for testing purposestatic void printLevelOrder(TNode root){    if (root == null) return;     Queue<TNode > q = new Queue<TNode>();    q.Enqueue(root);         while (q.Count > 0)    {        TNode node = q.Peek();        Console.Write( node.data + " ");        q.Dequeue();        if (node.left != null)            q.Enqueue(node.left);        if (node.right != null)            q.Enqueue(node.right);    }} /* Driver code */public static void Main(){     // Assuming the array is sorted    int []arr = { 1, 2, 3, 4, 5, 6, 7 };    int n = arr.Length;     /* Convert List to AVL tree */    TNode root = sortedArrayToBST(arr, 0, n - 1);    printLevelOrder(root);}} /* This code contributed by PrinciRaj1992 */
<script> // Javascript implementation of the approach /* A Binary Tree node */class TNode{    constructor()    {        this.data = 0;        this.left = null;        this.right = null;    }}  /* Function to con AVL treefrom a sorted array */function sortedArrayToBST(arr, start, end){    /* Base Case */    if (start > end)        return null;     /* Get the middle element    and make it root */    var mid = parseInt((start + end) / 2);    var root = newNode(arr[mid]);     /* Recursively construct the    left subtree and make it    left child of root */    root.left = sortedArrayToBST(arr, start, mid - 1);     /* Recursively construct the    right subtree and make it    right child of root */    root.right = sortedArrayToBST(arr, mid + 1, end);     return root;} /* Helper function that allocatesa new node with the given dataand null to the left andthe right pointers. */function newNode(data){    var node = new TNode();    node.data = data;    node.left = null;    node.right = null;     return node;} // This function is used for testing purposefunction printLevelOrder(root){    if (root == null) return;     var q = [];    q.push(root);         while (q.length > 0)    {        var node = q[0];        document.write( node.data + " ");        q.shift();        if (node.left != null)            q.push(node.left);        if (node.right != null)            q.push(node.right);    }} /* Driver code */// Assuming the array is sortedvar arr = [1, 2, 3, 4, 5, 6, 7];var n = arr.length; /* Convert List to AVL tree */var root = sortedArrayToBST(arr, 0, n - 1);printLevelOrder(root); // This code is contributed by itsok. </script>
4 2 6 1 3 5 7
 
Time Complexity: O(N)Auxiliary Space: O(N) 
andrew1234
lkcbharath
princiraj1992
itsok
pankajsharmagfg
sagartomar9927
ashutoshsinghgeeksforgeeks
AVL-Tree
Advanced Data Structure
Algorithms
Binary Search Tree
Binary Search Tree
Algorithms
AVL-Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Extendible Hashing (Dynamic approach to DBMS)
Ternary Search Tree
Proof that Dominant Set of a Graph is NP-Complete
2-3 Trees | (Search, Insert and Deletion)
Quad Tree
SDE SHEET - A Complete Guide for SDE Preparation
Top 50 Array Coding Problems for Interviews
DSA Sheet by Love Babbar
Difference between BFS and DFS
A* Search Algorithm