每日一题——单链表排序（归并排序）

每日一题

单链表排序

题目链接

思路（归并排序）

• 要达到题目要求的时间复杂度为nlogn，那我们应该采用分治算法。
  • 分治算法：分治即“分而治之”，“分”指的是将一个大而复杂的问题划分成多个性质相同但是规模更小的子问题，子问题继续按照这样划分，直到问题可以被轻易解决；“治”指的是将子问题单独进行处理。经过分治后的子问题，需要将解进行合并才能得到原问题的解，因此整个分治过程经常用递归来实现。
• 因此，我们可以将需排序的链表不断地进行二等分，直到不可再分割（即最后分割为对单个节点的子问题）。
• 最后，再根据合并有序链表（合并两个有序链表）的思想，不断将子问题合并，最后得到有序链表。
• 如图：

步骤

• 如果链表没有或只有一个节点，则以及有序，直接返回原头结点
• 利用快慢指针找到链表中间节点
  • 定义三个指针变量mid，left，right，让left始终在mid的前一个位置，right每次移动两个节点，mid和left每次移动一个节点，当right走到表尾的时候，mid刚好走到链表的中间
• 从left位置断开链表，得到两个小链表，按照相同的操作继续分割链表，直到分割为不可分割的单个节点（递归）
• 对每组节点进行两两合并，直到合并为原始有序链表

实现代码

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

/**
 * 
 * @param head ListNode类 the head node
 * @return ListNode类
 */
struct ListNode* merge(struct ListNode* head1,struct ListNode*head2)		//合并有序链表
{
    if(head1 == NULL || head2 == NULL)		
        return head1 == NULL ? head2 : head1;
    struct ListNode* newHead = (struct ListNode*)malloc(sizeof(struct ListNode));
    struct ListNode* pre = newHead;
    while(head1 && head2)
    {
        if(head1->val <= head2->val)
        {
            pre->next = head1;
            head1 = head1->next;
        }
        else 
        {
            pre->next = head2;
            head2 = head2->next;
        }
        pre = pre->next;
    }
    pre->next = head1 == NULL ? head2 : head1;
    return newHead->next;
}
struct ListNode* sortInList(struct ListNode* head ) {
    if( head == NULL || head->next == NULL)		//如果链表没有或只有一个节点，则以及有序，直接返回原头结点
        return head;
    struct ListNode *mid, *left, *right;
    mid = head->next;
    left = head;
    right = head->next->next;		//相当于快慢指针已经进行了一次下滑
    while(right != NULL && right->next != NULL)		//当快指针还没有走到表尾
    {
        mid = mid->next;
        left = left->next;
        right = right->next->next;
    }
    left->next = NULL;		//从left位置断开链表，进行分治
    return merge(sortInList(head), sortInList(mid));	//进行递归，当分割为不可分割的单个节点时，进行合并，最后返回有序链表的头节点
}