Linked List on Jiang Yi(姜祎)'s Homepage

2487. Remove Nodes From Linked List

Mon, 06 May 2024 19:47:28 +0800

Given a linked list, we are required to remove some nodes, such that for each node in the result linked list, the value of the node is the greatest from the node to the end of the linked list.

Intuition

We construct the result linked list from right to left, that is, the last node in the linked list is kept, then the pointer goes from right to left util there is a node with greater value. This process can be done via post traversal as tree.

Complexity

Time complexity: iterate the list once.
$$O(n)$$
Space complexity: use a set to store numbers.
$$O(n)$$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


/**
 * Definition for singly-linked list.
 * struct ListNode {
 * int val;
 * ListNode *next;
 * ListNode() : val(0), next(nullptr) {}
 * ListNode(int x) : val(x), next(nullptr) {}
 * ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
 void reverse_traversal(ListNode* head, stack<int> &s) {
 if (!head) return;
 reverse_traversal(head->next, s);
 if (s.empty() || head->val >= s.top()) {
 s.push(head->val);
 }
 }

 ListNode* removeNodes(ListNode* head) {
 stack<int> s;
 reverse_traversal(head, s);
 ListNode* dummyhead = new ListNode(0, nullptr);
 ListNode* cur = dummyhead;
 while (!s.empty()) {
 cur->next = new ListNode(s.top(), nullptr);
 cur = cur->next;
 s.pop();
 }
 return dummyhead->next;
 }
};
``

# References
- [Leetcode](https://leetcode.com/problems/remove-nodes-from-linked-list/description/)

2816. Double a Number Represented as a Linked List

Mon, 06 May 2024 19:47:28 +0800

Given a linked list representing a non-negative integer, we are required to double this integer and convert it back to a linked list.

Intuition

We can just simulate the process, that is:

Retrieve the integer represented by the linked list
Double the integer
Construct the result linked list from the result integer.

Approach

We can just simulate the process as above. However, if the integer is very large, retrieve the integer may cause overflow. To simplify this process, we can use a stack to store the digits of the original integer, then we double the integer by operating on the top of the stack.

In each step, we pop an element from the stack, doubling it and adding it with the carry digit. Then we construct the result linked list with inserting the new node in the front of the head.

Complexity

Time complexity: iterate all digits twice.
$$O(n)$$
Space complexity: store the result linked list.
$$O(n)$$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


/**
 * Definition for singly-linked list.
 * struct ListNode {
 * int val;
 * ListNode *next;
 * ListNode() : val(0), next(nullptr) {}
 * ListNode(int x) : val(x), next(nullptr) {}
 * ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
 ListNode* doubleIt(ListNode* head) {
 stack<int> s;
 ListNode* cur = head;
 while (cur) {
 s.push(cur->val);
 cur = cur->next;
 }
 int carry = 0;
 while (!s.empty()) {
 int num = s.top() * 2 + carry;
 ListNode* pre = new ListNode(num % 10, cur);
 carry = num / 10;
 cur = pre;
 s.pop();
 }
 if (carry) {
 ListNode* pre = new ListNode(carry, cur);
 cur = pre;
 }
 return cur;
 }
};

References

Leetcode

237. Delete Node in a Linked List

Sun, 05 May 2024 20:13:45 +0800

Given a linked list and the node to be deleted, delete the node without accessing the head of the linked list

Intuition

This deletion is same as deleting a node from an array.

Approach

We use two pointers, pre and node to represent the previous and current node of the linked list, and we update the value of pre and node at each iteration. Finally, we delete the last node in the linked list.

Complexity

Time complexity: iterate the linked list once.
$$O(n)$$
Space complexity: no extra space needed.
$$O(1)$$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


/**
 * Definition for singly-linked list.
 * struct ListNode {
 * int val;
 * ListNode *next;
 * ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
 void deleteNode(ListNode* node) {
 ListNode* pre = nullptr;
 while (node->next) {
 node->val = node->next->val;
 pre = node;
 node = node->next;
 }
 pre->next = nullptr;
 }
};

References

Leetcode