无头结点单链表直接插入排序

struct ListNode 
{
    int val;
    struct ListNode* next;
};

typedef struct ListNode ListNode;
struct ListNode* insertionSortList(struct ListNode* head)
{
    // 如果链表为空或者链表只有一个元素，那就根本不用排序
    if (head == NULL || head->next == NULL)
        return head;
    // 创建一个新链表sorthead 
    // 把原链表的第一个节点取下来放到新链表
    ListNode* sorthead = head;
    ListNode* cur = head->next; // 让cur指向原链表第二个节点
    sorthead->next = NULL;

    //  然后cur遍历链表，让cur得val去和soryhead的val作对比，
    // 如果cur小于sorthead，那就是头插
    // 如果 cur == 或者大于的话 那就是中间插入或者尾插，
    // 那就在遍历sorthead链表，让sortcur去遍历，让sortcur得val值去和cur得val值作对比
    // 让sortprev指向sortcur得上一个指针 
    // 如果小于，就在 sortprev和sortcur之间插入 
    // 如果大于，那就让sortcur往后走，继续对比
    // 如果出了循环，就说明cur的值最大，那就尾插到sort链表中
    while (cur)
    {
        ListNode* next = cur->next; // next指向cur得下一个节点

        // 将cur插入sort链表的同时保持有序
        if (cur->val <= sorthead->val)
        {
            // 头插到sorthead链表
            cur->next = sorthead;
            sorthead = cur;
        }
        else // 中间插入或者尾插
        {
            ListNode* sortprev = sorthead; // 指向sortcur得前一个指针
            ListNode* sortcur = sorthead->next;

            while (sortcur)
            {
                if (cur->val <= sortcur->val)
                {
                    // 中间插入
                    sortprev->next = cur;
                    cur->next = sortcur;
                    break;
                }
                else
                {
                    // 让sortcur继续迭代，遍历链表
                    sortprev = sortcur;
                    sortcur = sortcur->next;
                }

            }

            // 走到这里可能是cur得val值大于sorthead中的任何一个值
            // 也可能是前面break出循环
            // 尾插到链表
            if (sortcur == NULL) // 判断是不是遍历完链表了
            {
                sortprev->next = cur;
                cur->next = NULL;
            }

        }
        cur = next;
    }
    
    return sorthead;
}

写出来的目的 ：

 while (sortcur)
            {
                if (cur->val <= sortcur->val)
                {
                    // 中间插入
                    sortprev->next = cur;
                    cur->next = sortcur;
                    break;
                }
                else
                {
                    // 让sortcur继续迭代，遍历链表
                    sortprev = sortcur;
                    sortcur = sortcur->next;
                }

            }

对比：有头节点单链表，在第一个节点和中间节点和最后一个节点后插入，采用同样语句

p->next = pre->next;
pre->next = p;

void sort(LinkList * &L){
	LinkList *p,*pre,*q;
	p = L->next->next;		// 先保存下L的第二个元素，因为下一步要将L变成只有一个元素的有序表。  
	L->next->next = NULL;	// 将L变成只有一个元素的有序表
	// 从L的第二个元素开始遍历整个L直至表尾 
	while(p != NULL){
		q = p->next;
		pre = L;	// 先用pre来保存L。
		while(pre->next !=NULL && pre->next->data < p->data) // 遍历pre所指向的有序表L，直至找到比p大的节点 
			pre = pre->next; 
		p->next = pre->next;
		pre->next = p;
		p = q;	
	} 
}

在kmp中出现同样这个技巧，对比的这个程序是有头节点，是为了观察循环！！！！！

void sort(LinkList * &L){
	LinkList *p,*pre,*q;
	p = L->next->next;		// 先保存下L的第二个元素，因为下一步要将L变成只有一个元素的有序表。  
	L->next->next = NULL;	// 将L变成只有一个元素的有序表
	// 从L的第二个元素开始遍历整个L直至表尾 
	while(p != NULL){
		q = p->next;
		pre = L;	// 先用pre来保存L。
		while(pre->next !=NULL && pre->next->data < p->data) // 遍历pre所指向的有序表L，直至找到比p大的节点 
			pre = pre->next; 
		p->next = pre->next;
		pre->next = p;
		p = q;	
	} 
}

 while (sortcur)
            {
                if (cur->val <= sortcur->val)
                {
                    // 中间插入
                   // sortprev->next = cur;
                  //  cur->next = sortcur;
                  //  break;
                }
                else
                {
                    // 让sortcur继续迭代，遍历链表
                    sortprev = sortcur;
                    sortcur = sortcur->next;
                }

            }

 sortcur继续迭代对应pre继续迭代，其实kmp的相关博客页有同样这个技巧