Add Two Numbers Represented as Linked List in DSA C - Build from Scratch

Add Two Numbers Represented as Linked List

📖 Scenario: You are working on a simple calculator app that adds two numbers. These numbers are stored in reverse order in linked lists, where each node contains a single digit. Your task is to add these two numbers and return the sum as a linked list in the same reversed order.

🎯 Goal: Build a program that creates two linked lists representing numbers, adds them digit by digit, and prints the resulting linked list showing the sum.

📋 What You'll Learn

Create two linked lists representing the numbers 342 and 465 in reverse order

Create a variable to hold the carry during addition

Write the logic to add the two numbers digit by digit using linked lists

Print the resulting linked list showing the sum

💡 Why This Matters

🌍 Real World

Adding large numbers digit by digit is useful in calculators and financial software where numbers can be very large and stored as linked lists.

💼 Career

Understanding linked list operations and digit-wise addition is important for software engineers working on low-level data manipulation, embedded systems, or interview coding challenges.

1

Create two linked lists representing numbers

Create a linked list node struct called Node with an int data and a Node* next. Then create two linked lists called l1 and l2 representing the numbers 342 and 465 in reverse order. For l1, create nodes with data 2, 4, 3. For l2, create nodes with data 5, 6, 4. Link the nodes properly.

DSA C

// Define struct Node
// Create linked list l1 with nodes 2 -> 4 -> 3
// Create linked list l2 with nodes 5 -> 6 -> 4
// Your code here

Hint

Remember to create each node with malloc and set the data and next fields properly.

2

Create a carry variable for addition

Create an integer variable called carry and set it to 0. Also create a pointer Node* result initialized to NULL to hold the result linked list. Create a pointer Node* tail initialized to NULL to track the last node in the result list.

DSA C

#include 
#include 

typedef struct Node {
    int data;
    struct Node* next;
} Node;

int main() {
    Node* l1 = malloc(sizeof(Node));
    l1->data = 2;
    l1->next = malloc(sizeof(Node));
    l1->next->data = 4;
    l1->next->next = malloc(sizeof(Node));
    l1->next->next->data = 3;
    l1->next->next->next = NULL;

    Node* l2 = malloc(sizeof(Node));
    l2->data = 5;
    l2->next = malloc(sizeof(Node));
    l2->next->data = 6;
    l2->next->next = malloc(sizeof(Node));
    l2->next->next->data = 4;
    l2->next->next->next = NULL;

    // Create carry and result pointers
    // Your code here

    return 0;
}

Hint

Use int carry = 0; and initialize Node* result = NULL; and Node* tail = NULL;.

3

Add the two numbers digit by digit

Write a while loop that continues as long as l1 is not NULL or l2 is not NULL or carry is not zero. Inside the loop, get the digit from l1 and l2 if they are not NULL, else use 0. Calculate the sum of these digits plus carry. Update carry to sum divided by 10. Create a new node with data equal to sum modulo 10. Append this new node to the result linked list. Move l1 and l2 to their next nodes if they are not NULL.

DSA C

#include 
#include 

typedef struct Node {
    int data;
    struct Node* next;
} Node;

int main() {
    Node* l1 = malloc(sizeof(Node));
    l1->data = 2;
    l1->next = malloc(sizeof(Node));
    l1->next->data = 4;
    l1->next->next = malloc(sizeof(Node));
    l1->next->next->data = 3;
    l1->next->next->next = NULL;

    Node* l2 = malloc(sizeof(Node));
    l2->data = 5;
    l2->next = malloc(sizeof(Node));
    l2->next->data = 6;
    l2->next->next = malloc(sizeof(Node));
    l2->next->next->data = 4;
    l2->next->next->next = NULL;

    int carry = 0;
    Node* result = NULL;
    Node* tail = NULL;

    // Add digits and create result linked list
    // Your code here

    return 0;
}

Hint

Use a loop to add digits and carry. Create new nodes for the sum digits and link them to the result list.

4

Print the resulting linked list

Write a Node* pointer called current and set it to result. Use a while loop to traverse the result linked list. Inside the loop, print the data of the current node followed by -> . Move current to the next node. After the loop, print null to indicate the end of the list.

DSA C

#include 
#include 

typedef struct Node {
    int data;
    struct Node* next;
} Node;

int main() {
    Node* l1 = malloc(sizeof(Node));
    l1->data = 2;
    l1->next = malloc(sizeof(Node));
    l1->next->data = 4;
    l1->next->next = malloc(sizeof(Node));
    l1->next->next->data = 3;
    l1->next->next->next = NULL;

    Node* l2 = malloc(sizeof(Node));
    l2->data = 5;
    l2->next = malloc(sizeof(Node));
    l2->next->data = 6;
    l2->next->next = malloc(sizeof(Node));
    l2->next->next->data = 4;
    l2->next->next->next = NULL;

    int carry = 0;
    Node* result = NULL;
    Node* tail = NULL;

    while (l1 != NULL || l2 != NULL || carry != 0) {
        int val1 = (l1 != NULL) ? l1->data : 0;
        int val2 = (l2 != NULL) ? l2->data : 0;
        int sum = val1 + val2 + carry;
        carry = sum / 10;
        Node* newNode = malloc(sizeof(Node));
        newNode->data = sum % 10;
        newNode->next = NULL;

        if (result == NULL) {
            result = newNode;
            tail = newNode;
        } else {
            tail->next = newNode;
            tail = newNode;
        }

        if (l1 != NULL) l1 = l1->next;
        if (l2 != NULL) l2 = l2->next;
    }

    // Print the result linked list
    // Your code here

    return 0;
}

Hint

Traverse the result linked list and print each node's data followed by ' -> '. After the loop, print 'null'.