Subtraction in Linked List

Introduction:

Fundamental data structures in computer science and linked lists are utilized for a wide range of tasks, from designing dynamic data structures to resolving challenging issues. Subtraction is less frequently studied in the context of linked lists than addition and multiplication are. On the other hand, subtraction in linked lists can be a helpful tool for addressing certain issues and provides insightful knowledge about how data structures can be worked with. We shall examine the idea of subtraction in linked lists, its uses, and its implementation in this article.

Understanding Linked Lists:

It is crucial to comprehend linked lists in their whole before talking about subtraction in them. A linked list is a type of data structure made up of nodes, each of which has a reference to the node after it in the sequence as well as data. The head is the initial node, while the last node usually indicates that the list has ended by pointing to null. Because they are dynamic and provide quick additions and removals, linked lists are adaptable to a wide range of uses.

Subtraction in Linked Lists:

In linked lists, subtraction is the mathematical process of taking the values of the associated nodes in two linked lists and subtracting them to produce a new linked list that shows the outcome. The two linked lists must have the same length to carry out this operation, guaranteeing that every node in one list corresponds to every other node. Values reflecting the variations between the appropriate nodes in the original lists will be present in the linked list that is produced.

Applications of Subtraction in Linked Lists:

In linked lists, subtraction can be a useful tool in the following situations:

Numerical Operations: Linked lists can be used to represent numbers, and subtraction is a fundamental mathematical concept. By dividing huge numbers into smaller, more manageable parts, subtracting two linked lists can assist in performing arithmetic tasks.
Stock Market Analysis: Linked lists can be used to display historical stock prices in financial applications. To compute price changes and find trends, subtract two connected lists of stock prices on various dates.
Data Comparison: Linked lists can be used to represent the data pieces when comparing two datasets. Finding the differences and similarities between the two datasets can be aided by subtracting the corresponding items.

Implementation of Subtraction in Linked Lists:

To implement subtraction in linked lists, we can follow these steps:

Verify the Length: Make that the lengths of the two connected lists are equal. If not, add zeros to the beginning of the shorter list to make them equal in length.
Initialize Carry: To manage borrow, initialize a carry variable in a manner akin to manual subtraction.
Traverse and Subtract: Begin by moving from the last node to the first in the linked lists. Subtract the data values and the carry from the previous step for every pair of corresponding nodes. In the event of a negative result, borrowing is required, and the carry is adjusted appropriately.
Create Result List: To store the result, create a new linked list. Put every calculated value at the top of the list of results.
Handle Overflow: Look for any carry that remains after processing every node. Put the carry at the top of the result list if there is one.

Program:

#include <stdio.h>
#include <stdlib.h>
struct Node {
    int data;
    struct Node* next;
};
struct Node* createNode(int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
newNode->next = NULL;
    return newNode;
}
struct Node* subtractLinkedLists(struct Node* list1, struct Node* list2) {
    struct Node* result = NULL;
    struct Node* current = NULL;
    int borrow = 0;
    while (list1 != NULL && list2 != NULL) {
        int diff = list1->data - list2->data - borrow;
        if (diff < 0) {
            diff += 10; 
            borrow = 1;
        } else {
            borrow = 0;
        }
        struct Node* newNode = createNode(diff);
        if (result == NULL) {
            result = newNode;
            current = newNode;
        } else {
            current->next = newNode;
            current = newNode;
        }
        list1 = list1->next;
        list2 = list2->next;
    }
    while (list1 != NULL) {
        int diff = list1->data - borrow;
        if (diff < 0) {
            diff += 10;
            borrow = 1;
        } else {
            borrow = 0;
        }
        struct Node* newNode = createNode(diff);
        current->next = newNode;
        current = newNode;
        list1 = list1->next;
    }
    return result;
}
void displayList(struct Node* list) {
    struct Node* current = list;
    while (current != NULL) {
printf("%d ", current->data);
        current = current->next;
    }
printf("\n");
}
int main() {
    struct Node* list1 = createNode(8);
    list1->next = createNode(6);
    list1->next->next = createNode(15);
    struct Node* list2 = createNode(2);
    list2->next = createNode(13);
    list2->next->next = createNode(5);
    struct Node* result = subtractLinkedLists(list1, list2);
printf("Result of subtraction: ");
displayList(result);
    return 0;
}

Output:

Result of subtraction: 6 3 9

Complexity Analysis:

The results of the complexity analysis for subtraction in linked lists show that the operation has a linear temporal complexity of O(n) and a spatial complexity of O(n), where 'n' is the number of nodes in the input linked lists. This indicates that as linked lists get larger, so do the time and space needed for subtraction. The necessity to create the result list and traverse both linked lists while executing constant-time operations for every pair of nodes leads to the linear time complexity. The size of the result list, which equals the number of nodes in the input lists, largely determines the space complexity.These intricacies draw attention to the subtraction operation's efficiency in linked lists, which makes it a sensible option for applications combining data manipulation with dynamic data structures and numerical calculations.

Next TopicTRANSITIONS OF MATRIX

← prev next →