Subtract Two Numbers represented as Linked Lists

// C++ program to subtract smaller valued list from
// larger valued list and return result as a list.
#include <bits/stdc++.h>
using namespace std;

// A linked List Node
struct Node {
    int data;
    struct Node* next;
};

// A utility which creates Node.
Node* newNode(int data)
{
    Node* temp = new Node;
    temp->data = data;
    temp->next = NULL;
    return temp;
}

/* A utility function to get length
 of linked list */
int getLength(Node* Node)
{
    int size = 0;
    while (Node != NULL) {
        Node = Node->next;
        size++;
    }
    return size;
}

/* A Utility that padds zeros in front of the
   Node, with the given diff */
Node* paddZeros(Node* sNode, int diff)
{
    if (sNode == NULL)
        return NULL;

    Node* zHead = newNode(0);
    diff--;
    Node* temp = zHead;
    while (diff--) {
        temp->next = newNode(0);
        temp = temp->next;
    }
    temp->next = sNode;
    return zHead;
}

/* Subtract LinkedList Helper is a recursive function,
   move till the last Node,  and subtract the digits and
   create the Node and return the Node. If d1 < d2, we
   borrow the number from previous digit. */
Node* subtractLinkedListHelper(Node* l1, Node* l2,
                               bool& borrow)
{
    if (l1 == NULL && l2 == NULL && borrow == 0)
        return NULL;

    Node* previous = subtractLinkedListHelper(
        l1 ? l1->next : NULL, l2 ? l2->next : NULL, borrow);

    int d1 = l1->data;
    int d2 = l2->data;
    int sub = 0;

    /* if you have given the value to next digit then
       reduce the d1 by 1 */
    if (borrow) {
        d1--;
        borrow = false;
    }

    /* If d1 < d2, then borrow the number from previous
       digit. Add 10 to d1 and set borrow = true; */
    if (d1 < d2) {
        borrow = true;
        d1 = d1 + 10;
    }

    /* subtract the digits */
    sub = d1 - d2;

    /* Create a Node with sub value */
    Node* current = newNode(sub);

    /* Set the Next pointer as Previous */
    current->next = previous;

    return current;
}

/* This API subtracts two linked lists and returns the
   linked list which shall  have the subtracted result. */
Node* subtractLinkedList(Node* l1, Node* l2)
{
    // Base Case.
    if (l1 == NULL && l2 == NULL)
        return NULL;

    // In either of the case, get the lengths of both
    // Linked list.
    int len1 = getLength(l1);
    int len2 = getLength(l2);

    Node *lNode = NULL, *sNode = NULL;

    Node* temp1 = l1;
    Node* temp2 = l2;

    // If lengths differ, calculate the smaller Node
    // and padd zeros for smaller Node and ensure both
    // larger Node and smaller Node has equal length.
    if (len1 != len2) {
        lNode = len1 > len2 ? l1 : l2;
        sNode = len1 > len2 ? l2 : l1;
        sNode = paddZeros(sNode, abs(len1 - len2));
    }

    else {
        // If both list lengths are equal, then calculate
        // the larger and smaller list. If 5-6-7 & 5-6-8
        // are linked list, then walk through linked list
        // at last Node as 7 < 8, larger Node is 5-6-8
        // and smaller Node is 5-6-7.
        while (l1 && l2) {
            if (l1->data != l2->data) {
                lNode = l1->data > l2->data ? temp1 : temp2;
                sNode = l1->data > l2->data ? temp2 : temp1;
                break;
            }
            l1 = l1->next;
            l2 = l2->next;
        }
    }
    // If both lNode and sNode still have NULL value,
    // then this means that the  value of both of the given
    // linked lists is the same and hence we can directly
    // return a node with value 0.
    if (lNode == NULL && sNode == NULL) {
        return newNode(0);
    }
    // After calculating larger and smaller Node, call
    // subtractLinkedListHelper which returns the subtracted
    // linked list.
    bool borrow = false;
    return subtractLinkedListHelper(lNode, sNode, borrow);
}

/* A utility function to print linked list */
void printList(struct Node* Node)
{
    while (Node != NULL) {
        printf("%d ", Node->data);
        Node = Node->next;
    }
    printf("\n");
}

// Driver program to test above functions
int main()
{
    Node* head1 = newNode(1);
    head1->next = newNode(0);
    head1->next->next = newNode(0);

    Node* head2 = newNode(1);

    Node* result = subtractLinkedList(head1, head2);

    printList(result);

    return 0;
}

// This code is contributed by Sania Kumari Gupta (kriSania804)

#include <iostream>

class LinkedList {
private:
    struct Node {
        int data;
        Node* next;

        Node(int d) : data(d), next(nullptr) {}
    };

    Node* head;

    // Function to remove leading zeros from the linked list
    Node* removeLeadingZeros(Node* head) {
        while (head != nullptr && head->data == 0) {
            Node* temp = head;
            head = head->next;
            delete temp;
        }
        return head;
    }

    // Function to reverse a linked list
    Node* reverse(Node* head) {
        Node* prev = nullptr;
        Node* current = head;
        while (current != nullptr) {
            Node* next = current->next;
            current->next = prev;
            prev = current;
            current = next;
        }
        return prev;
    }

    // Function to determine which linked list represents the larger number
    Node* getLarger(Node* l1, Node* l2) {
        while (l1 != nullptr && l2 != nullptr) {
            if (l1->data > l2->data) {
                return l1;
            }
            else if (l2->data > l1->data) {
                return l2;
            }
            l1 = l1->next;
            l2 = l2->next;
        }
        // If both numbers are equal, return either linked list
        return l1 != nullptr ? l1 : l2;
    }

public:
    LinkedList() : head(nullptr) {}

    // Function to subtract two numbers represented as linked lists
    Node* subtract(Node* l1, Node* l2) {
        // Remove leading zeros
        l1 = removeLeadingZeros(l1);
        l2 = removeLeadingZeros(l2);

        // Reverse both linked lists
        l1 = reverse(l1);
        l2 = reverse(l2);

        // Determine which linked list represents the larger number
        Node* larger = getLarger(l1, l2);

        Node* result = nullptr;
        Node* prev = nullptr;
        int borrow = 0;

        // Traverse both linked lists simultaneously and subtract
        while (l1 != nullptr || l2 != nullptr) {
            int val1 = (l1 != nullptr) ? l1->data : 0;
            int val2 = (l2 != nullptr) ? l2->data : 0;

            int diff = val1 - val2 - borrow;

            if (diff < 0) {
                diff += 10;
                borrow = 1;
            }
            else {
                borrow = 0;
            }

            // Create a new node for the result
            Node* newNode = new Node(diff);

            if (result == nullptr) {
                result = newNode;
            }
            else {
                prev->next = newNode;
            }
            prev = newNode;

            // Move to the next nodes
            if (l1 != nullptr)
                l1 = l1->next;
            if (l2 != nullptr)
                l2 = l2->next;
        }

        // Reverse the result linked list
        result = reverse(result);

        return result;
    }

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

int main() {
    LinkedList list;

    // Example input
    LinkedList::Node* l1 = new LinkedList::Node(1);
    l1->next = new LinkedList::Node(0);
    l1->next->next = new LinkedList::Node(0);

    LinkedList::Node* l2 = new LinkedList::Node(1);

    std::cout << "Input Lists:" << std::endl;
    list.printList(l1);
    list.printList(l2);

    LinkedList::Node* result = list.subtract(l1, l2);

    std::cout << "Subtraction Result:" << std::endl;
    list.printList(result);

    // Clean up memory
    while (l1 != nullptr) {
        LinkedList::Node* temp = l1;
        l1 = l1->next;
        delete temp;
    }

    while (l2 != nullptr) {
        LinkedList::Node* temp = l2;
        l2 = l2->next;
        delete temp;
    }

    while (result != nullptr) {
        LinkedList::Node* temp = result;
        result = result->next;
        delete temp;
    }

    return 0;
}