【33】排序链表 | 相交链表（LeetCode 148 | 160）

排序链表

问题描述

给你链表的头结点 head ，请将其按 升序排列 并返回排序后的链表 。

进阶：

你可以在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序吗？

解题思路

看到时间复杂度O（nlogn），第一想法就是快速排序，但是指针并不能前移，所以在这题中不能用快速排序。而应该用归并排序。

如果要达到题目要求的常数时间的空间复杂度，就用迭代来实现。

关于归并排序见合并排序（归并排序）-分治法-计算机算法。

先来看递归的方法：

1. 找到链表的中间结点mid；（可用快慢指针，也可求出链表的长度找n/2处的结点）
2. 对上半部分和下半部分进行排序；（每个部分排序的方法仍是找中间节点、分部分排序、合并）
3. 合并排好序的两部分。（见合并两个有序链表）

代码实现：

/**
 * 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* sortList(ListNode* head, ListNode* tail) {//分治排序
        if (!head) 
            return head;
        if (head->next == tail) {//还剩一个结点时直接返回
            head->next = nullptr;
            return head;
        }
        ListNode* slow = head, *fast = head;
        while (fast != tail) {//找中间位置的结点
            slow = slow->next;
            fast = fast->next;
            if (fast != tail) {
                fast = fast->next;
            }
        }
        ListNode* mid = slow;
        ListNode* p = sortList(head, mid);
        ListNode* q = sortList(mid, tail);
        return merge(p,q);
    }

    ListNode* merge(ListNode* l1, ListNode* l2) { //递归合并两个有序链表
        if (l1 == nullptr) {
            return l2;
        } else if (l2 == nullptr) {
            return l1;
        } else if (l1->val < l2->val) {
            l1->next = merge(l1->next, l2);
            return l1;
        } else {
            l2->next = merge(l1, l2->next);
            return l2;
        }
    }

    ListNode* sortList(ListNode* head) {
        return sortList(head, nullptr);
    }
};

相交链表

问题描述

编写一个程序，找到两个单链表相交的起始节点。

例子：

解题思路

①求出链表a和链表b的长度差；
②根据长度差将A和B的指针指向同一水平；
③A、B的指针后移，直到指到同一位置或者NULL。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    int legth(ListNode* head){//求链表的长度
        int i=0;
        while(head){
            i++;
            head = head->next;
        }
        return i;
    }

    ListNode *res(ListNode *headA,ListNode *headB){//返回结果
        ListNode* res = NULL;
        while(headA && headB){
            if(headA == headB){
                res = headA;
                break;
            }
            headA = headA->next;
            headB = headB->next;
        }
        return res;
    }

    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if(headA == headB) return headA;
        if(!headA || !headB) return NULL;

        int an = legth(headA),bn = legth(headB);
        if(an > bn){
            int cha = an-bn;
            for(int i=0;i<cha;i++) //将A、B指针指向同一水平
                headA = headA->next;
            return res(headA,headB);
        }else{
            int cha = bn-an;
            for(int i=0;i<cha;i++)
                headB = headB->next;
            return res(headA,headB);
        }
    }
};

时间复杂度：O（n）
空间复杂度：O（1）