Leetcode刷题[链表]

1. 两数相加（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;
}

---

---

2. 旋转链表（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;

}

---

---

3. 删除排序链表中的重复元素(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;
}

---

---