ошибка в функции в задании списка

#define compLT(a,b) (a < b)
#define compEQ(a,b) (a == b)
 
#include <iostream>
#include <time.h>
#include <locale>
 
using namespace std;
 
 
typedef int T; // тип элемента
typedef struct Node_ {
  T data;  // значение узла
    struct Node_ *left;// левый потомок
    struct Node_ *right;// правый потомок
    struct Node_ *parent;// родитель
} Node;
Node *root = NULL; //корень бинарного дерева поиска
 
//PROTOTYPE START
Node* insertNode(T data);
void deleteNode(Node *z);
Node* findNode(T data);
void printTree(Node *node, int l = 0);
void findSum();
//PROTOTYPE END
 
int main(){
  setlocale(LC_ALL,"");
  int i, *a, maxnum;
  cout << "Введите количество элементов maxnum(бинарного дерева) : ";
  cin >> maxnum;
  cout << endl;
  a = new int[maxnum];  
  srand(time(NULL)*1000);
  
  // генерация массива
  for (i = 0; i < maxnum; i++)
  {
    a[i] = rand();
  }
  cout << "Вывод сгенерированной последовательности" << endl;
  
  for (i = 0; i < maxnum; i++)
  
  cout << a[i] << " ";
  cout << endl;
  cout << endl;
 
  // добавление элементов в бинарное дерево поиска
  for (i = 0; i < maxnum; i++) {
    insertNode(a[i]);
  }
  cout << "Вывод бинарного дерева поиска" << endl;
  printTree(root);
 
  cout << endl;
  // поиск элементов по бинарному дереву поиска
  for (i = maxnum-1; i >= 0; i--) {
    findNode(a[i]);
  }
 
 cout << "Сумма цифр в значениях тех узлов, которые лежат на пути от корня до максимального элемента."<< endl;
 findsum();
 
  // очистка бинарного дерева поиска
  for (i = 0; i < maxnum; i++) {
    deleteNode(findNode(a[i]));
  }
  system("pause");
  return 0;
}
 
//функция выделения памяти для нового узла и вставка в дерево
Node* insertNode(T data) {
  Node *x, *current, *parent;
  current = root;
  parent = 0;
  while (current) {
    if ( data == current->data ) return (current);
      parent = current;
      current = data < current->data ? 
      current->left : current->right;
  }
  x = new Node;
  x->data = data;
  x->parent = parent;
  x->left = NULL;
  x->right = NULL;
  if(parent)
    if( x->data < parent->data )
      parent->left = x;
    else
    parent->right = x;
  else
 
    root = x;
  
  return(x);
}
 
//функция удаления узла из дерева
void deleteNode(Node *z) {
  Node *x, *y;
  if (!z || z == NULL) return;
  if (z->left == NULL || z->right == NULL)
    y = z;
  else {
    y = z->right;
    while (y->left != NULL) y = y->left;
  }
  if (y->left != NULL)
    x = y->left;
  else
    x = y->right;
  if (x) x->parent = y->parent;
  if (y->parent)
    if (y == y->parent->left)
      y->parent->left = x;
    else
      y->parent->right = x;
  else
    root = x;
  if (y != z) {
    y->left = z->left;
    if (y->left) y->left->parent = y;
      y->right = z->right;
    if (y->right) y->right->parent = y;
      y->parent = z->parent;
    if (z->parent)
      if (z == z->parent->left)
        z->parent->left = y;
      else
        z->parent->right = y;
    else
      root = y;
      free (z);
  } 
  else {
    free (y);
  }
}
 
//функция поиска узла, содержащего data
Node* findNode(T data) {
  Node *current = root;
  while(current != NULL)
    if(compEQ(data, current->data))
      return (current);
    else
      current = compLT(data, current->data) ? current->left : current->right;
  return(0);
}
 
//функция вывода бинарного дерева поиска
void printTree(Node *node, int l){
  int i;
  if (node != NULL) {
    printTree(node->right, l+1);
    for (i=0; i < l; i++) cout << "    ";
    printf ("%4ld", node->data);
    printTree(node->left, l+1);
  }
  else cout << endl;
}
 struct SearchResult {    
    int _maxValue;
    int _sum;
    public:
    SearchResult():_sum(0), _maxValue(numeric_limits<int>::min()) {};
    void getMaxValue() const;
    void setMaxValue(int value);
    void setSum(int value);
    void getSum() const;
 
 
}
void findsum(const Node &node, int previousSum, SearchResult &  result)
{
    double sum = previousSum + node.data;   
    if(node.data > result.getMaxValue()) {
        result.setMaxValue(node.data);
        result.setSum(sum);
    }
    if(node.left != null) findsum(node.left, sum, result);
    if(node.right != null) findsum(node.right, sum, result);
}
 
// Это просто некоторые данные в которых хранится максимальное значение и сумма можно 
// просто структуру из двух полей
struct SearchResult {    
    int _maxValue;
    int _sum;
    public:
    SearchResult():_sum(0), _maxValue(numeric_limits<int>::min()) {};
    void getMaxValue() const;
    void setMaxValue(int value);
    void setSum(int value);
    void getSum() const;
 
 
}

void findSum(); // ваш прототип
void findsum(const Node &node, int previousSum, SearchResult &  result) // а тут она уже совсем другая