Count all Grandparent-Parent-Child Triplets in a binary tree whose sum is greater than X

#include <iostream>
#include <vector>

using namespace std;

// Class to store node information
class Node {
public:
    int val;
    Node* left;
    Node* right;

    Node(int value = 0, Node* l = nullptr,
         Node* r = nullptr)
        : val(value)
        , left(l)
        , right(r)
    {
    }
};

// Stack to perform stack operations
class Stack {
public:
    vector<int> stack;

    int size() { return stack.size(); }

    int top()
    {
        return (size() > 0) ? stack[size() - 1] : 0;
    }

    void push(int val) { stack.push_back(val); }

    void pop()
    {
        if (size() >= 1) {
            stack.pop_back();
        }
        else {
            stack.clear();
        }
    }

    // Period is 3 to satisfy grandparent-parent-child
    // relationship
    void rolling_push(int val, int period = 3)
    {

        // Find the index of element to remove
        int to_remove_idx = size() - period;

        // If index is out of bounds then we remove nothing,
        // i.e, 0
        int to_remove = (to_remove_idx < 0)
                            ? 0
                            : stack[to_remove_idx];

        // For rolling sum what we want is that at each
        // index i, we remove out-of-period elements, but
        // since we are not maintaining a separate list of
        // actual elements, we can get the actual element by
        // taking diff between current and previous element.
        // So every time we remove an element, we also add
        // the element just before it, which is equivalent
        // to removing the actual value and not the rolling
        // sum.

        // If index is out of bounds or 0 then we add
        // nothing i.e, 0, because there is no previous
        // element
        int to_add = (to_remove_idx <= 0)
                         ? 0
                         : stack[to_remove_idx - 1];

        // If stack is empty then just push the value
        // Else add last element to current value to get
        // rolling sum then subtract out-of-period elements,
        // then finally add the element just before
        // out-of-period element
        if (size() <= 0) {
            push(val);
        }
        else {
            push(val + stack[size() - 1] - to_remove
                 + to_add);
        }
    }

    void show()
    {
        for (auto item : stack) {
            cout << item << " ";
        }
        cout << endl;
    }
};

// Global variables used by count_with_greater_sum()
int count = 0;
Stack s;

void count_with_greater_sum(Node* root_node, int x)
{

    if (!root_node) {
        return;
    }

    s.rolling_push(root_node->val);

    if (s.size() >= 3 && s.top() > x) {
        count++;
    }

    count_with_greater_sum(root_node->left, x);
    count_with_greater_sum(root_node->right, x);

    // Moving up the tree so pop the last element
    s.pop();
}

int main()
{
    Node* root = new Node(10);

    root->left = new Node(1);
    root->right = new Node(22);

    root->left->left = new Node(35);
    root->left->right = new Node(4);

    root->right->left = new Node(15);
    root->right->right = new Node(67);

    root->left->left->left = new Node(57);
    root->left->left->right = new Node(38);

    root->left->right->left = new Node(9);
    root->left->right->right = new Node(10);

    root->right->left->left = new Node(110);
    root->right->left->right = new Node(312);

    root->right->right->left = new Node(131);
    root->right->right->right = new Node(414);

    root->right->left->right->left = new Node(8);

    root->right->right->right->right = new Node(39);

    count_with_greater_sum(root, 100);
    cout << count << endl;
}

// CPP implementation to print
// the nodes having a single child
#include <bits/stdc++.h>
using namespace std;

// Class of the Binary Tree node
struct Node
{
  int data;
  Node *left, *right;

  Node(int x)
  {
    data = x;
    left = right = NULL;
  }
};

// global variable
int count = 0; 

void preorder(Node* grandParent,
              Node* parent,
              Node* child,
              int sum)
{
  if(grandParent != NULL && 
     parent != NULL && 
     child != NULL && 
     (grandParent -> data + 
      parent -> data + 
      child->data) > sum)
  {
    count++;
    //uncomment below lines if you 
    // want to print triplets
    /*System->out->print(grandParent
      ->data+"-->"+parent->data+"-->
      "+child->data);
      System->out->println();*/
  }
  if(child == NULL)
    return;
  
  preorder(parent, child, 
           child -> left, sum);
  preorder(parent, child, 
           child -> right, sum);
}

//Driver code
int main()
{
  Node *r10 = new Node(10);
  Node *r1 = new Node(1);
  Node *r22 = new Node(22);
  Node *r35 = new Node(35);
  Node *r4 = new Node(4);
  Node *r15 = new Node(15);
  Node *r67 = new Node(67);
  Node *r57 = new Node(57);
  Node *r38 = new Node(38);
  Node *r9 = new Node(9);
  Node *r10_2 = new Node(10);
  Node *r110 = new Node(110);
  Node *r312 = new Node(312);
  Node *r131 = new Node(131);
  Node *r414 = new Node(414);
  Node *r8 = new Node(8);
  Node *r39 = new Node(39);

  r10 -> left = r1;
  r10 -> right = r22;
  r1 -> left = r35;
  r1 -> right = r4;
  r22 -> left = r15;
  r22 -> right = r67;
  r35 -> left = r57;
  r35 -> right = r38;
  r4 -> left = r9;
  r4 -> right = r10_2;
  r15 -> left = r110;
  r15 -> right = r312;
  r67 -> left = r131;
  r67 -> right = r414;
  r312 -> left = r8;
  r414 -> right = r39;

  preorder(NULL, NULL, 
           r10, 100);
  cout << cont;
}

// This code is contributed by Mohit Kumar 29