mirror rec bt cpp

#include <iostream>
#include <queue>
#include <map>
#include <list>
#include <stack>

using namespace std;

// node class
class node{
public:
    int data;
    node* left;
    node* right;
};

// function that returns a pointer to new node
node* createNode(int element){
    node* temp = (node*) malloc(sizeof(node));
    temp->data = element;
    temp->left = NULL;
    temp->right = NULL;
    return temp;
}

// function to print the preorder traversal of a binary tree
void preorder(node* root){
    if(root == NULL){
        return;
    }
    cout<<root->data<<" ";
    preorder(root->left);
    preorder(root->right);
}

// function to return mirror of the binary tree
void mirror_tree_recursive(node *root){
    if (root == NULL){
        return;
    }else{
        // creating mirror using postorder traversal
        mirror_tree_recursive(root->left);
        mirror_tree_recursive(root->right);

        node* temp = root->left;
        root->left = root->right;
        root->right = temp;
    }

}

int main() {

    node* m1 = createNode(8);
    m1->left = createNode(3);
    m1->right = createNode(10);
    m1->left->left = createNode(1);
    m1->left->right = createNode(6);
    m1->left->right->left = createNode(4);
    m1->left->right->right = createNode(7);
    m1->right->right = createNode(14);
    m1->right->right->left = createNode(13);

    node* m2 = createNode(8);
    m2->right = createNode(3);
    m2->left = createNode(10);
    m2->left->left = createNode(14);
    m2->right->left = createNode(6);
    m2->right->right = createNode(1);
    m2->left->left->right = createNode(13);
    m2->right->left->left = createNode(7);
    m2->right->left->right = createNode(4);

    cout<<"Tree #1 before mirroring : ";
    preorder(m1);
    cout<<endl;
    cout<<"Tree #1 after mirroring : ";
    mirror_tree_recursive(m1);
    preorder(m1);
    cout<<endl;
    cout<<"\n\nTree #2 is mirror of Tree #1 to check the correctness : "<<endl;
    cout<<"TREE #1 : ";
    preorder(m1);
    cout<<endl;
    cout<<"TREE #2 : ";
    preorder(m2);
    cout<<endl;

}



/*

Tree #1 before mirroring : 8 3 1 6 4 7 10 14 13
Tree #1 after mirroring : 8 10 14 13 3 6 7 4 1


Tree #2 is mirror of Tree #1 to check the correctness :
TREE #1 : 8 10 14 13 3 6 7 4 1
TREE #2 : 8 10 14 13 3 6 7 4 1

Process finished with exit code 0

*/