How to handle duplicates in Binary Search Tree?

// C# program to implement basic operations 
// (search, insert, and delete) on a BST that
// handles duplicates by storing count with 
// every node

using System;

class Node {
    public int key, count;
    public Node left, right;

    public Node(int x) {
        key = x;
        count = 1;
        left = right = null;
    }
}

class GfG {
  
    // A utility function to do inorder traversal of BST
     static void inorder(Node root) {
        if (root != null) {
            inorder(root.left);
            Console.Write(root.key + "(" + root.count + ") ");
            inorder(root.right);
        }
    }

    // A utility function to insert a new 
    // node with given key in BST 
    static Node insert(Node node, int key) {
      
        // If the tree is empty, return a new node
        if (node == null) 
            return new Node(key);

        // If key already exists in BST, 
        // increment count and return
        if (key == node.key) {
            node.count++;
            return node;
        }

        // Otherwise, recur down the tree
        if (key < node.key)
            node.left = insert(node.left, key);
        else
            node.right = insert(node.right, key);

        // return the (unchanged) node pointer 
        return node;
    }

    // Given a non-empty binary search tree, return 
    // the node with minimum key value found in that 
    // tree. Note that the entire tree does not need
    // to be searched. 
     static Node minValueNode(Node node) {
        Node current = node;

        // loop down to find the leftmost leaf 
        while (current.left != null)
            current = current.left;

        return current;
    }

    // Given a binary search tree and a key, 
    // this function deletes a given key and 
    // returns root of modified tree 
     static Node deleteNode(Node root, int key) {
       
        // base case
        if (root == null) return root;

        // If the key to be deleted is smaller than the
        // root's key, then it lies in left subtree
        if (key < root.key)
            root.left = deleteNode(root.left, key);

        // If the key to be deleted is greater than 
        // the root's key, then it lies in right subtree
        else if (key > root.key)
            root.right = deleteNode(root.right, key);

        // if key is same as root's key
        else {
          
            // If key is present more than once, 
            // simply decrement count and return
            if (root.count > 1) {
                root.count--;
                return root;
            }

            // else, delete the node
            // node with only one child or no child
            if (root.left == null) {
                Node curr = root.right;
                root = null;
                return curr;
            } else if (root.right == null) {
                Node curr = root.left;
                root = null;
                return curr;
            }

            // node with two children: Get the inorder 
            // successor (smallest in the right subtree)
            Node mn = minValueNode(root.right);

            // Copy the inorder successor's 
            // content to this node
            root.key = mn.key;
            root.count = mn.count;

            // To ensure successor gets deleted by 
            // deleteNode call, set count to 0.
            mn.count = 0;

            // Delete the inorder successor
            root.right = deleteNode(root.right, mn.key);
        }
        return root;
    }

    static void Main(string[] args) {
      
        // Let us create following BST
        //        12(3)
        //       /     \
        //    10(2)     20(1)
        //   /   \
        // 9(1) 11(1) 
        Node root = null;
        root = insert(root, 12);
        root = insert(root, 10);
        root = insert(root, 20);
        root = insert(root, 9);
        root = insert(root, 11);
        root = insert(root, 10);
        root = insert(root, 12);
        root = insert(root, 12);

        Console.WriteLine("Inorder traversal of the given tree ");
        inorder(root);

        Console.WriteLine("\nDelete 20");
        root = deleteNode(root, 20);
        Console.WriteLine("Inorder traversal of the modified tree ");
        inorder(root);

        Console.WriteLine("\nDelete 12");
        root = deleteNode(root, 12);
        Console.WriteLine("Inorder traversal of the modified tree ");
        inorder(root);

        Console.WriteLine("\nDelete 9");
        root = deleteNode(root, 9);
        Console.WriteLine("Inorder traversal of the modified tree ");
        inorder(root);
    }
}