# 1, Problem summary ## 2.1LeetCode: 2. Add two numbers

### (1) Problem description

Here you are   A non empty linked list that represents two non negative integers. Each of these numbers is based on   Reverse order   And each node can only store   One   Number.

You can assume that neither of these numbers will be 0 except the number 0   start.

Example 1:

Input: l1 = [2,4,3], l2 = [5,6,4]
Output: [7,0,8]
Explanation: 342 + 465 = 807
Example 2:

Input: l1 = , l2 = 
Output: 
Example 3:

Input: L1 = [9,9,9,9,9,9], L2 = [9,9,9]
Output: [8,9,9,9,0,0,1]

### (2) Problem analysis

This problem can define an auxiliary pointer. When the linked list is not NULL, define an integer t and add the values of two nodes respectively. Finally, divide and remainder are used to obtain the linked list.

### (3) Code implementation

```/**
* public class ListNode {
*     int val;
*     ListNode next;
*     ListNode() {}
*     ListNode(int val) { this.val = val; }
*     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ListNode dummy=new ListNode(-1);
ListNode pre=dummy;
int t=0;
while(t!=0||l1!=null||l2!=null){
if(l1!=null){
t+=l1.val;
l1=l1.next;
}
if(l2!=null){
t+=l2.val;
l2=l2.next;
}
pre.next=new ListNode(t%10);
pre=pre.next;
t=t/10;
}
return dummy.next;
}
}```

### (1) Title Description:

Example 1:

Output: [1,2,3,4]
Example 2:

Output: [- 1,0,3,4,5]
Example 3:

Output: []

### (3) Topic analysis

Before doing this problem, you can first look at the problem of merging two linked lists, so this idea can think in the direction of merging. Dividing a linked list into two linked lists and doing it according to the method of merging two linked lists can solve the problem. When using recursion in this problem, don't forget the end condition of recursion.

### (4) Code implementation

```/**
* public class ListNode {
*     int val;
*     ListNode next;
*     ListNode() {}
*     ListNode(int val) { this.val = val; }
*     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
}

public ListNode sortList(ListNode head, ListNode tail) {
}
while(fast!=tail){
slow=slow.next;
fast=fast.next;
if(fast!=tail){
fast=fast.next;
}
}
ListNode mid=slow;
ListNode list2 = sortList(mid,tail);
ListNode sorted=merge(list1,list2);
return sorted;
}
while(temp1!=null&&temp2!=null){
if(temp1.val<=temp2.val){
temp.next=temp1;
temp1=temp1.next;
}else{
temp.next=temp2;
temp2=temp2.next;
}
temp=temp.next;
}
if(temp1!=null){
temp.next=temp1;
}else if(temp2!=null){
temp.next=temp2;
}
}
}```

### (1) Title Description

k   Is a positive integer whose value is less than or equal to the length of the linked list.

If the total number of nodes is not   k   If it is an integer multiple of, please keep the last remaining nodes in the original order.

Can you design an algorithm that uses only constant extra space to solve this problem?
You can't just change the value inside the node, but you need to actually exchange nodes.

Example 1:

Input: head = [1,2,3,4,5], k = 2
Output: [2,1,4,3,5]
Example 2:

Input: head = [1,2,3,4,5], k = 3
Output: [3,2,1,4,5]
Example 3:

Input: head = [1,2,3,4,5], k = 1
Output: [1,2,3,4,5]
Example 4:

Input: head = , k = 1
Output: 

### (2) Topic analysis:

Before doing this problem, you should first reverse the linked list. This problem mainly uses a for loop to K nodes on the basis of reversing the linked list, and then reverse. If there are less than k left in the linked list, it will not be reversed. Here, the main attention is to the disconnection and connection of the linked list.

### (3) Code implementation

```/**
* 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 temp=NULL;
while(cur!=nullptr){
ListNode* temp1=cur.next;
cur.next=temp;
temp=cur;
cur=temp1;
}
return temp;
}
ListNode* reverseKGroup(ListNode* head, int k) {
ListNode* dummy=new ListNode(0);
ListNode* curr=dummy;
ListNode* tail=dummy;
ListNode* start,next;
while(tail.next!=null){
for(int i=0;i<k&&tail!=null;i++){
tail=tail.next;
}
if(tail==nullptr){
break;
}
next=tail->next;
start=pre->next;
tail->next=NULL;
pre->next=reverse(start);
start->next=next;
pre=start;
tail=pre;
}
return curr->next;
};```

### (1) Problem Description:

Give you two non empty linked lists to represent two non negative integers. The highest digit is at the beginning of the linked list. Each of their nodes stores only one digit. Adding these two numbers will return a new linked list.

You can assume that neither number starts with zero except the number 0.

Example 1:

Input: l1 = [7,2,4,3], l2 = [5,6,4]
Output: [7,8,0,7]
Example 2:

Input: l1 = [2,4,3], l2 = [5,6,4]
Output: [8,0,7]
Example 3:

Input: l1 = , l2 = 
Output: 

### (2) Problem analysis

Such reverse order problems are generally solved by stack. Create two stacks and put the two linked lists into the stack respectively. Finally, if the stack is not empty, pop up the elements, add them, and use division or remainder to obtain the reverse order linked list

### (3) Code implementation

```/**
* 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* addTwoNumbers(ListNode* l1, ListNode* l2) {
stack<int>s1,s2;
while(l1!=NULL){
s1.push(l1->val);
l1=l1->next;
}
while(l2!=NULL){
s2.push(l2->val);
l2=l2->next;
}
ListNode* ans=NULL;
int carry=0;
while(!s1.empty()||carry!=0||!s2.empty()){
int a = s1.empty() ? 0 : s1.top();
int b = s2.empty() ? 0 : s2.top();
if (!s1.empty()) s1.pop();
if (!s2.empty()) s2.pop();
int cur=a+b+carry;
carry=cur/10;
cur%=10;
ListNode* curnode=new ListNode(cur);
curnode->next=ans;
ans=curnode;
}
return ans;
}
};```

Posted by fingerprn on Sun, 10 Oct 2021 04:54:42 -0700