Find all the pairs with given sum in a BST | Set 2

// C++ implementation of the 
// above approach
#include<bits/stdc++.h>
using namespace std;
struct Node
{
  int data;
  Node *left, *right, 
       *root;

  Node(int data)
  {
    this -> data = data;
    left = NULL;
    right = NULL;
    root = NULL;
  }
};

// Function to add a node 
// to the BST
Node* AddNode(Node *root,
              int data)
{
  // If the tree is empty, 
  // return a new node
  if (root == NULL)
  {
    root = new Node(data);
    return root;
  }

  // Otherwise, recur down 
  // the tree
  if (root -> data < data)
    root -> right = AddNode(root -> right, 
                            data);

  else if (root -> data > data)
    root -> left = AddNode(root -> left, 
                           data);

  return root;
}

// Function to find the 
// target pairs
void TargetPair(Node *node, 
                int tar)
{
  // LeftList which stores 
  // the left side values
  vector<Node*> LeftList;

  // RightList which stores 
  // the right side values
  vector<Node*> RightList;

  // curr_left pointer is used 
  // for left side execution and
  // curr_right pointer is used 
  // for right side execution
  Node *curr_left = node;
  Node *curr_right = node;

  while (curr_left != NULL || 
         curr_right != NULL || 
         LeftList.size() > 0 && 
         RightList.size() > 0)
  {
    // Storing the left side 
    // values into LeftList
    // till leaf node not found
    while (curr_left != NULL)
    {
      LeftList.push_back(curr_left);
      curr_left = curr_left -> left;
    }

    // Storing the right side 
    // values into RightList
    // till leaf node not found
    while (curr_right != NULL)
    {
      RightList.push_back(curr_right);
      curr_right = curr_right -> right;
    }

    // Last node of LeftList
    Node *LeftNode = 
          LeftList[LeftList.size() - 1];

    // Last node of RightList
    Node *RightNode = 
          RightList[RightList.size() - 1];

    int leftVal = LeftNode -> data;
    int rightVal = RightNode -> data;

    // To prevent repetition 
    // like 2, 6 and 6, 2
    if (leftVal >= rightVal)
      break;

    // Delete the last value of LeftList 
    // and make the execution to the 
    // right side
    if (leftVal + rightVal < tar)
    {
      LeftList.pop_back();
      curr_left = LeftNode -> right;
    }

    // Delete the last value of RightList
    // and make the execution to the left 
    // side
    else if (leftVal + rightVal > tar)
    {
      RightList.pop_back();
      curr_right = RightNode -> left;
    }

    // (left value + right value) = target
    // then print the left value and right value
    // Delete the last value of left and right list
    // and make the left execution to right side
    // and right side execution to left side
    else
    {
      cout << LeftNode -> data << " " << 
              RightNode -> data << endl;

      RightList.pop_back();
      LeftList.pop_back();
      curr_left = LeftNode -> right;
      curr_right = RightNode -> left;
    }
  }
}

// Driver code
int main()
{
  Node *root = NULL;
  root  = AddNode(root, 2);
  root = AddNode(root, 6);
  root = AddNode(root, 5);
  root = AddNode(root, 3);
  root = AddNode(root, 4);
  root = AddNode(root, 1);
  root = AddNode(root, 7);
  int sum = 8;
  TargetPair(root, sum);
}

// This code is contributed by Rutvik_56

#include <bits/stdc++.h>
using namespace std;

struct TreeNode
{
    int data;
    TreeNode *right;
    TreeNode *left;
    TreeNode(int data)
    {
        this->data = data;
        this->right = NULL;
        this->left = NULL;
    }
};
TreeNode *insertNode(int data, TreeNode *root)
{
    if (root == NULL)
    {
        TreeNode *node = new TreeNode(data);
        return node;
    }
    else if (data > root->data)
    {
        root->right = insertNode(data, root->right);
    }
    else if (data <= root->data)
    {
        root->left = insertNode(data, root->left);
    }
    return root;
}
// The idea used here is same as the two pointer algorithm for find pair with target sum in O(n) time

// 1. Create Two stacks
//     i) for inorder
//     ii) for revInorder
// 2. Now populating one by one from each stack
// 3.
//     i) if sum == k we add to the sum and make find1 and find2 to false to get new elements
//     ii) if sum < k we add to the sum and make find1 to false.
//     iii) if sum == k we add to the sum and make find2 to false.
// 4. breaking condition when element of curr1 > curr2

void allPairs(TreeNode *root, int k)
{
    stack<TreeNode *> s1; //inorder
    stack<TreeNode *> s2; // revInorder

    TreeNode *root1 = root, *root2 = root;
    TreeNode *curr1 = NULL, *curr2 = NULL;

    bool find1 = false, find2 = false; //markers to get new elements

    while (1)
    {
        // standard code for iterative inorder traversal using stack approach
        if (find1 == false)
        {
            while (root1 != NULL)
            {
                s1.push(root1);
                root1 = root1->left;
            }
            curr1 = s1.top();
            s1.pop();
            root1 = curr1->right;
            find1 = true;
        }
        // standard code for iterative reverse inorder traversal using stack approach
        if (find2 == false)
        {
            while (root2 != NULL)
            {
                s2.push(root2);
                root2 = root2->right;
            }
            curr2 = s2.top();
            s2.pop();
            root2 = curr2->left;
            find2 = true;
        }
        // breaking condition
        if (curr1->data >= curr2->data)
        {
            break;
        }
        // means we need next elements so make find1 and find2 to  false to get next elements
        if (curr1->data + curr2->data == k)
        {
            cout << curr1->data << " " << curr2->data << "\n";
            find1 = false;
            find2 = false;
        }
        // means we need greater element so make find1 to false to get next greater
        else if (curr1->data + curr2->data < k)
        {
            find1 = false;
        }
        // means we need smaller element so make find2 to false to get next smaller
        else //if (curr1->data + curr2->data > k)
        {
            find2 = false;
        }
    }
}

int main()
{
    TreeNode *root = NULL;

    int n = 11;
    int tree[] = {3, 1, 7, 0, 2, 5, 10, 4, 6, 9, 8};
    for (int i = 0; i < 11; i++)
    {
        root = insertNode(tree[i], root);
    }
    allPairs(root, 10);
}