Open In App

Add number and its reverse represented by Linked List

Last Updated : 23 Mar, 2023
Comments
Improve
Suggest changes
Like Article
Like
Report

Given a number represented by a linked list, write a function that returns the sum of that number with its reverse form, and returns the resultant linked list.

Note: Avoid modifying the original linked list.

Examples:

Input: 1->2->3->4 
Output: 5->5->5->5
Explanation: 

Input list:      1 2 3 4
Reverse list:  + 4 3 2 1
resultant list:  5 5 5 5

Input: 4->7->3->6
Output: 1->1->1->1->0 
Explanation: 

Input list:        4 7 3 6
reverse list:    + 6 3 7 4
resultant list:  1 1 1 1 0

Approach: The approach to solve the problem of adding linked lists and its reverse can be divided into the following steps:

  • Make a copy of the given linked list: To avoid modifying the original linked list, a copy of it is created.
  • Reverse the linked list: The reversed linked list is obtained by iteratively changing the next pointer of each node to point to the previous node.
  • Add the linked list and its reverse: The two linked lists (original linked list and its reverse) are added digit by digit, starting from the least significant digit. A carry variable is maintained while adding the digits.
  • Reverse the result of the addition: The result of the addition, which is in reverse order, is reversed back to obtain the final result.
  • Print the resultant linked list: The final resultant linked list is printed.

Below is the implementation of this approach.

C++ 
// C++ code of above approach
#include <bits/stdc++.h>
using namespace std;

// Define the structure of a
// node in the linked list
struct Node {
    int data;
    struct Node* next;
    Node(int x)
    {
        data = x;
        next = NULL;
    }
};

// Function to return the
// reverse of a linked list
Node* reverseList(Node* head)
{
    Node* prev = NULL;
    Node* cur = head;
    Node* next_ = NULL;

    while (cur != NULL) {
        next_ = cur->next;
        cur->next = prev;
        prev = cur;
        cur = next_;
    }
    return prev;
}

// Function to return the sum of two
// linked lists
Node* addTwoLists(Node* l1, Node* l2)
{
    Node* dummy = new Node(0);
    Node* cur = dummy;
    int carry = 0;

    while (l1 != NULL || l2 != NULL) {
        int x = l1 ? l1->data : 0;
        int y = l2 ? l2->data : 0;
        int sum = carry + x + y;
        carry = sum / 10;
        cur->next = new Node(sum % 10);
        cur = cur->next;
        if (l1) {
            l1 = l1->next;
        }
        if (l2) {
            l2 = l2->next;
        }
    }
    if (carry > 0) {
        cur->next = new Node(carry);
    }
    return dummy->next;
}

// Function to print a linked list
void printList(Node* head)
{
    while (head != NULL) {
        cout << head->data << " ";
        head = head->next;
    }
    cout << endl;
}

// Function to create a copy of
// a linked list
Node* copyList(Node* head)
{
    Node* cur = head;
    Node* dummy = new Node(0);
    Node* copy = dummy;

    while (cur != NULL) {
        copy->next = new Node(cur->data);
        copy = copy->next;
        cur = cur->next;
    }
    return dummy->next;
}

// Driver Code
int main()
{

    // Example linked list:
    // 1 -> 2 -> 3 -> 4
    Node* head1 = new Node(1);
    head1->next = new Node(2);
    head1->next->next = new Node(3);
    head1->next->next->next = new Node(4);

    // Printing original linked list
    cout << "Original linked list : ";
    printList(head1);

    // Step1 - Make a copy of original
    // linked list
    Node* newList = copyList(head1);

    // Step2 - Reverse a linked list
    Node* head2 = reverseList(newList);

    // Printing reversed linked list
    cout << "Reversed linked list : ";
    printList(head2);

    // Step3 - Addition of a original
    // linked list and its reverse
    Node* addition = addTwoLists(head1, head2);

    // Step4 - Reverse a addition
    // Linked list
    Node* result = reverseList(addition);

    // Step5 - Print the resultant
    // linked list
    cout << "Resultant linked list : ";
    printList(result);

    return 0;
}
Java 
// Java code implementation for the above approach
import java.io.*;
import java.util.*;

// Define the structure of a node in the linked list
class Node {
  int data;
  Node next;
  Node(int x)
  {
    data = x;
    next = null;
  }
}

class GFG {

  // Function to return the reverse of a linked list
  static Node reverseList(Node head)
  {
    Node prev = null;
    Node cur = head;
    Node next_;
    while (cur != null) {
      next_ = cur.next;
      cur.next = prev;
      prev = cur;
      cur = next_;
    }
    return prev;
  }

  // Function to return the sum of two linked lists
  static Node addTwoLists(Node l1, Node l2)
  {
    Node dummy = new Node(0);
    Node cur = dummy;
    int carry = 0;

    while (l1 != null || l2 != null) {
      int x = l1 != null ? l1.data : 0;
      int y = l2 != null ? l2.data : 0;
      int sum = carry + x + y;
      carry = sum / 10;
      cur.next = new Node(sum % 10);
      cur = cur.next;
      if (l1 != null) {
        l1 = l1.next;
      }
      if (l2 != null) {
        l2 = l2.next;
      }
    }
    if (carry > 0) {
      cur.next = new Node(carry);
    }
    return dummy.next;
  }

  // Function to print a linked list
  static void printList(Node head)
  {
    while (head != null) {
      System.out.print(head.data + " ");
      head = head.next;
    }
    System.out.println();
  }

  // Function to create a copy of a linked list
  static Node copyList(Node head)
  {
    Node cur = head;
    Node dummy = new Node(0);
    Node copy = dummy;

    while (cur != null) {
      copy.next = new Node(cur.data);
      copy = copy.next;
      cur = cur.next;
    }
    return dummy.next;
  }

  public static void main(String[] args)
  {
    // Example linked list:
    // 1 -> 2 -> 3 -> 4
    Node head1 = new Node(1);
    head1.next = new Node(2);
    head1.next.next = new Node(3);
    head1.next.next.next = new Node(4);

    // Printing original linked list
    System.out.print("Original linked list : ");
    printList(head1);

    // Step1 - Make a copy of original linked list
    Node newList = copyList(head1);

    // Step2 - Reverse a linked list
    Node head2 = reverseList(newList);

    // Printing reversed linked list
    System.out.print("Reversed linked list : ");
    printList(head2);

    // Step3 - Addition of a original linked list and
    // its reverse
    Node addition = addTwoLists(head1, head2);

    // Step4 - Reverse a addition Linked list
    Node result = reverseList(addition);

    // Step5 - Print the resultant linked list
    System.out.print("Resultant linked list : ");
    printList(result);
  }
}

// This code is contributed by sankar
Python3 
# python code of above approach
# Define the structure of a
# node in the linked list


class Node:
    def __init__(self, x):
        self.data = x
        self.next = None

# Function to return the
# reverse of a linked list


def reverseList(head):
    prev = None
    cur = head
    next_ = None

    while cur is not None:
        next_ = cur.next
        cur.next = prev
        prev = cur
        cur = next_
    return prev

# Function to return the sum of two
# linked lists


def addTwoLists(l1, l2):
    dummy = Node(0)
    cur = dummy
    carry = 0

    while l1 is not None or l2 is not None:
        x = l1.data if l1 else 0
        y = l2.data if l2 else 0
        summ = carry + x + y
        carry = summ // 10
        cur.next = Node(summ % 10)
        cur = cur.next
        if l1:
            l1 = l1.next
        if l2:
            l2 = l2.next
    if carry > 0:
        cur.next = Node(carry)
    return dummy.next

# Function to print a linked list


def printList(head):
    while head is not None:
        print(head.data, end=" ")
        head = head.next
    print()

# Function to create a copy of
# a linked list


def copyList(head):
    cur = head
    dummy = Node(0)
    copy = dummy

    while cur is not None:
        copy.next = Node(cur.data)
        copy = copy.next
        cur = cur.next
    return dummy.next


# Driver Code
if __name__ == '__main__':

    # Example linked list:
    # 1 -> 2 -> 3 -> 4
    head1 = Node(1)
    head1.next = Node(2)
    head1.next.next = Node(3)
    head1.next.next.next = Node(4)

    # Printing original linked list
    print("Original linked list : ", end="")
    printList(head1)

    # Step1 - Make a copy of original
    # linked list
    newList = copyList(head1)

    # Step2 - Reverse a linked list
    head2 = reverseList(newList)

    # Printing reversed linked list
    print("Reversed linked list : ", end="")
    printList(head2)

    # Step3 - Addition of a original
    # linked list and its reverse
    addition = addTwoLists(head1, head2)

    # Step4 - Reverse a addition
    # Linked list
    result = reverseList(addition)

    # Step5 - Print the resultant
    # linked list
    print("Resultant linked list : ", end="")
    printList(result)
C# 
// C# code implementation for the above approach

using System;

// Define the structure of a node in the linked list
public class Node {
    public int data;
    public Node next;
    public Node(int x)
    {
        data = x;
        next = null;
    }
}

public class GFG {

    // Function to return the reverse of a linked list
    static Node reverseList(Node head)
    {
        Node prev = null;
        Node cur = head;
        Node next_;
        while (cur != null) {
            next_ = cur.next;
            cur.next = prev;
            prev = cur;
            cur = next_;
        }
        return prev;
    }

    // Function to return the sum of two linked lists
    static Node addTwoLists(Node l1, Node l2)
    {
        Node dummy = new Node(0);
        Node cur = dummy;
        int carry = 0;

        while (l1 != null || l2 != null) {
            int x = l1 != null ? l1.data : 0;
            int y = l2 != null ? l2.data : 0;
            int sum = carry + x + y;
            carry = sum / 10;
            cur.next = new Node(sum % 10);
            cur = cur.next;
            if (l1 != null) {
                l1 = l1.next;
            }
            if (l2 != null) {
                l2 = l2.next;
            }
        }
        if (carry > 0) {
            cur.next = new Node(carry);
        }
        return dummy.next;
    }

    // Function to print a linked list
    static void printList(Node head)
    {
        while (head != null) {
            Console.Write(head.data + " ");
            head = head.next;
        }
        Console.WriteLine();
    }

    // Function to create a copy of a linked list
    static Node copyList(Node head)
    {
        Node cur = head;
        Node dummy = new Node(0);
        Node copy = dummy;

        while (cur != null) {
            copy.next = new Node(cur.data);
            copy = copy.next;
            cur = cur.next;
        }
        return dummy.next;
    }

    static public void Main()
    {

        // Code
        // Example linked list:
        // 1 -> 2 -> 3 -> 4
        Node head1 = new Node(1);
        head1.next = new Node(2);
        head1.next.next = new Node(3);
        head1.next.next.next = new Node(4);

        // Printing original linked list
        Console.Write("Original linked list : ");
        printList(head1);

        // Step1 - Make a copy of original linked list
        Node newList = copyList(head1);

        // Step2 - Reverse a linked list
        Node head2 = reverseList(newList);

        // Printing reversed linked list
        Console.Write("Reversed linked list : ");
        printList(head2);

        // Step3 - Addition of a original linked list and
        // its reverse
        Node addition = addTwoLists(head1, head2);

        // Step4 - Reverse a addition Linked list
        Node result = reverseList(addition);

        // Step5 - Print the resultant linked list
        Console.Write("Resultant linked list : ");
        printList(result);
    }
}

// This code is contributed by karthik.
JavaScript 
// JavaScript code of above approach
// Define the structure of a
// node in the linked list

class Node {
constructor(x) {
this.data = x;
this.next = null;
}
}

// Function to return the
// reverse of a linked list

function reverseList(head) {
let prev = null;
let cur = head;
let next_ = null;
while (cur !== null) {
    next_ = cur.next;
    cur.next = prev;
    prev = cur;
    cur = next_;
}
return prev;
}

// Function to return the sum of two
// linked lists

function addTwoLists(l1, l2) {
let dummy = new Node(0);
let cur = dummy;
let carry = 0;
while (l1 !== null || l2 !== null) {
    let x = l1 ? l1.data : 0;
    let y = l2 ? l2.data : 0;
    let summ = carry + x + y;
    carry = Math.floor(summ / 10);
    cur.next = new Node(summ % 10);
    cur = cur.next;
    if (l1) {
        l1 = l1.next;
    }
    if (l2) {
        l2 = l2.next;
    }
}
if (carry > 0) {
    cur.next = new Node(carry);
}
return dummy.next;
}

// Function to print a linked list

function printList(head) {
while (head !== null) {
console.log(head.data, end=" ");
head = head.next;
}
console.log();
}

// Function to create a copy of
// a linked list

function copyList(head) {
let cur = head;
let dummy = new Node(0);
let copy = dummy;
while (cur !== null) {
    copy.next = new Node(cur.data);
    copy = copy.next;
    cur = cur.next;
}
return dummy.next;
}

// Driver Code
if (typeof require !== 'undefined' && require.main === module) {
    // Example linked list:
// 1 -> 2 -> 3 -> 4
let head1 = new Node(1);
head1.next = new Node(2);
head1.next.next = new Node(3);
head1.next.next.next = new Node(4);

// Printing original linked list
console.log("Original linked list : ");
printList(head1);

// Step1 - Make a copy of original
// linked list
let newList = copyList(head1);

// Step2 - Reverse a linked list
let head2 = reverseList(newList);

// Printing reversed linked list
console.log("Reversed linked list : ");
printList(head2);

// Step3 - Addition of a original
// linked list and its reverse
let addition = addTwoLists(head1, head2);

// Step4 - Reverse a addition
// Linked list
let result = reverseList(addition);

// Step5 - Print the resultant
// linked list
console.log("Resultant linked list : ");
printList(result);
}

//This code is contributed by shivamsharma215

Output
Original linked list : 1 2 3 4 
Reversed linked list : 4 3 2 1 
Resultant linked list : 5 5 5 5

Time complexity: O(max(m, n)), where m and n are the lengths of the linked lists being added.
Auxiliary Space: O(max(m, n)), as the length of the resultant linked list can be at most one more than the length of the longer linked list. The copyList and reverseList functions have a time complexity of O(n), where n is the length of the linked list.


Next Article
Add number and its reverse represented by Linked List
author
prasad264
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox