Not to add duplicate values to Binary tree in python (not BST)

I am trying to create a binary tree from an array of values. I dont want to add a duplicate entry to the tree, if a duplicate value is found, I need to increment the counter of existing node.

class eNode: 
	def __init__(self, data):
		self.data = data 
		self.left = self.right = None
		self.Counter = 1
	def __str__(self):
		return str(self.data) + " Counter: " + str(self.Counter)
def insertLevelOrder(arr, root, i, n):
	if i < n:
		temp = eNode(arr[i])
		root = temp
		
		root.left = insertLevelOrder(arr, root.left, 
									2 * i + 1, n)
		root.right = insertLevelOrder(arr, root.right, 
									2 * i + 2, n)	
	return root

def main():
	empList = [1, 2, 2, 3, 5]
	n = len(empList) 
	root = None
	root = insertLevelOrder(empList, root, 0, n)
	print (root);
	print (root.left);
	print (root.right);
	print (root.left.left);
	print (root.left.right);
	#inOrder(root)
				

main()

Is there a way to achieve this ? all helps are appreciated.

Since your tree building algorithm assigns a value to a specific location in the tree, that only depends on the index in the input array, it becomes a problem when certain values would not become a node in a tree (but would increment a counter of some other node):

The would-be children of that value will be orphaned.

Take the example:

[1, 2, 2, 3, 5, 6]

Without any special treatment for duplicates, this produces the following tree:

     1
   /   \
  2     2
 / \   / 
3   5 6

The fact that 6 ends up on the third level, at the 3^rd place, is completely determined by the fact that this value occurs at index 5 in the input array (zero-based indexing), and nothing else. If we would not create the node for the second 2, we would get an orphaned 6:

     1
   /   
  2     
 / \    
3   5 6

One way to solve this, is to agree that the index in the original input array is no longer defining the position of the node, and the tree would become:

     1
   /   \
  2*    3
 / \    
5   6

...where the asterisk represents a count of 2. Note that this is a completely different tree. For instance, now 3 is a direct child of 1, and only because there was a duplicate 2...

If this is however how you would want it to work, then make your algorithm iterative instead of recursive, and keep track of what the parent is of any newly created node:

class eNode: 
    def __init__(self, data):
        self.data = data 
        self.left = self.right = None
        self.counter = 1
    
    def __str__(self):
        return str(self.data) + " Counter: " + str(self.counter)

def insertLevelOrder(arr):
    if arr == []:
        return
    root = eNode(arr[0])
    nodes = [root]
    d = {root.data: root}
    right = False
    parent = 0
    for val in arr[1:]:
        if val in d:
            d[val].counter += 1
        else:
            node = eNode(val)
            nodes.append(node)
            d[val] = node    
            if right:
                nodes[parent].right = node
                parent += 1
            else:
                nodes[parent].left = node
            right = not right
    return root

def main():
    empList = [1, 2, 2, 3, 5]
    root = insertLevelOrder(empList)
    print (root);
    print (root.left);
    print (root.right);
    print (root.left.left);
    print (root.left.right);

main()

You can maintain a dictionary of value to binary tree nodes. If the value being inserted already exists in the dictionary, you can get the reference to the node and update it.