Count pairs in a binary tree whose sum is equal to a given value x

<script>

// Javascript implementation to count
// pairs in a binary tree whose sum is
// equal to given value x

// Structure of a node of a binary tree
class Node 
{
    constructor()
    {
        this.data = 0;
        this.left = null;
        this.right = null;
    }
};
var count = 0;

// Function to create and return a node
// of a binary tree
function getNode(data)
{
    
    // Allocate space for the node
    var new_node = new Node();

    // Put in the data
    new_node.data = data;
    new_node.left = new_node.right = null;
    return new_node;
}

// Returns true if a pair exists
// with given sum 'x'
function findPair(root, temp, x)
{
    
    // Base case
    if (root == null)
        return false;

    // Pair exists
    if (root != temp && 
       ((root.data + temp.data) == x))
        return true;

    // Find pair in left and right subtrees
    if (findPair(root.left, temp, x) || 
        findPair(root.right, temp, x))
        return true;

    // Pair does not exists with given sum 'x'
    return false;
}

// Function to count pairs in a binary tree
// whose sum is equal to given value x
function countPairs( root, curr, x)
{
    
    // If tree is empty
    if (curr == null)
        return;

    // Check whether pair exists for current node
    // 'curr' in the binary tree that sum up to 'x'
    if (findPair(root, curr, x))
        count++;

    // Recursively count pairs in left subtree
    countPairs(root, curr.left, x);

    // Recursively count pairs in right subtree
    countPairs(root, curr.right, x);
}

// Driver code

// Formation of binary tree
var root = getNode(5); /*     5     */
root.left = getNode(3); /*     / \     */
root.right = getNode(7); /* 3 7     */
root.left.left = getNode(2); /* / \ / \ */
root.left.right = getNode(4); /* 2 4 6 8 */
root.right.left = getNode(6);
root.right.right = getNode(8);
var x = 10;
count = 0;

countPairs(root, root, x);
count = parseInt(count / 2);

document.write("Count = " + count);

// This code is contributed by noob2000

</script>

<script>

      // JavaScript implementation to count pairs
      // in a binary tree whose sum is
      // equal to the given value x
      // structure of a node of a binary tree
      class Node {
        constructor() {
          this.data = 0;
          this.left = null;
          this.right = null;
        }
      }

      var head_ref = null;

      // function to create and return a node
      // of a binary tree
      function getNode(data) {
        // allocate space for the node
        var new_node = new Node();

        // put in the data
        new_node.data = data;
        new_node.left = new_node.right = null;
        return new_node;
      }

      // A simple recursive function to convert
      // a given Binary tree to Doubly Linked List
      // root -. Root of Binary Tree
      // head_ref -. Pointer to head node of
      // created doubly linked list
      function BToDLL(root) {
        // Base cases
        if (root == null) return;

        // Recursively convert right subtree
        BToDLL(root.right);

        // insert root into DLL
        root.right = head_ref;

        // Change left pointer of previous head
        if (head_ref != null) head_ref.left = root;

        // Change head of Doubly linked list
        head_ref = root;

        // Recursively convert left subtree
        BToDLL(root.left);
      }

      // Split a doubly linked list (DLL)
      // into 2 DLLs of half sizes
      function split(head) {
        var fast = head,
          slow = head;
        while (fast.right != null && fast.right.right != null) {
          fast = fast.right.right;
          slow = slow.right;
        }
        var temp = slow.right;
        slow.right = null;
        return temp;
      }

      // Function to merge two sorted
      // doubly linked lists
      function merge(first, second) {
        // If first linked list is empty
        if (first == null) return second;

        // If second linked list is empty
        if (second == null) return first;

        // Pick the smaller value
        if (first.data < second.data) {
          first.right = merge(first.right, second);
          first.right.left = first;
          first.left = null;
          return first;
        } else {
          second.right = merge(first, second.right);
          second.right.left = second;
          second.left = null;
          return second;
        }
      }

      // Function to do merge sort
      function mergeSort(head) {
        if (head == null || head.right == null) return head;
        var second = split(head);

        // Recur for left and right halves
        head = mergeSort(head);
        second = mergeSort(second);

        // Merge the two sorted halves
        return merge(head, second);
      }

      // Function to count pairs in a sorted
      // doubly linked list whose sum equal
      // to given value x
      function pairSum(head, x) {
        // Set two pointers, first to the beginning
        // of DLL and second to the end of DLL.
        var first = head;
        var second = head;
        while (second.right != null) second = second.right;

        var count = 0;

        // The loop terminates when either of
        // two pointers become null, or they
        // cross each other (second.right == first),
        // or they become same (first == second)
        while (
          first != null &&
          second != null &&
          first != second &&
          second.right != first
        ) {
          // pair found
          if (first.data + second.data == x) {
            count++;

            // move first in forward direction
            first = first.right;

            // move second in backward direction
            second = second.left;
          } else {
            if (first.data + second.data < x) first = first.right;
            else second = second.left;
          }
        }
        return count;
      }

      // function to count pairs in a binary tree
      // whose sum is equal to given value x
      function countPairs(root, x) {
        head_ref = null;

        // Convert binary tree to
        // doubly linked list
        BToDLL(root);

        // sort DLL
        head_ref = mergeSort(head_ref);

        // count pairs
        return pairSum(head_ref, x);
      }

      // Driver Code
      // formation of binary tree
      var root = getNode(5); /* 5 */
      root.left = getNode(3); /* / \ */
      root.right = getNode(7); /* 3 7 */
      root.left.left = getNode(2); /* / \ / \ */
      root.left.right = getNode(4); /* 2 4 6 8 */
      root.right.left = getNode(6);
      root.right.right = getNode(8);

      var x = 10;

      document.write("Count = " + countPairs(root, x));
    </script>

// THIS CODE IS CONTRIBUTED BY KIRTI AGARWAL
// JavaScript program to count pairs in binary tree whose sum is
// equal to a given value in x
class Node{
    constructor(value){
        this.value = value;
        this.left = null;
        this.right = null;
    }
}

// To store count of pairs
let count = 0;

// To store difference between
// current node's value and x,
// acts a lookup for counting pairs
let hash_t = new Set();

// The input, we need to count
// pairs whose sum is equal to x
let x = 10;

// Function to count number of pairs
// Does a pre-order traversal of the tree
function count_pairs_w_sum(root){
    if(root != null){
        if(hash_t.has(root.value)){
            count++;
        }
        else{
            hash_t.add(x-root.value);
        }
        
        count_pairs_w_sum(root.left);
        count_pairs_w_sum(root.right);
    }
}

// Entry point / Driver - Create a
// binary tree and call the function
// to get the count
let root = new Node(5);
root.left = new Node(3);
root.right = new Node(7);

root.left.left = new Node(2);
root.left.right = new Node(4);

root.right.left = new Node(6);
root.right.right = new Node(8);

count_pairs_w_sum(root);

console.log(count);