Skip to content
Related Articles

Related Articles

Improve Article

Linked List Pair Sum

  • Difficulty Level : Easy
  • Last Updated : 23 Jun, 2021

Given a linked list, and a number, check if their exist two numbers whose sum is equal to given number. If there exist two numbers, print them. If there are multiple answer, print any of them.
Examples: 

Input : 1 -> 2 -> 3 -> 4 -> 5 -> NULL 
        sum = 3
Output : Pair is (1, 2)

Input : 10 -> 12 -> 31 -> 42 -> 53 -> NULL 
        sum = 15
Output : NO PAIR EXIST

Method(Brute force) 
Iteratively check if their exist any pair or not 

C++




// CPP code to find the pair with given sum
#include <bits/stdc++.h>
using namespace std;
 
/* Link list node */
struct Node {
    int data;
    struct Node* next;
};
 
/* Given a reference (pointer to pointer)
    to the head of a list and an int,
    push a new node on the front
    of the list. */
void push(struct Node** head_ref, int new_data)
{
    /* allocate node */
    struct Node* new_node =
          (struct Node*)malloc(sizeof(struct Node));
 
    /* put in the data */
    new_node->data = new_data;
 
    /* link the old list off the new node */
    new_node->next = (*head_ref);
 
    /* move the head to point to the new node */
    (*head_ref) = new_node;
}
 
/* Takes head pointer of the linked list and sum*/
int check_pair_sum(struct Node* head, int sum)
{
    struct Node* p = head, *q;
    while (p != NULL) {
     
        q = p->next;
        while (q != NULL) {
 
           // check if both sum is equal to
           // given sum
           if ((p->data) + (q->data) == sum) {
               cout << p->data << " " << q->data;
               return true;
           }    
           q = q->next;         
        }
 
        p = p->next;
    }
 
    return 0;
}
 
/* Driver program to test above function */
int main()
{
    /* Start with the empty list */
    struct Node* head = NULL;
 
    /* Use push() to construct linked list*/
    push(&head, 1);
    push(&head, 4);
    push(&head, 1);
    push(&head, 12);
    push(&head, 1);
    push(&head, 18);
    push(&head, 47);
    push(&head, 16);
    push(&head, 12);
    push(&head, 14);
 
    /* function to print the result*/
    bool res = check_pair_sum(head, 26);
    if (res == false)
        cout << "NO PAIR EXIST";
 
    return 0;
}

Java




// Java code to find the pair with given sum
import java.util.*;
 
class GFG {
 
    /* Link list node */
    static class Node {
        int data;
        Node next;
    };
    static Node head;
 
    /* Given a reference (pointer to pointer)
        to the head of a list and an int,
        push a new node on the front
        of the list. */
    // Inserting node at the beginning
    static Node push(Node head_ref, int new_data)
    {
        /* allocate node */
        Node new_node = new Node();
 
        /* put in the data */
        new_node.data = new_data;
 
        /* link the old list to the new node */
        new_node.next = head_ref;
 
        /* move the head to point to the new node */
        head_ref = new_node;
        return head = head_ref;
    }
 
    /* Takes head pointer of the linked list and sum*/
    static boolean check_pair_sum(Node head, int sum)
    {
        Node p = head, q;
        while (p != null)
        {
            q = p.next;
            while (q != null)
            {
 
                // check if both sum is equal to
                // given sum
                if ((p.data) + (q.data) == sum)
                {
                    System.out.print(p.data + " " + q.data);
                    return true;
                }
                q = q.next;
            }
            p = p.next;
        }
        return false;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        /* Start with the empty list */
        head = null;
 
        /* Use push() to conlinked list*/
        push(head, 1);
        push(head, 4);
        push(head, 1);
        push(head, 12);
        push(head, 1);
        push(head, 18);
        push(head, 47);
        push(head, 16);
        push(head, 12);
        push(head, 14);
 
        /* function to print the result*/
        boolean res = check_pair_sum(head, 26);
        if (res == false)
            System.out.print("NO PAIR EXIST");
    }
}
 
// This code is contributed by 29AjayKumar

Python3




# Python3 program for finding the pair with given sum
import math
import sys
 
# Link list node #
 
 
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
# Given a reference (pointer to pointer) to the head
# of a list and an int, push a new node on the front
# of the list.
 
 
def push(head, data):
    if head == None:
        return Node(data)
 
    # allocate node
    temp = Node(data)
 
    # link the old list off the new node
    temp.next = head
 
    # move the head to point to the new node
    head = temp
    return head
 
# Takes head pointer of the linked list and sum
 
 
def check_pair_sum(head, _sum_):
    p = head
    q = None
    while(p):
        q = p.next
        while(q):
            if p.data+q.data == _sum_:
                print("{} {}".format(p.data, q.data))
                return True
            q = q.next
        p = p.next
    return False
 
 
# Driver program to test above function
if __name__ == '__main__':
 
    # Start with the empty list
    head = None
 
    # Use push() to construct linked list
    head = push(head, 1)
    head = push(head, 4)
    head = push(head, 1)
    head = push(head, 12)
    head = push(head, 1)
    head = push(head, 18)
    head = push(head, 47)
    head = push(head, 16)
    head = push(head, 12)
    head = push(head, 14)
 
    # function to print the result
    res = check_pair_sum(head, 26)
    if (res == False):
        print("NO PAIR EXIST")
 
# This code is contributed by Vikash Kumar 37

C#




// C# code to find the pair with given sum
using System;
 
class GFG {
 
    /* Link list node */
    public class Node {
        public int data;
        public Node next;
    };
    static Node head;
 
    /* Given a reference (pointer to pointer)
        to the head of a list and an int,
        push a new node on the front
        of the list. */
 
    // Inserting node at the beginning
    static Node push(Node head_ref, int new_data)
    {
        /* allocate node */
        Node new_node = new Node();
 
        /* put in the data */
        new_node.data = new_data;
 
        /* link the old list to the new node */
        new_node.next = head_ref;
 
        /* move the head to point to the new node */
        head_ref = new_node;
        return head = head_ref;
    }
 
    /* Takes head pointer of the linked list and sum*/
    static Boolean check_pair_sum(Node head, int sum)
    {
        Node p = head, q;
        while (p != null)
        {
            q = p.next;
            while (q != null)
            {
                // check if both sum is equal to
                // given sum
                if ((p.data) + (q.data) == sum)
                {
                    Console.Write(p.data + " " + q.data);
                    return true;
                }
                q = q.next;
            }
            p = p.next;
        }
        return false;
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        /* Start with the empty list */
        head = null;
 
        /* Use push() to conlinked list*/
        push(head, 1);
        push(head, 4);
        push(head, 1);
        push(head, 12);
        push(head, 1);
        push(head, 18);
        push(head, 47);
        push(head, 16);
        push(head, 12);
        push(head, 14);
 
        /* function to print the result*/
        Boolean res = check_pair_sum(head, 26);
        if (res == false)
            Console.Write("NO PAIR EXIST");
    }
}
 
// This code is contributed by Rajput-Ji

Javascript




<script>
 
// JavaScript code to find the pair with given sum
 
/* Link list node */
class Node {
 
    constructor()
    {
        this.data = 0;
        this.next = null;
    }
};
 
var head = null;
/* Given a reference (pointer to pointer)
    to the head of a list and an int,
    push a new node on the front
    of the list. */
// Inserting node at the beginning
function push(head_ref, new_data)
{
    /* allocate node */
    var new_node = new Node();
    /* put in the data */
    new_node.data = new_data;
    /* link the old list to the new node */
    new_node.next = head_ref;
    /* move the head to point to the new node */
    head_ref = new_node;
    return head = head_ref;
}
/* Takes head pointer of the linked list and sum*/
function check_pair_sum(head, sum)
{
    var p = head, q;
    while (p != null)
    {
        q = p.next;
        while (q != null)
        {
            // check if both sum is equal to
            // given sum
            if ((p.data) + (q.data) == sum)
            {
                document.write(p.data + " " + q.data);
                return true;
            }
            q = q.next;
        }
        p = p.next;
    }
    return false;
}
// Driver Code
/* Start with the empty list */
head = null;
/* Use push() to conlinked list*/
push(head, 1);
push(head, 4);
push(head, 1);
push(head, 12);
push(head, 1);
push(head, 18);
push(head, 47);
push(head, 16);
push(head, 12);
push(head, 14);
/* function to print the result*/
var res = check_pair_sum(head, 26);
if (res == false)
    document.write("NO PAIR EXIST");
 
</script>
Output
14 12

Time complexity: O(n*n)

Method 2 (using hashing) 
1. Take a hashtable and mark all element with zero 
2. Iteratively mark all the element as 1 in hashtable which are present in linked list 
3. Iteratively find sum-current element of linked list is present in hashtable or not



C++




// CPP program to for finding the pair with given sum
#include <bits/stdc++.h>
#define MAX 100000
using namespace std;
 
/* Link list node */
struct Node {
    int data;
    struct Node* next;
};
 
/* Given a reference (pointer to pointer) to the head
    of a list and an int, push a new node on the front
    of the list. */
void push(struct Node** head_ref, int new_data)
{
    /* allocate node */
    struct Node* new_node =
            (struct Node*)malloc(sizeof(struct Node));
 
    /* put in the data */
    new_node->data = new_data;
 
    /* link the old list off the new node */
    new_node->next = (*head_ref);
 
    /* move the head to point to the new node */
    (*head_ref) = new_node;
}
 
/* Takes head pointer of the linked list and sum*/
bool check_pair_sum(struct Node* head, int sum)
{
    unordered_set<int> s;
    
    struct Node* p = head;
    while (p != NULL) {
        int curr = p->data;
        if (s.find(sum - curr) != s.end())
        {
           cout << curr << " " << sum - curr;
           return true;
        }
        s.insert(p->data);
        p = p->next;
    }
 
    return false;
}
 
/* Driver program to test above function*/
int main()
{
    /* Start with the empty list */
    struct Node* head = NULL;
 
    /* Use push() to construct linked list */
    push(&head, 1);
    push(&head, 4);
    push(&head, 1);
    push(&head, 12);
    push(&head, 1);
    push(&head, 18);
    push(&head, 47);
    push(&head, 16);
    push(&head, 12);
    push(&head, 14);
 
    /* function to print the result*/
    bool res = check_pair_sum(head, 26);
    if (res == false)
        cout << "NO PAIR EXIST";
 
    return 0;
}

Java




// Java program for finding
// the pair with given sum
import java.util.*;
class GFG {
    static int MAX = 100000;
 
    /* Link list node */
    static class Node {
        int data;
        Node next;
    };
 
    static Node head;
 
    /* Given a reference (pointer to pointer)
    to the head of a list and an int,
    push a new node on the front of the list. */
    static void push(Node head_ref, int new_data)
    {
        /* allocate node */
        Node new_node = new Node();
 
        /* put in the data */
        new_node.data = new_data;
 
        /* link the old list off the new node */
        new_node.next = head_ref;
 
        /* move the head to point to the new node */
        head_ref = new_node;
        head = head_ref;
    }
 
    /* Takes head pointer of the linked list and sum*/
    static boolean check_pair_sum(Node head, int sum)
    {
        HashSet<Integer> s = new HashSet<Integer>();
 
        Node p = head;
        while (p != null)
        {
            int curr = p.data;
            if (s.contains(sum - curr))
            {
                System.out.print(curr + " " + (sum - curr));
                return true;
            }
            s.add(p.data);
            p = p.next;
        }
 
        return false;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
 
        /* Start with the empty list */
        head = null;
 
        /* Use push() to conlinked list */
        push(head, 1);
        push(head, 4);
        push(head, 1);
        push(head, 12);
        push(head, 1);
        push(head, 18);
        push(head, 47);
        push(head, 16);
        push(head, 12);
        push(head, 14);
 
        /* function to print the result*/
        boolean res = check_pair_sum(head, 26);
        if (res == false)
            System.out.print("NO PAIR EXIST");
    }
}
 
// This code is contributed by PrinciRaj1992

Python3




# Python3 program to for finding the pair with given sum
MAX = 100000
 
''' Link list node '''
 
 
class Node:
 
    def __init__(self, data):
        self.data = data
        self.next = None
 
 
''' Given a reference (pointer to pointer) to the head
    of a list and an int, push a new node on the front
    of the list. '''
 
 
def push(head_ref, new_data):
    ''' allocate node '''
    new_node = Node(new_data)
 
    ''' put in the data '''
    new_node.data = new_data
 
    ''' link the old list off the new node '''
    new_node.next = (head_ref)
 
    ''' move the head to point to the new node '''
    (head_ref) = new_node
 
    return head_ref
 
 
''' Takes head pointer of the linked list and sum'''
 
 
def check_pair_sum(head, sum):
    s = set()
    p = head
    while (p != None):
        curr = p.data
        if((sum - curr) in s):
            print(curr, end=' ')
            print(sum-curr, end='')
            return True
        s.add(p.data)
        p = p.next
 
    return False
 
 
''' Driver program to test above function'''
if __name__ == '__main__':
 
    ''' Start with the empty list '''
    head = None
 
    ''' Use push() to construct linked list '''
    head = push(head, 1)
    head = push(head, 4)
    head = push(head, 1)
    head = push(head, 12)
    head = push(head, 1)
    head = push(head, 18)
    head = push(head, 47)
    head = push(head, 16)
    head = push(head, 12)
    head = push(head, 14)
 
    ''' function to print the result'''
    res = check_pair_sum(head, 26)
 
    if (res == False):
        print("NO PAIR EXIST")
 
# This code is contributed by rutvik_56

C#




// C# program for finding
// the pair with given sum
using System;
using System.Collections.Generic;
 
class GFG {
    static int MAX = 100000;
 
    /* Link list node */
    public class Node {
        public int data;
        public Node next;
    };
 
    static Node head;
 
    /* Given a reference (pointer to pointer)
    to the head of a list and an int,
    push a new node on the front of the list. */
    static void push(Node head_ref, int new_data)
    {
        /* allocate node */
        Node new_node = new Node();
 
        /* put in the data */
        new_node.data = new_data;
 
        /* link the old list off the new node */
        new_node.next = head_ref;
 
        /* move the head to point to the new node */
        head_ref = new_node;
        head = head_ref;
    }
 
    /* Takes head pointer of the linked list and sum*/
    static Boolean check_pair_sum(Node head, int sum)
    {
        HashSet<int> s = new HashSet<int>();
 
        Node p = head;
        while (p != null)
        {
            int curr = p.data;
            if (s.Contains(sum - curr))
            {
                Console.Write(curr + " " + (sum - curr));
                return true;
            }
            s.Add(p.data);
            p = p.next;
        }
        return false;
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
 
        /* Start with the empty list */
        head = null;
 
        /* Use push() to conlinked list */
        push(head, 1);
        push(head, 4);
        push(head, 1);
        push(head, 12);
        push(head, 1);
        push(head, 18);
        push(head, 47);
        push(head, 16);
        push(head, 12);
        push(head, 14);
 
        /* function to print the result*/
        Boolean res = check_pair_sum(head, 26);
        if (res == false)
            Console.Write("NO PAIR EXIST");
    }
}
 
// This code is contributed by Princi Singh

Javascript




<script>
      // JavaScript program for finding
      // the pair with given sum
      const MAX = 100000;
 
      /* Link list node */
      class Node {
        constructor() {
          this.data = 0;
          this.next = null;
        }
      }
 
      var head = null;
 
      /* Given a reference (pointer to pointer)
    to the head of a list and an int,
    push a new node on the front of the list. */
      function push(head_ref, new_data) {
        /* allocate node */
        var new_node = new Node();
 
        /* put in the data */
        new_node.data = new_data;
 
        /* link the old list off the new node */
        new_node.next = head_ref;
 
        /* move the head to point to the new node */
        head_ref = new_node;
        head = head_ref;
      }
 
      /* Takes head pointer of the linked list and sum*/
      function check_pair_sum(head, sum) {
        var s = new Set();
 
        var p = head;
        while (p != null)
        {
          var curr = p.data;
          if (s.has(sum - curr))
          {
            document.write(curr + " " + (sum - curr));
            return true;
          }
          s.add(p.data);
          p = p.next;
        }
        return false;
      }
 
      // Driver Code
      /* Start with the empty list */
      head = null;
 
      /* Use push() to conlinked list */
      push(head, 1);
      push(head, 4);
      push(head, 1);
      push(head, 12);
      push(head, 1);
      push(head, 18);
      push(head, 47);
      push(head, 16);
      push(head, 12);
      push(head, 14);
 
      /* function to print the result*/
      var res = check_pair_sum(head, 26);
      if (res == false) document.write("NO PAIR EXIST");
       
      // This code is contributed by rdtank.
    </script>
Output
12 14

Time complexity: O(n) 
Auxiliary Space: O(n)

Method 3 (using recursion)

Traverse through each node and find if element Sum-(node->data) is available in remaining linked list or not. if Not, current node will not be a part of solution. Single traversal of list is needed and no additional space is required for this solution. Although we are using additional stack space for recursion.

C




// C++ implementation of the above approach
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
 
/* Link list node */
struct Node {
    int data;
    struct Node* next;
};
 
void push(struct Node** head_ref, int new_data)
{
    struct Node* new_node
        = (struct Node*)malloc(sizeof(struct Node));
    new_node->data = new_data;
    new_node->next = (*head_ref);
    (*head_ref) = new_node;
}
 
bool findElement(struct Node* head, int element)
{
    if (head == NULL)
    {
        return false;
    }
    else if (head->data == element)
    {
        return true;
    }
    return findElement(head->next, element);
}
 
bool check_pair_sum(struct Node* head, int sum)
{
    bool found = false;
    while (head != NULL)
    {
        found = findElement(head, sum - head->data);
        if (found == true)
        {
            printf("%d and %d \n", head->data,
                   sum - head->data);
            return found;
        }
        head = head->next;
    }
    return found;
}
 
// Driver Code
int main()
{
    /* Start with the empty list */
    struct Node* head = NULL;
     
    /* Use push() to construct linked list*/
    push(&head, 1);
    push(&head, 4);
    push(&head, 1);
    push(&head, 12);
    push(&head, 1);
    push(&head, 18);
    push(&head, 47);
    push(&head, 16);
    push(&head, 12);
    push(&head, 14);
    push(&head, 0);
 
    /* Function to print the result*/
    bool res = check_pair_sum(head, 26);
    if (res == false)
        printf("No pair found");
    return 0;
}
Output
0 and 47 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :