Skip to content

# 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
Recommended Articles
Page :