剑指offer-链表相关

剑指offer面试常考手撸算法题-链表篇

1. 从头到尾打印链表

class Solution {
public:
    // 可以先压栈，再出栈到vector
    // 时间/空间：O(n)
    vector<int> printListFromTailToHead(ListNode* head) {
        if(head == nullptr)
            return {};
        vector<int> res;
        stack<int> s;
        while(head != nullptr)
        {
            s.push(head->val);
            head = head->next;
        }
        while(!s.empty())
        {
            res.push_back(s.top());
            s.pop();
        }
        return res;
    }
    // 可以直接插入vector中，翻转vector
    // 时间/空间：O(n)
    vector<int> printListFromTailToHead(ListNode* head) {
        vector<int> res;
        if(head == nullptr)
            return {};
        while(head)
        {
            res.push_back(head->val);
            head = head->next;
        }
        reverse(res.begin(), res.end());
        return res;
    }
};

2. 链表中倒数第k个节点

class Solution {
public:
    //快慢指针,快指针先走k-1步，之后一起走，直到快指针到达链表尾。
    //时间：O(n), 空间O(1)
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
        if(pListHead == nullptr || k == 0)
            return nullptr;
        auto p = pListHead;
        for(int i=0; i<k-1; i++)
        {
            if(p->next == nullptr)
                return nullptr;
            p = p->next;
        }
        while(p->next != nullptr)
        {
            p = p->next;
            pListHead = pListHead->next;
        }
        return pListHead;
    }
};

3. 翻转链表

class Solution {
public:
    //一个取巧的方法(如果允许使用额外空间)：先遍历链表用栈存储元素值，然后重新遍历链表，将链表值置为栈顶。
    //时间：O(n), 空间O(n)
    ListNode* ReverseList(ListNode* pHead) {
        stack<int> s;
        auto p = pHead, q = pHead;
        while(pHead != nullptr)
        {
            s.push(pHead->val);
            pHead = pHead->next;
        }
        while(p != nullptr)
        {
            p->val = s.top();
            s.pop();
            p = p->next;
        }
        return q;
    }
};

class Solution {
public:
    //2. 真正地翻转链表，交换地址
    ListNode* ReverseList(ListNode* pHead) {
        if(pHead == nullptr)
            return nullptr;
        decltype(pHead) pre = nullptr;
        auto next = pre;
        ListNode *res = nullptr;
        while(pHead != nullptr)
        {
            next = pHead->next;
            if(next == nullptr)
                res = pHead;
            pHead->next = pre;
            pre = pHead;
            pHead = next;
        }
        return res;
    }
};

4. 合并两个排序链表

class Solution {
public:
    //非递归版本：双指针分别遍历两个链表
    ListNode* Merge1(ListNode* pHead1, ListNode* pHead2)
    {
        if(pHead1 == nullptr)
            return pHead2;
        if(pHead2 == nullptr)
            return pHead1;
        ListNode *head = new ListNode(0);
        head->next = nullptr;
        ListNode *res = head;
        while(pHead1 != nullptr && pHead2 != nullptr)
        {
            if(pHead1->val <= pHead2->val)
            {
                head->next = pHead1;
                head = head->next;
                pHead1 = pHead1->next;
            }
            else
            {
                head->next = pHead2;
                head = head->next;
                pHead2 = pHead2->next;
            }
        }
        if(pHead1 != nullptr)
            head->next = pHead1;
        else
            head->next = pHead2;
        return res->next;
    }
    //递归版本
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
    {
        if(pHead1 == nullptr)
            return pHead2;
        if(pHead2 == nullptr)
            return pHead1;
        
        ListNode* head = nullptr;
        if(pHead1->val <= pHead2->val)
        {
            head = pHead1;
            head->next = Merge(pHead1->next, pHead2);
        }
        else
        {
            head = pHead2;
            head->next = Merge(pHead2->next, pHead1);
        }
        return head;
    }
};

5. 两个链表第一个公共节点

class Solution {
public:
    //暴力法太低级，O(n2)不可接受
    //使用unordered_map存储一个链表节点吧，时间O(n),空间O(n)
    //unordered_map使用[]/insert插入，不是push_back()
    ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
        if(pHead1 == nullptr)
            return nullptr;
        if(pHead2 == nullptr)
            return nullptr;
        
        unordered_map<int, ListNode*> ump;
        while(pHead1 != nullptr)
        {
            ump.insert({pHead1->val, pHead1});
            pHead1 = pHead1->next;
        }
        while(pHead2 != nullptr)
        {
            auto res = ump.find(pHead2->val);
            if(res != ump.end())
                return res->second;
            pHead2 = pHead2->next;
        }
        return nullptr;
    }
};

6. 链表中环的入口节点（快2满1指针判断成环，再走一圈计算环长，快慢指针找到入口）

判断链表是否成环（快慢指针解决）

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    //判断成环及入口：快慢指针
    ListNode* EntryNodeOfLoop(ListNode* pHead)
    {
        if(pHead == nullptr)
            return nullptr;
        ListNode *pMeet = judgeLoop(pHead);
        if(pMeet == nullptr)//未成环
            return nullptr;
        auto p = pMeet;
        int loopLen = 1;
        //计算环长，相遇点再走一圈
        while(p->next != pMeet)
        {
            p = p->next;
            loopLen++;
        }
        auto q = pHead;
        //后指针先走环长
        while(loopLen--)
        {
            q = q->next;
        }
        //快慢一起走
        p = pHead;
        while(p != q)
        {
            p = p->next;
            q = q->next;
        }
        return p;
    }
    //判断是否成环,快指针走两步-慢指针走一步，指针相遇必在环内
    ListNode* judgeLoop(ListNode* pHead)
    {
        if(pHead == nullptr)
            return nullptr;
        auto pSlow = pHead->next;
        if(pSlow == nullptr)
            return nullptr;
        auto pFast = pSlow->next;
        while(pSlow != nullptr && pFast != nullptr)
        {
            if(pSlow == pFast)
                return pSlow;
            pSlow = pSlow->next;
            pFast = pFast->next;
            if(pFast != nullptr)
                pFast = pFast->next;
        }
        return nullptr;
    }
};

7. 删除链表重复节点(重复保留一个)

class Solution {
public:
    //一次遍历，前后节点值相等,删除后一节点
    ListNode* deleteDuplication(ListNode* pHead)
    {
        if(pHead == nullptr)
            return nullptr;
        auto pre = pHead;
        auto cur = pre->next;
        while(cur != nullptr)
        {
            while(cur->val == pre->val)
            {
                pre->next = cur->next;
                cur = pre->next;
                if(cur == nullptr)
                    return pHead;
            }
            pre = cur;
            cur = cur->next;
        }
        return pHead;
    }
};

8. 删除链表重复节点(重复节点不保留)

class Solution {
public:
    /*创建一个头节点，它的next指向链表头，然后再用两个指针
    一前一后来遍历链表，后一个指针判断有无重复并进行后移*/
    ListNode* deleteDuplication(ListNode* pHead)
    {
        if(pHead == nullptr)
            return nullptr;
        ListNode *first = new ListNode(0);
        first->next = pHead;
        ListNode *last = first;
        ListNode *p = pHead;
        while(p != nullptr && p->next != nullptr)
        {
            if(p->val == p->next->val)//有重复，需要删除
            {
                int val = p->val;
                while(p != nullptr && p->val == val)
                    p = p->next;
                last->next = p;
            }
            else
            {
                last = p;
                p = p->next;
            }
        }
        return first->next;
    }
};

9. 判断两个链表是否交叉

(同样可使用一个unordered_map来存储一个链表中的节点指针，再遍历另外一个链表逐个查找)

bool FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
    if(pHead1 == nullptr || pHead2 == nullptr)
        return false;
    unordered_map<ListNode*, int> ump;
    while(pHead1 != nullptr)
    {
        ump.insert({pHead1, pHead1->val});
        pHead1 = pHead1->next;
    }
    while(pHead2 != nullptr)
    {
        auto res = ump.find(pHead2);
        if(res != ump.end())
            return true;
        pHead2 = pHead2->next;
    }
    return false;
}

10.相交链表

O(n)

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        auto p = headA, q = headB;
        while(p != q)
        {
            if(p == q)
                return p;
            p = (p == nullptr) ? headB : p->next;
            q = (q == nullptr) ? headA : q->next;
        }
        return p;
    }
};

说明：以上其他题目代码由牛客oj/leetcode通过，第9个未测试。

11.删除链表第n个节点（leetcode 19）

O(n)

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        int len = 0;
        auto p = head;
        while(p != nullptr)//计算表长
        {
            len++;
            p = p->next;
        }
        if(n > len)//边界处理
            return nullptr;
        
        len = len-n-1;//先走len-n-1步
        p = head;
        if(len < 0)//删除头节点
            return p->next;
        
        while(len--)//删除其他节点
            p = p->next;
        p->next = p->next->next;
        return head;
    }
};

the end.