Вывести путь от корня до листа с наибольшим произведением элементов

Дано дерево. Как вывести путь от корня до листа с наибольшим произведением элементов?

#include <iostream>
#include <ctime>
using namespace std;

struct tree
{
    int key;
    struct tree* left;
    struct tree* right;
};
void outputTree(tree* tree, int level);
void creatNew(tree** Root, int el);
tree creatTree(tree** Root);
tree Del(tree** Root, int key);
tree* List(int i);
void Del_All(tree* Root);

int main()
{
    setlocale(LC_ALL, "Russian");
    tree* Root = NULL;
    creatTree(&Root);
    outputTree(Root, 1);
    int choise;
    int i = 1;
    while (i == 1)
    {
        cout << "1. Выполнить функцию.\n"
            << "2. Вывести дерево.\n"
            << "3. Удалить элемент из дерева.\n"
            << "4. Добавить новый элемент.\n"
            << "5. Выход\n"
            << ">>>  ";
        cin >> choise;

        switch (choise)
        {
        case 1:
        {
            cout << "\n Путь с наибольшим произведением элементов: "<< endl;
            break;
        }
        case 2:
        {
            outputTree(Root, 1);
            break;
        }
        case 3:
        {
            int el;
            cout << "Введите удаляемый элемент: ";
            cin >> el;
            Del(&Root, el);
            cout << endl;
            break;
        }
        case 4:
        {
            int el;
            cout << "Введите элемент: ";
            cin >> el;
            creatNew(&Root, el);
            break;
        }
        case 5:
            i = rand() % 10 + 1;
            break;
        }

    }
    Del_All(Root);
    return 0;
}


tree creatTree(tree** Root)
{
    tree* Prev = NULL, * t;
    int elem, find;
    int all;
    if (*Root == NULL)
    {
        cout << "Введите корень: ";
        cin >> elem;

        *Root = List(elem);
    }
    cout << "Введите количество элементов дерева:";
    cin >> all;
    while (all > 0)
    {

        elem = rand() % 101;
        t = *Root;
        find = 0;
        while (t && !find)
        {
            Prev = t;
            if (elem == t->key)
                find = 1;
            else
                if (elem < t->key)
                    t = t->left;
                else
                    t = t->right;
        }
        if (!find)
        {
            t = List(elem);

            if (elem < Prev->key)
                Prev->left = t;
            else
                Prev->right = t;
        }
        all--;
    }
    return **Root;
}
void Del_All(tree* Root) {

    if (Root != NULL) {

        Del_All(Root->left);

        Del_All(Root->right);

        free(Root);

    }

}
tree* List(int i)
{
    tree* t;
    t = new tree;
    t->key = i;

    t->left = t->right = NULL;

    return t;

}
void outputTree(tree* tree, int level)
{
    if (tree)
    {
        outputTree(tree->right, level + 1);
        for (int i = 0; i < level; i++)
            cout << "    ";
        cout << tree->key << endl << endl;

        outputTree(tree->left, level + 1);
    }
}
tree Del(tree** Root, int key)
{
    tree* del, * prevDel, * R, * prevR;
    del = *Root;
    prevDel = NULL;
    while (del != NULL && del->key != key)
    {
        prevDel = del;
        if (del->key > key)
            del = del->left;
        else
            del = del->right;
    }

    if (del == NULL)
    {
        cout << "Нет такого ключа\n";
        return **Root;

    }
    if (del->right == NULL)
        R = del->left;
    else
        if (del->left == NULL)
            R = del->right;
        else
        {
            prevR = del;
            R = del->left;
            while (R->right != NULL)
            {
                prevR = R;
                R = R->right;
            }
            if (prevR == del)
                R->right = del->right;
            else
            {
                R->right = del->right;
                prevR->right = R->left;
                R->left = prevR;
            }

        }
    if (del == *Root)
        *Root = R;
    else
        if (del->key < prevDel->key)
            prevDel->left = R;
        else
            prevDel->right = R;

    cout << "Удаляемый элемент: " << del->key;
    delete(del);
    return **Root;

}

void creatNew(tree** Root, int el)
{
    tree* found = *Root, * prevFound = NULL;
    bool flag = true;
    while (found != NULL)
    {
        if (el > found->key)
        {
            prevFound = found;
            found = found->right;
        }
        else
            if (el < found->key)
            {
                prevFound = found;
                found = found->left;
            }
            else
            {
                flag = false;
                break;
            }
    }
    if (flag == true)
    {
        found = List(el);
        if (el > prevFound->key)
            prevFound->right = found;
        else
            prevFound->left = found;
    }
    else
        cout << "Такой элемент уже есть.\n";
}