链表基本操作

1 reverse

1) 常规顺序遍历算法：（4句话）

auto next = cur->next;
cur->next = head2;
head2 = cur;
cur = next;

2）递归算法：

保存第二个结点地址second，reverse从第二个结点开始的链表，这时候second是reverse之后的链表的尾，令second->next = head, head = NULL，这样就完整了整个链表的翻转。

ListNode* reverse(ListNode * head) {
        if (head == NULL || head->next == NULL ) return head;
        auto second = head->next;
        auto head2 = reverse(head->next);
        second->next = head;
        head->next = NULL;
        return head2;
    }

2 插入有序链表

思路：1）head可能会变---> 要用dummy。2）以prev->next作为测试对象，当prev->next->val t大于 x，循环停止。3）调整链接。

ListNode * insert(ListNode *head, int x) {
        ListNode dummy(-1), *node = new ListNode(x);
        dummy.next = head;
        auto prev = &dummy;
        for ( ; prev->next && prev->next->val < x; prev = prev->next) ;
        auto tmp = prev->next;
        prev->next = node;
        node->next = tmp;
        return dummy.next;
    }

ListNode *insert (ListNode *head, int x) {
    if (head == nullptr) return new ListNode(x);
    if (head -> val > x) {
        ListNode node = new ListNode(x);
        node -> next = head;
        return node;
    }
    head -> next = insert(head ->next, x)
    return head;
}

3 删除结点值为给定值的结点

思路：1）head可变，用dummy。2）以prev->next为测试对象，当prev->next不等于x，prev推进；当prev->next->val 等于x ，调整链接，进行删除，prev不推进

ListNode * remove(ListNode *head, int x) {
        ListNode dummy(-1);
        dummy.next = head;
        for (auto prev = &dummy; prev->next;) {
            if (prev->next->val == x) {
                auto tmp = prev->next->next;
                delete prev->next;
                prev->next = tmp;
            } else {
                prev = prev->next;
            }
        }
        return dummy.next;
    }

ListNode * remove(ListNode* head, int x) {
    if (head == nullptr) return nullptr;
    if (head -> val == x) {
        auto next = head -> next;
        delete head;
        return next;
    }
    head -> next = remove(head ->next, x);
    return head;
}