插入排序

插入排序的思路很简单，基本都知道。

关键是放在链表中，

1.要建立一个哨兵位，这个哨兵位的下一个节点，始终指向val最小的节点。

2.prev指针作为cur的前一个节点，始终指向val最大的节点。它的下一个节点始终指向cur/cur即将跳跃的待排序的节点。

3.cur指向待排序的第一个节点。

cur从第二个开始，prev就指向头节点。

代码：

 /* 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* insertionSortList(ListNode* head) {
        if(head==nullptr || head->next==nullptr)
        {
            return head;
        }
        ListNode* dummy = new ListNode(0);//建立一个哨兵位，始终指向最小的
        dummy->next=head;

        ListNode* cur=head->next;
        ListNode* prev=head;

        while(cur)
        {
            if(prev->val <= cur->val)//prev始终指向最大的，cur的前一个
            {
                prev=cur;
                cur=cur->next;
            }
            else
            {
                ListNode* tmp=dummy;
                while(tmp->next->val <= cur->val)//不用考虑走到空，这里一定有大于cur的值
                {
                    tmp=tmp->next;
                }
                prev->next=cur->next;//标记，方便cur跳跃
                //cur插入tmp和tmp->next中
                cur->next=tmp->next;
                tmp->next=cur;
                //cur跳跃
                cur=prev->next;
            }
        }
        ListNode* newhead = dummy->next;
        delete dummy;
        return newhead;
    }
};

2.删除链表中的重复节点

分析：

1.删除重复节点可能会遇到连续多个重复节点，因此需要在循环进行。

2.删除的重复节点是头节点和不是头节点要分别处理，是头节点，那么头节点要换到next，不是头节点，就不需要更换头节点了。（最后返回头节点）

3.删除节点的方式，这题我使用的是跳过这个节点，而不是释放节点。

4.在判断cur节点和next节点值相等的循环中，跳出循环时，next走到下一个节点，下一个节点是空和不是空要分别处理。

这里要声明3个节点，头节点是已经给了的，始终指向第一个存在的位置，如果它要被删除，那么它要更换别的不被删除的位置，如果所有的节点都可以消消乐，那么就要让它指向空。

cur节点指向即将判断的第一个节点，next节点指向即将判断的第二个节点。如果判断不相等。prev就指向cur，cur和next依次往后走一个位置。prev永远指向安全的不被删除的位置，永远指向cur的前，当连续存在相等的值时，next一直往下走和cur判断。直到走到不等的位置时跳出，此时需要prev的next指针指向这个不与cur相等的更新的next，接着再更新cur和next的位置。

这道题可能会坑的地方基本指出，其余的就是逻辑上要考虑到所有情况，不能让任何一种情况遗漏了。

代码：

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/

class Solution {
public:
    ListNode* deleteDuplication(ListNode* pHead) {
        if(pHead==nullptr || pHead->next==nullptr)
        {
            return pHead;
        }
        ListNode* cur=pHead;
        ListNode* prev=nullptr;
        ListNode* next=pHead->next;
        while(next)
        {
            if(cur->val==next->val)
            {
                while(next&&cur->val==next->val)
                {
                    next=next->next;
                }
                if(cur==pHead&&next==nullptr)
                {
                    return nullptr;
                }
                else if(cur==pHead&&next!=nullptr)
                {
                    pHead=next;
                }
                else if(cur!=pHead &&next!=nullptr)
                {
                    prev->next=next;
                }
                else
                {
                    prev->next=next;
                    return pHead;
                }
                cur=next;
                if(next)
                {
                    next=cur->next;
                }
            }
            else
            {
                prev=cur;
                cur=next;
                next=next->next;
            }
        }
        return pHead;
    }
};