剑指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 == )
             return nullptr;
         auto p = pListHead;
         for(int i=; i<k-; 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();
         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 = ;
         //计算环长，相遇点再走一圈
         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();
         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 = ;
         auto p = head;
         while(p != nullptr)//计算表长
         {
             len++;
             p = p->next;
         }
         if(n > len)//边界处理
             return nullptr;

         len = len-n-;//先走len-n-1步
         p = head;
         if(len < )//删除头节点
             return p->next;

         while(len--)//删除其他节点
             p = p->next;
         p->next = p->next->next;
         return head;
     }
 };

the end.