147.对链表进行插入排序

题目

给定单个链表的头 head ，使用 插入排序 对链表进行排序，并返回 排序后链表的头 。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/insertion-sort-list
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

 

示例

 

思路

插入排序 :

插入排序是迭代的，每次只移动一个元素，直到所有元素可以形成一个有序的输出列表。
每次迭代中，插入排序只从输入数据中移除一个待排序的元素，找到它在序列中适当的位置，并将其插入。
重复直到所有输入数据插入完为止。
下面是插入排序算法的一个图形示例。部分排序的列表(黑色)最初只包含列表中的第一个元素。每次迭代时，从输入数据中删除一个元素(红色)，并就地插入已排序的列表中。

对链表进行插入排序。

冒泡排序：

定义双指针，在定义临时变量保存交换值，一个指针遍历链表，另外一个指针循环遍历链表判断与前一个指针数值大小，将链表中最小是数交换到前一个链表位置

代码

插入排序：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
/*
*sortList：将链表升序排列
struct ListNode* head：链表头结点
返回值：返回升序链表
*/
struct ListNode *insertionSortList(struct ListNode *head) {
    if(!head)
    {
        return NULL;
    }
    struct ListNode * head_tt = malloc(sizeof(struct ListNode));
    head_tt->val = 0;
    head_tt->next = head;
    struct ListNode * i = head->next;
    struct ListNode * j = head;
    while(i)
    {
        if(i->val >= j->val)
        {
            i = i->next;
            j = j->next;
        }
        else
        {
            struct ListNode * m = head_tt;
            while(m->next->val <= i->val && m)
            {
                m = m->next;
            }
            j->next = i->next;
            i->next = m->next;
            m->next = i;
            i = j->next;
        }
    }
    return head_tt->next;
}

冒泡排序：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
/*
*sortList：将链表升序排列
struct ListNode* head：链表头结点
返回值：返回升序链表
*/
struct ListNode* insertionSortList(struct ListNode* head){
    struct ListNode * i = head;
    struct ListNode * j;
    int t;
    while(i)
    {
        j = i->next;
        while(j)
        {
            if(i->val > j->val)
            {
                t = i->val;
                i->val = j->val;
                j->val = t;
            }
            j = j->next;
        }
        i = i->next;
    }
    return head;
}

插入排序：

struct ListNode *insertionSortList(struct ListNode *head) {
    if (head == NULL) {
        return head;
    }
    struct ListNode *dummyHead = malloc(sizeof(struct ListNode));
    dummyHead->val = 0;
    dummyHead->next = head;
    struct ListNode *lastSorted = head;
    struct ListNode *curr = head->next;
    while (curr != NULL) {
        if (lastSorted->val <= curr->val) {
            lastSorted = lastSorted->next;
        } else {
            struct ListNode *prev = dummyHead;
            while (prev->next->val <= curr->val) {
                prev = prev->next;
            }
            lastSorted->next = curr->next;
            curr->next = prev->next;
            prev->next = curr;
        }
        curr = lastSorted->next;
    }
    return dummyHead->next;
}

 

时间空间复杂度

冒泡排序： 

插入排序：