Как оптимизировать программу ? Или подскажите другую реализацию. Задача на 47/1000 секунды превышает лимит

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string>
#include <iostream>
#include <fstream>
#include <stdlib.h>
 
using namespace std;
 
void print(int &x, ofstream &F)
{
    F << x << endl;
 
}
class Tree
{
protected:
    struct tnode {
        int x; // поле данных
        tnode *father;
        tnode *left;  // левый потомок
        tnode *right;// правый потомок
        int deep = 0;//кол-во узлов в поддеревьях текущего узла
    };
    tnode *root;
public:
    Tree::tnode* Get_root() const
    {
        return root;
    }
    bool insert(tnode* R, int f)
    {
        bool t;
        if (R == 0)
        {
            tnode* P = new tnode;
            P->x = f;
            P->father = NULL;
            P->left = NULL;
            P->right = NULL;
            root = P;
            return true;
        }
        if (R->x > f)
        {
            if (R->left == NULL)
            {
                tnode *P = new tnode;
                P->x = f;
                P->father = R;
                P->left = NULL;
                P->right = NULL;
                R->left = P;
                return true;
            }
            else
            {
                t = insert(R->left, f);
                return t;
            }
        }
        if (R->x < f)
        {
            if (R->right == NULL)
            {
                tnode *P = new tnode;
                P->x = f;
                P->father = R;
                P->left = NULL;
                P->right = NULL;
                R->right = P;
                return true;
            }
            else
            {
                t = insert(R->right, f);
                return t;
            }
        }
        if (R->x == f)
            return false;
    }
 
    tnode* Deeping(tnode* T)//расстановка deep+находжение нужного узла
    {
        static int res = 0;
        static tnode *target = T;
        if (T)
        {
            Deeping(T->left);
            Deeping(T->right);
            if (T->left == NULL && T->right == NULL)
            {
                T->deep = 1;
            }
 
            if (T->left != NULL || T->right != NULL)
            {
                T->deep += 1;
            }
 
            if (T->father != NULL)
            {
                T->father->deep += T->deep;
            }
        
            if (T->left != NULL && T->right != NULL)
            {
                if (abs(T->left->x - T->right->x) >= res && T->x > target->x)
                {
                    target = T;
                    res = abs(T->left->x - T->right->x);
                }
            }
 
            if (T->left == NULL && T->right != NULL)
            {
                if (T->right->x >= res && T->x > target->x)
                {
                    target = T;
                    res = T->right->x;
                }
            }
 
            if (T->left != NULL && T->right == NULL)
            {
                if (T->left->x >= res && T->x > target->x)
                {
                    target = T;
                    res = T->left->x;
                }
            }
 
            return target;
        }
    }
 
    void ForEach(tnode* root, ofstream &s, void print(int &,ofstream &))const
    {
        if (root)
        {   
            print(root->x, s);
            ForEach(root->left, s, print);
            ForEach(root->right, s, print);
            
        }
    }
 
    void deleting(tnode* T, tnode* target)//правое удаление
    {           
        if (T == NULL)
            return;
        if (target->x < T->x)
            return deleting(T->left, target);
        else if (target->x > T->x)
            return deleting(T->right,target);
        else {
            if (T->left == NULL && T->right == NULL) {
                if (T->father->left == T)
                    T->father->left = NULL;
                else
                    T->father->right = NULL;
                delete T;
            }
            else {
                tnode * newnode = NULL;
                
                newnode = Leftmost(T->right);
                if (newnode == NULL)
                {
                    if (T->father != NULL)
                    {
                        if(T->father->left==T)
                            T->father->left = T->left;
                        else
                            T->father->right = T->left;
                    }
                    if (T->left != NULL)
                        T->left->father = T->father;
                    delete T;
                    return;
                }
 
                if (newnode->father != NULL)
                    newnode->father->left = newnode->right;
                if (newnode->right != NULL)
                    newnode->right->father = newnode->father;
 
                newnode->father = T->father;
                newnode->right = T->right;
                newnode->left = T->left;
                delete T;
            }
        }
    }
    tnode * Leftmost(tnode * node) {
        if (node == NULL)
            return NULL;
        if (node->left != NULL) {
            return Leftmost(node->left);
        }
        return node;
    }
 
    Tree()
    {
        root = NULL;
    }
    virtual~Tree()
    {
 
    }
};
int main()
{
    string line="";
    setlocale(LC_ALL, ".1251");
    ifstream fin("tst.in");
    ofstream fout("tst.out");
    Tree T;
    while (!fin.eof())
    {
        fin >> line;
        if (line == "")
            break;
        T.insert(T.Get_root(),atoi(line.c_str()));
    }
    T.deleting(T.Get_root(), T.Deeping(T.Get_root()->right));
    T.ForEach(T.Get_root(), fout, print);
    system("pause");
    return 0;
}