Problem StatementImplement an AVL tree data structure that accepts a series of integers as input and constructs the AVL tree. After inserting all the integers, perform an in-order traversal of the AVL tree and print the elements.Input format :The first line of input consists of the number of nodes in the AVL Tree, N.The second line of input consists of the nodes of the AVL Tree, separated by space.Output format :The output prints the in-order traversal of the constructed AVL Tree, separated by space.

Sure, here is a Python solution for the problem:

class Node:
    def __init__(self, key):
        self.key  = key
        self.left   = None
        self.right  = None
        self.height = 1

class AVL_Tree:
    def insert(self, root, key):
        if not root:
            return Node(key)
        elif key < root.key:
            root.left = self.insert(root.left, key)
        else:
            root.right = self.insert(root.right, key)
        root.height = 1 + max(self.getHeight(root.left), self.getHeight(root.right))
        balance = self.getBalance(root)
        if balance > 1:
            if key < root.left.key:
                return self.rightRotate(root)
            else:
                root.left = self.leftRotate(root.left)
                return self.rightRotate(root)
        if balance < -1:
            if key > root.right.key:
                return self.leftRotate(root)
            else:
                root.right = self.rightRotate(root.right)
                return self.leftRotate(root)
        return root

    def leftRotate(self, z):
        y = z.right
        T2 = y.left
        y.left = z
        z.right = T2
        z.height = 1 + max(self.getHeight(z.left), self.getHeight(z.right))
        y.height = 1 + max(self.getHeight(y.left), self.getHeight(y.right))
        return y

    def rightRotate(self, y):
        x = y.left
        T3 = x.right
        x.right = y
        y.left = T3
        y.height = 1 + max(self.getHeight(y.left), self.getHeight(y.right))
        x.height = 1 + max(self.getHeight(x.left), self.getHeight(x.right))
        return x

    def getHeight(self, root):
        if not root:
            return 0
        return root.height

    def getBalance(self, root):
        if not root:
            return 0
        return self.getHeight(root.left) - self.getHeight(root.right)

    def preOrder(self, root):
        if not root:
            return
        print("{0} ".format(root.key), end="")
        self.preOrder(root.left)
        self.preOrder(root.right)

    def inOrder(self, root):
        if not root:
            return
        self.inOrder(root.left)
        print("{0} ".format(root.key), end="")
        self.inOrder(root.right)

myTree = AVL_Tree()
root = None
nodes = int(input())
keys = list(map(int, input().split()))
for key in keys:
    root = myTree.insert(root, key)
myTree.inOrder(root)

This Python script first defines a Node class for the AVL tree nodes, and an AVL_Tree class for the tree itself. The AVL_Tree class has methods for inserting nodes, performing left and right rotations, getting the height of a node, getting the balance factor of a node, and performing pre-order and in-order traversals. The script then reads the number of nodes and the node keys from the input, inserts the nodes into the tree, and performs an in-order traversal of the tree.