ListNode

链表

1.移除链表元素

/**
 * 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* removeElements(ListNode* head, int val) {
        ListNode* dummyhead = new ListNode(-1);
        dummyhead -> next = head;
        ListNode* cur = dummyhead;
        
        while(cur -> next != nullptr){
            if(cur->next->val == val){
                ListNode* temp = cur->next;
                cur->next = cur->next->next;
                delete temp;
            }else{
                cur = cur->next;
            }
        }
        head = dummyhead->next;
        delete dummyhead;
        return head;
    }
};
//注意链表需要释放被删除的元素
//注意链表数据结构的构造

2.翻转链表

// 1.头插法
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == nullptr) return nullptr;
        ListNode* dummyhead = new ListNode(-1);
        dummyhead -> next = head;
        ListNode* cur = head;
        while(cur -> next != nullptr){
            auto temp  = cur->next->next;
            auto temp1 = dummyhead->next;
            dummyhead->next = cur->next;
            cur->next->next = temp1;
            cur->next = temp;
        }
        return dummyhead->next;
    }
};
// 2.双指针
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* cur = head;
        ListNode* pre = nullptr;
        ListNode* temp = nullptr;
        while(cur){
            temp = cur -> next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
};
// 3.递归解法
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == nullptr) return nullptr;
        if(head -> next == nullptr) return head;
        ListNode* temp = reverseList(head->next);
        head -> next ->next = head;
        head -> next = nullptr;
        return temp; 
    }
};

3.两两交换链表中的节点

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* cur = head;
        ListNode* temp = nullptr;
        ListNode* dummyhead = new ListNode(-1);
        dummyhead -> next = head;
        ListNode* pre = dummyhead;
        while(cur != nullptr && cur -> next != nullptr){
            pre -> next = cur -> next;
            temp = cur -> next ->next;
            cur -> next ->next = cur;
            cur -> next = temp;
            pre = cur;
            cur = cur -> next;
        }
        return dummyhead->next;
    }
};

4.删除链表的倒数第N个节点

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyhead = new ListNode(-1);
        dummyhead -> next = head;
        ListNode* pre = dummyhead;
        ListNode* cur = head;
        while(n--){
            if(cur == nullptr) return head;
            cur = cur -> next;        
        }
        while(cur != nullptr){
            cur = cur->next;
            pre = pre->next;
        }
        pre -> next = pre ->next->next;
        return dummyhead->next;
    }
};

5.链表相交

// 1.数学法
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode *A = headA, *B = headB;
        while (A != B) {
            A = A != nullptr ? A->next : headB;
            B = B != nullptr ? B->next : headA;
        }
        return A;
    }
};
作者：jyd
链接：https://leetcode-cn.com/problems/intersection-of-two-linked-lists-lcci/solution/mian-shi-ti-0207-lian-biao-xiang-jiao-sh-b8hn/
// 2.简单易懂
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;

        int nA = 0;
        int nB = 0;
        while(curA != nullptr){
            curA = curA -> next;
            nA++;
        }
        while(curB != nullptr){
            curB = curB -> next;
            nB++;
        }
        curA = headA;
        curB = headB;

        if(nB > nA){
            swap(curA, curB);
        }
        int diff = abs(nA - nB);

        while(diff--){
            curA = curA -> next;
        }
        while(curA != nullptr){
            if(curA == curB) return curA;
            curA = curA -> next;
            curB = curB -> next;
        }
        return nullptr;
    }
};

6.环形链表 II

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fastptr = head;
        ListNode* slowptr = head;

        do{
            if(fastptr == nullptr || fastptr->next == nullptr){
                return NULL;
            }
            fastptr = fastptr -> next ->next;
            slowptr = slowptr -> next;
            
        }while(fastptr != slowptr);

        ListNode* cur = head;
        while(cur != fastptr){
            cur = cur -> next;
            fastptr = fastptr -> next;
        }
        return cur;
        
    }
};