/**
 * 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) {}
 * };
 */

//模拟算法，正常思维2个2个切割替换
class Solution {
public:
    void log(ListNode* tmp){
        while(tmp != nullptr){
            cout << tmp->val << "," ;
            tmp = tmp->next;
        }
        cout << endl;
    }

    ListNode* swapPairs(ListNode* head) {
        // ListNode* tmp1 = head;
        // ListNode* pre = NULL;
        // int i = 0;
        // while(head != NULL && head->next != NULL){
        //     ListNode* tmp = head->next;
        //     if(i++ == 0)
        //         tmp1 = tmp;
        //     head->next = head->next->next;
        //     tmp->next = head;
            
        //     if(pre != NULL)
        //         pre->next = tmp;
        //     pre = head;
        //     head = head->next;
        //     log(tmp1);
        // }
        // return tmp1;

        ListNode* dummyHead = new ListNode(0); // 设置一个虚拟头结点
        dummyHead->next = head; // 将虚拟头结点指向head，这样方面后面做删除操作
        ListNode* cur = dummyHead;
        while(cur->next != nullptr && cur->next->next != nullptr) {
            ListNode* tmp = cur->next; // 记录临时节点
            ListNode* tmp1 = cur->next->next->next; // 记录临时节点

            cur->next = cur->next->next;    // 步骤一
            cur->next->next = tmp;          // 步骤二
            cur->next->next->next = tmp1;   // 步骤三

            cur = cur->next->next; // cur移动两位，准备下一轮交换
        }
        return dummyHead->next;
    }
};

/**
 * 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* removeNthFromEnd(ListNode* head, int n) {
        int size = 0;
        ListNode* cur = head;
        while(cur != NULL){
            size++;
            cur = cur->next;
        }
        int idx = size - n;
        if(idx < 0)
            return head;
        ListNode* add_head = new ListNode(0);
        add_head->next = head;
        cur = add_head;
        while(idx-- > 0)
            cur = cur->next;
        cur->next = cur->next->next;
        return add_head->next;

        /*
        双指针方法，slow和fast跟上面的size-n原理一样
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* slow = dummyHead;
        ListNode* fast = dummyHead;
        while(n-- && fast != NULL) {
            fast = fast->next;
        }
        fast = fast->next; // fast再提前走一步，因为需要让slow指向删除节点的上一个节点
        while (fast != NULL) {
            fast = fast->next;
            slow = slow->next;
        }
        slow->next = slow->next->next; 
        
        // ListNode *tmp = slow->next;  C++释放内存的逻辑
        // slow->next = tmp->next;
        // delete nth;
        
        return dummyHead->next;
        */
    }
};