# Subtract 1 from a number represented as Linked List

• Difficulty Level : Medium
• Last Updated : 22 Jun, 2021

Given the head of the linked list representing a positive integer, the task is to print the updated linked list after subtracting 1 from it.

Examples:

Input: LL = 1 -> 2 -> 3 -> 4
Output: 1 -> 2 -> 3 -> 3

Input: LL = 1 -> 2
Output: 1 -> 1

Approach: The given problem can be solved by using recursion. Follow the steps below to solve the problem:

• Define a function, say subtractOneUtil(Node *head) that takes the head of the linked list as the arguments and perform the following steps:
• Base Case: If the head node of the Linked List is NULL, then return -1 from that recursive call.
• Recursive Call: Recursively call for the next node of the linked list and let the value returned by this recursive call be borrow.
• If the value of borrow is -1 and the value of the head node is 0, then update the value of the head node to 9 and return -1 from the current recursive call.
• Otherwise, decrement the value of the head node by 1 and return 0 from the current recursive call.
• Subtract 1 from the Linked List by calling the above function as subtractOneUtil(head).
• If the update linked list has leading 0s, then move the head pointer.
• After completing the above steps, print the updated linked list as the resultant linked list.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Linked list Node``class` `Node {``public``:``    ``int` `data;``    ``Node* next;``};` `// Function to create a new node with``// the given data``Node* newNode(``int` `data)``{``    ``// Create a new node``    ``Node* new_node = ``new` `Node;``    ``new_node->data = data;``    ``new_node->next = NULL;` `    ``// Return the created node``    ``return` `new_node;``}` `// Recursive function to subtract 1``// from the linked list and update``// the node value accordingly``int` `subtractOneUtil(Node* head)``{` `    ``// Base Case``    ``if` `(head == NULL)``        ``return` `-1;` `    ``// Recursively call for the next``    ``// node of the head``    ``int` `borrow = subtractOneUtil(``        ``head->next);` `    ``// If there is a borrow``    ``if` `(borrow == -1) {` `        ``// If the head data is 0, then``        ``// update it with 9 and return -1``        ``if` `(head->data == 0) {``            ``head->data = 9;``            ``return` `-1;``        ``}` `        ``// Otherwise, decrement head's``        ``// data by 1 and return 0``        ``else` `{``            ``head->data = head->data - 1;``            ``return` `0;``        ``}``    ``}` `    ``// Otherwise, return 0``    ``else` `{``        ``return` `0;``    ``}``}` `// Function to subtract 1 from the given``// Linked List representation of number``Node* subtractOne(Node* head)``{` `    ``// Recursively subtract 1 from``    ``// the Linked List``    ``subtractOneUtil(head);` `    ``// Increment the head pointer``    ``// if there are any leading zeros``    ``while` `(head and head->next``           ``and head->data == 0) {``        ``head = head->next;``    ``}` `    ``return` `head;``}` `// Function to print a linked list``void` `printList(Node* node)``{``    ``// Iterate until node is NULL``    ``while` `(node != NULL) {``        ``cout << node->data;``        ``node = node->next;``    ``}``    ``cout << endl;``}` `// Driver Code``int` `main()``{``    ``Node* head = newNode(1);``    ``head->next = newNode(0);``    ``head->next->next = newNode(0);``    ``head->next->next->next = newNode(0);` `    ``cout << ``"List is "``;``    ``printList(head);` `    ``head = subtractOne(head);` `    ``cout << ``"Resultant list is "``;``    ``printList(head);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{` `// Linked list Node``static` `class` `Node``{``    ``int` `data;``    ``Node next;``};` `// Function to create a new node with``// the given data``static` `Node newNode(``int` `data)``{``    ` `    ``// Create a new node``    ``Node new_node = ``new` `Node();``    ``new_node.data = data;``    ``new_node.next = ``null``;` `    ``// Return the created node``    ``return` `new_node;``}` `// Recursive function to subtract 1``// from the linked list and update``// the node value accordingly``static`  `int` `subtractOneUtil(Node head)``{` `    ``// Base Case``    ``if` `(head == ``null``)``        ``return` `-``1``;` `    ``// Recursively call for the next``    ``// node of the head``    ``int` `borrow = subtractOneUtil(``        ``head.next);` `    ``// If there is a borrow``    ``if` `(borrow == -``1``)``    ``{``        ` `        ``// If the head data is 0, then``        ``// update it with 9 and return -1``        ``if` `(head.data == ``0``)``        ``{``            ``head.data = ``9``;``            ``return` `-``1``;``        ``}` `        ``// Otherwise, decrement head's``        ``// data by 1 and return 0``        ``else``        ``{``            ``head.data = head.data - ``1``;``            ``return` `0``;``        ``}``    ``}` `    ``// Otherwise, return 0``    ``else``    ``{``        ``return` `0``;``    ``}``}` `// Function to subtract 1 from the given``// Linked List representation of number``static` `Node subtractOne(Node head)``{` `    ``// Recursively subtract 1 from``    ``// the Linked List``    ``subtractOneUtil(head);` `    ``// Increment the head pointer``    ``// if there are any leading zeros``    ``while` `(head != ``null` `&& head.next != ``null` `&&``           ``head.data == ``0``)``    ``{``        ``head = head.next;``    ``}``    ``return` `head;``}` `// Function to print a linked list``static` `void` `printList(Node node)``{``    ` `    ``// Iterate until node is null``    ``while` `(node != ``null``)``    ``{``        ``System.out.print(node.data);``        ``node = node.next;``    ``}``    ``System.out.println();``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``Node head = newNode(``1``);``    ``head.next = newNode(``0``);``    ``head.next.next = newNode(``0``);``    ``head.next.next.next = newNode(``0``);` `    ``System.out.print(``"List is "``);``    ``printList(head);` `    ``head = subtractOne(head);` `    ``System.out.print(``"Resultant list is "``);``    ``printList(head);``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program for the above approach` `# Linked list Node``class` `Node:``    ` `    ``def` `__init__(``self``, d):``        ` `        ``self``.data ``=` `d``        ``self``.``next` `=` `None` `# Recursive function to subtract 1``# from the linked list and update``# the node value accordingly``def` `subtractOneUtil(head):``    ` `    ``# Base Case``    ``if` `(head ``=``=` `None``):``        ``return` `-``1``        ` `    ``# Recursively call for the next``    ``# node of the head``    ``borrow ``=` `subtractOneUtil(head.``next``)``    ` `    ``# If there is a borrow``    ``if` `(borrow ``=``=` `-``1``):``        ` `        ``# If the head data is 0, then``        ``# update it with 9 and return -1``        ``if` `(head.data ``=``=` `0``):``            ``head.data ``=` `9``            ``return` `-``1``            ` `        ``# Otherwise, decrement head's``        ``# data by 1 and return 0``        ``else``:``            ``head.data ``=` `head.data ``-` `1``            ``return` `0``            ` `    ``# Otherwise, return 0``    ``else``:``        ``return` `0` `# Function to subtract 1 from the given``# Linked List representation of number``def` `subtractOne(head):` `    ``# Recursively subtract 1 from``    ``# the Linked List``    ``subtractOneUtil(head)` `    ``# Increment the head pointer``    ``# if there are any leading zeros``    ``while` `(head ``and` `head.``next` `and``           ``head.data ``=``=` `0``):``        ``head ``=` `head.``next` `    ``return` `head` `# Function to pra linked list``def` `printList(node):``    ` `    ``# Iterate until node is None``    ``while` `(node !``=` `None``):``        ``print``(node.data, end ``=` `"")``        ``node ``=` `node.``next``        ` `    ``print``()` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``head ``=` `Node(``1``)``    ``head.``next` `=` `Node(``0``)``    ``head.``next``.``next` `=` `Node(``0``)``    ``head.``next``.``next``.``next` `=` `Node(``0``)` `    ``print``(``"List is "``, end ``=` `"")``    ``printList(head)` `    ``head ``=` `subtractOne(head)` `    ``print``(``"Resultant list is "``, end ``=` `"")``    ``printList(head)` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Linked list Node``class` `Node``{``    ``public` `int` `data;``    ``public` `Node next;``};` `// Function to create a new node with``// the given data``static` `Node newNode(``int` `data)``{``    ` `    ``// Create a new node``    ``Node new_node = ``new` `Node();``    ``new_node.data = data;``    ``new_node.next = ``null``;` `    ``// Return the created node``    ``return` `new_node;``}` `// Recursive function to subtract 1``// from the linked list and update``// the node value accordingly``static`  `int` `subtractOneUtil(Node head)``{` `    ``// Base Case``    ``if` `(head == ``null``)``        ``return` `-1;` `    ``// Recursively call for the next``    ``// node of the head``    ``int` `borrow = subtractOneUtil(``        ``head.next);` `    ``// If there is a borrow``    ``if` `(borrow == -1)``    ``{``        ` `        ``// If the head data is 0, then``        ``// update it with 9 and return -1``        ``if` `(head.data == 0)``        ``{``            ``head.data = 9;``            ``return` `-1;``        ``}` `        ``// Otherwise, decrement head's``        ``// data by 1 and return 0``        ``else``        ``{``            ``head.data = head.data - 1;``            ``return` `0;``        ``}``    ``}` `    ``// Otherwise, return 0``    ``else``    ``{``        ``return` `0;``    ``}``}` `// Function to subtract 1 from the given``// Linked List representation of number``static` `Node subtractOne(Node head)``{` `    ``// Recursively subtract 1 from``    ``// the Linked List``    ``subtractOneUtil(head);` `    ``// Increment the head pointer``    ``// if there are any leading zeros``    ``while` `(head != ``null` `&& head.next != ``null` `&&``           ``head.data == 0)``    ``{``        ``head = head.next;``    ``}``    ``return` `head;``}` `// Function to print a linked list``static` `void` `printList(Node node)``{``    ` `    ``// Iterate until node is null``    ``while` `(node != ``null``)``    ``{``        ``Console.Write(node.data);``        ``node = node.next;``    ``}``    ``Console.WriteLine();``}` `// Driver Code``public` `static` `void` `Main()``{``    ``Node head = newNode(1);``    ``head.next = newNode(0);``    ``head.next.next = newNode(0);``    ``head.next.next.next = newNode(0);` `    ``Console.Write(``"List is "``);``    ``printList(head);` `    ``head = subtractOne(head);` `    ``Console.Write(``"Resultant list is "``);``    ``printList(head);``}``}` `// This code is contributed by SURENDRA_GANGWAR`

## Javascript

 ``

Output:

```List is 1000
Resultant list is 999```

Time Complexity: O(N), N is the length of the given linked list.
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up