Ошибка

#include <iostream>
#include <fstream>
#include <time.h>
using namespace std;
 
int N = 0, i=0;
int Sum = 0;
struct TreeElement
{
    int Key;
    TreeElement* Left;
    TreeElement* Right;
    int L;
    int R;
}
 
int max (int a, int b)
{
    return (a > b) ? a : b;
}
 
void Output(TreeElement* a, ofstream &f)
{
    if (a != NULL)
    {
        f << a -> Key << '\n';
        Output (a -> Left, f);
        Output (a -> Right, f);
    }
}
 
void Input(ifstream &f, TreeElement* First)
{
    char c [100];
    f.getline (c,100);
    First -> Key = atoi (c);
    while (! f.eof())
    {
        f.getline (c,100);
        TreeElement* t = new TreeElement;
        t -> Left = NULL;
        t -> Right = NULL;
        t -> L = 0;
        t -> R = 0;
        t -> Key = atoi (c);
        TreeElement* temp = First;
        bool k = false;
        while ( k == false)
        {
            if (t -> Key < temp -> Key)
                if (temp -> Left != NULL)
                    temp = temp -> Left;
                else
                {
                    temp -> Left = t;
                    k = true;
                }
            else if (t -> Key > temp -> Key)
                if (temp -> Right != NULL)
                    temp = temp -> Right;
                else
                {
                    temp -> Right = t;
                    k = true;
                }
            else if (t -> Key == temp -> Key)
            {
                delete t;
                k = true;
            }
        }
    }
}
 
TreeElement * Delete(TreeElement *Tree, int x)
{ 
    TreeElement* P, *v;
    if (x < Tree -> Key) Tree -> Left = Delete(Tree -> Left, x);
       else if (x > Tree -> Key) Tree-> Right = Delete(Tree -> Right, x);
        else {P = Tree;
          if (!Tree -> Right) Tree = Tree -> Left;
          else if (!Tree -> Left) Tree = Tree -> Right;
               else
                            { v = Tree -> Left;
                              if (v -> Right)
                              {
                  while (v -> Right -> Right) v = v -> Right; 
                  Tree -> Key = v -> Right -> Key;
                  P = v -> Right; v -> Right = v -> Right -> Left;
                              }
                              else
                              {
                               Tree -> Key = v -> Key;
                               P = v;
                               Tree -> Left = Tree-> Left -> Left;
                              }
                }
          free(P);
        }
        return Tree;
}
 
void Obhod(TreeElement* a)
{
 
    if (a != NULL)
    {
     
        Obhod (a -> Left);
        Obhod (a -> Right);
        if (a -> Left != NULL)
        {
            a -> L = max (a -> Left -> L, a -> Left -> R) + 1;
 
        }
        else 
            a-> L = -1 ;
        if (a -> Right != NULL)
        {
            
            a -> R = max (a -> Right -> L, a -> Right -> R) + 1;
            
    
        }
        else
            a-> R = -1 ;
        
        if ((a -> L == a -> R+2 ) || ( a-> R == a-> L+2))
        {
            Sum += a->Key; N++;
        }
        
    }
 
}
 
int Sort (TreeElement *a, int* arr)
{
 
    if (a != NULL)
    {
     
        Sort (a -> Left, arr);
        Sort (a -> Right, arr);
        if ((a -> L == a -> R+2) || ( a-> R == a-> L+2))
        {
            arr[i] = a -> Key;
            i++;
        }
        
    }
 
    return *arr;
        
}
 
int Sort2 (int *arr)
{
        for (int k = 0; k < N; k++)
            for (int l=k; l < N; l++)
                if (arr[l] < arr[k])
                {
                    int b = arr[l];
                    arr[l] = arr[k];
                    arr[k] = b;
                }
                return arr[(N-1)/2];
}
 
int main()
{
    
    ifstream in;
    ofstream out;
    in.open ("tst.in");
    out.open ("tst.out");
    TreeElement* First = new TreeElement;
    First -> Left = NULL;
    First -> Right = NULL;
    First -> L = 0;
    First -> R = 0;
    Input(in, First);
    Obhod(First);
    if (N == 1)
    {
        Delete(First,Sum);
        Output(First,out);
    }
    else
    {
       if (N % 2 == 0) Output(First,out);
       
       else 
       {
               int *arr = new int[N];
               Sort(First,arr);
               Delete(First,Sort2(arr));
               Output(First,out);
       }
    }
    in.close();
    out.close();
    return 0;
}

struct TreeElement
{
    int Key;
    TreeElement* Left;
    TreeElement* Right;
    int L;
    int R;
};