-
两数相加(2)
给你两个 非空 的链表,表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的,并且每个节点只能存储 一位 数字。请你将两个数相加,并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外,这两个数都不会以 0 开头。
思路:
- 定义头节点用于函数返回链表头指针
- 遍历结束条件
- 两链表长度不一致时如何处理
- 结束遍历后是否有进位位,若有则追加节点
//代码示例
/**
2. Definition for singly-linked list.
3. struct ListNode {
4. int val;
5. struct ListNode *next;
6. };
*/
struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2){
int carryBit = 0;
struct ListNode* returnListNode = NULL;
struct ListNode* currentListNode = (struct ListNode*)malloc(sizeof(struct ListNode));
currentListNode->next = NULL;
returnListNode = currentListNode;
while(l1 != NULL || l2 != NULL)
{
if(l1 == NULL || l2 == NULL){
if(l1 == NULL)
currentListNode->val = 0 + l2->val +carryBit;
if(l2 == NULL)
currentListNode->val = l1->val + 0 +carryBit;
}
else{
currentListNode->val = l1->val + l2->val +carryBit;
}
carryBit = currentListNode->val > 9 ? 1 : 0;
currentListNode->val = carryBit == 0 ? (currentListNode->val) : (currentListNode->val % 10);
if(l1)
l1 = (l1->next == NULL ? NULL:l1->next);
if(l2)
l2 = (l2->next == NULL ? NULL:l2->next);
if(l1 || l2){
currentListNode->next = (struct ListNode*)malloc(sizeof(struct ListNode));
currentListNode->next->next = NULL;
currentListNode->next->val = 0;
currentListNode = currentListNode->next;
}
}
if(carryBit){
currentListNode->next = (struct ListNode*)malloc(sizeof(struct ListNode));
currentListNode->next->next = NULL;
currentListNode->next->val = carryBit;
}
return returnListNode;
}
- 旋转链表(61)
给你一个链表的头节点 head ,旋转链表,将链表每个节点向右移动 k 个位置。思路:首先判断链表的长度,并且找到头尾节点,由移动k个位置,找到断点处的指针,再将依次执行下列语句tailListNode->next = head; head = breakListNode->next; break->next = NULL;
struct ListNode* rotateRight(struct ListNode* head, int k){
struct ListNode* tailListNode;
struct ListNode* breakListNode;
breakListNode = head;
if(head == NULL || k == 0){
return head;
}
int lengthList = 1;
while(breakListNode->next != NULL){
breakListNode = breakListNode->next;
lengthList ++;
}
tailListNode = breakListNode;
k = k % lengthList;
breakListNode = head;
for(int i = 0; i < lengthList - k-1; i++)
breakListNode = breakListNode->next;
tailListNode->next = head;
head = breakListNode->next;
breakListNode->next = NULL;
return head;
}
- 删除排序链表中的重复元素(83)
给定一个已排序的链表的头 head , 删除所有重复的元素,使每个元素只出现一次 。返回 已排序的链表 。
示例 1:
输入:head = [1,1,2]
输出:[1,2]
思路:方法1:双指针,通过遍历链表,当遇到不重复元素时,创建新的节点并将该节点链在慢指针后面。
方法2:双指针,通过创建快慢指针,快指针在前面遍历,慢指针链接不重复节点,与方法1相比,方法2遍历的过程中遇到不重复的节点不开辟新的内存,而是将该节点指针直接链接在慢指针后面。
方法1:
struct ListNode* deleteDuplicates(struct ListNode* head){
if(head == NULL || head->next == NULL){
return head;
}
struct ListNode* slow = (struct ListNode*)malloc(sizeof(struct ListNode));
slow->val = head->val;
slow->next = NULL;
struct ListNode* fast = head->next;
struct ListNode* returnNode = slow;
while(fast != NULL){
if(slow->val != fast->val){
struct ListNode* temp = (struct ListNode*)malloc(sizeof(struct ListNode));
temp->val = fast->val;
temp->next = NULL;
slow->next = temp;
slow = slow->next;
}
fast = fast->next;
}
return returnNode;
}
方法2
struct ListNode* deleteDuplicates(struct ListNode* head){
if(head == NULL || head->next == NULL){
return head;
}
struct ListNode* slow = head;
struct ListNode* fast = head->next;
struct ListNode* returnNode = slow;
while(fast != NULL){
//当遇到不重复的节点时
if(slow->val != fast->val){
//将该节点链接在slow节点后面
slow->next = fast;
//slow节点指向下一个节点
slow = slow->next;
}
//遍历一个节点,fast就指向下个节点
fast = fast->next;
}
//slow链表是在head链表的基础上去掉重复元素组成的,所以slow链表的长度小于或等于head链表长度,因此将slow->next = null;
if(slow->next != NULL){
slow->next = NULL;
}
//slow链表的头节点
return returnNode;
}