Print the elements of given two Binary Trees in sorted order

// C# program of the above approach

using System;
using System.Collections;
using System.Collections.Generic;

public class GFG {

    // Structure of a binary tree node
    public class Node {
        public int data;
        public Node left, right;
        public Node(int data)
        {
            left = right = null;
            this.data = data;
        }
    }

    // Dictionary to store all elements from given two trees
    static Dictionary<int, int> m
        = new Dictionary<int, int>();

    // Recursive function to perform inorder traversal on
    // tree
    public static void traverse(Node root)
    {
        // Base Case
        if (root == null)
            return;
        else {
            // Update map
            if (m.ContainsKey(root.data))
                m[root.data] += 1;
            else
                m.Add(root.data, 1);
        }

        // Recursive call for left subtree
        traverse(root.left);

        // Recursive call for right subtree
        traverse(root.right);
    }

    // Function to print all the elements of two given
    // binary trees in sorted order
    public static void printAllElements(Node root1,
                                        Node root2)
    {
        // Traverse the 1st tree
        traverse(root1);

        // Traverse the 2nd tree
        traverse(root2);

        ArrayList v = new ArrayList();

        // Traverse the map.
        foreach(KeyValuePair<int, int> it in m)
        {
            for (int i = 0; i < it.Value; i++) {
                v.Add(it.Key);
            }
        }

        v.Sort();

        foreach(var i in v) { Console.Write(i + " "); }
    }

    static public void Main()
    {

        // Code
        Node root1 = new Node(8);
        root1.left = new Node(2);
        root1.right = new Node(10);
        root1.left.left = new Node(1);

        Node root2 = new Node(5);
        root2.left = new Node(3);
        root2.right = new Node(0);

        printAllElements(root1, root2);
    }
}

// This code is contributed by lokesh (lokeshmvs21).

using System;
using System.Collections.Generic;
using System.Linq;
using System.Collections;

// Define a binary tree node class with a value, left child,
// and right child
public class TreeNode
{
    public int val;
    public TreeNode left;
    public TreeNode right;

    public TreeNode(int val)
    {
        this.val = val;
        this.left = null;
        this.right = null;
    }
}

public class GFG
{
    // Define a function to merge two binary trees into a
    // sorted list of their values
    public static List<int> MergeTrees(TreeNode root1,
                                       TreeNode root2)
    {
        // Create a TreeMap to store the frequency of each
        // node's value (automatically sorted by key)
        SortedDictionary<int, int> freqMap = new SortedDictionary<int, int>();
        // Traverse the first tree in inorder and update the
        // frequency map
        InorderTraversal(root1, freqMap);
        // Traverse the second tree in inorder and update
        // the frequency map
        InorderTraversal(root2, freqMap);
        // Create an empty list to hold the merged values
        List<int> merged = new List<int>();
        // Iterate through the keys of the frequency map
        // (sorted order)
        foreach (int key in freqMap.Keys)
        {
            // Append the value to the merged list the
            // number of times it appears in the frequency
            // map
            int freq = freqMap[key];
            for (int i = 0; i < freq; i++)
            {
                merged.Add(key);
            }
        }
        // Return the merged list
        return merged;
    }

    // Define a function to traverse a binary tree in
    // inorder and update the frequency map
    private static void InorderTraversal(TreeNode root,
                                         SortedDictionary<int, int> freqMap)
    {
        // If the root is null, return
        if (root == null)
        {
            return;
        }
        // Traverse the left subtree
        InorderTraversal(root.left, freqMap);
        // Update the frequency of the current node's value
        // in the frequency map
        if (freqMap.ContainsKey(root.val))
        {
            freqMap[root.val]++;
        }
        else
        {
            freqMap[root.val] = 1;
        }
        // Traverse the right subtree
        InorderTraversal(root.right, freqMap);
    }

    // Main function to test the code
    public static void Main(string[] args)
    {
        // Example usage:
        // Create two binary trees
        TreeNode root1 = new TreeNode(8);
        root1.left = new TreeNode(2);
        root1.right = new TreeNode(10);
        root1.left.left = new TreeNode(1);
        TreeNode root2 = new TreeNode(5);
        root2.left = new TreeNode(3);
        root2.right = new TreeNode(0);

        // Merge the trees and print the result
        List<int> merged = MergeTrees(root1, root2);
        Console.WriteLine("{"+string.Join(", ", merged)+"}"); // Output: 0, 1, 2, 3, 5, 8, 10
    }
}

// This code is contributed by Dwaipayan Bandyopadhyay