面试专题 单链表常见操作

说起单链表是我永远的痛……
所以专门做一个专题,整理常见的单链表的题目,彻底攻下这个大坑.

链表逆序输出

首先是常见的,链表逆序输出

class Solution {
public:
    vector<int> printListFromTailToHead(ListNode* head) {
         vector<int> ans;
        stack<ListNode> nodes;
        while(head != NULL){
            nodes.push( *head);
            head = head -> next;
        }

        while(!nodes.empty()){
            ans.push_back( nodes.top().val);
            nodes.pop();
        }

        return ans;
    }
};

这里面有一个问题是在于,逆序输出不能更改链表结构,因此用栈来处理这个问题.
用递归当然也可以,不过链表太长的时候就会有一个递归深度的问题,有可能栈溢出.这就要视规模而定啦.

链表反转

这个是Leetcode上的一道题,Reverse Linked List
目的是将整个链表反转过来,然后返回头指针

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
      if (head == NULL
        || head->next == NULL) {
        return head;
    }
    ListNode * prev,* temp,* next;
    prev = head;
    temp = head->next;
    prev->next = NULL;
    while (temp != NULL)
    {
        next = temp->next;
        temp->next = prev;
        prev = temp;
        temp = next;
    }

    return prev;
    }
};

单链表问题通常的套路是双指针的方法,两个指针可以很好地处理旧键断裂和新键生成.
避免了修改了结点的next指针修改后原来的下一结点找不到的问题.

链表找环问题

这个问题目前我有两个解法
一是遍历链表 然后把访问到的每一个结点存入一个set中 (set不存在重复的节点) 当发现有两个地址相同的结点时,就可以确定这个链表存在环路了.
这个做法有一个问题就在于非原地计算.有O(n)的空间复杂度.
那么另一个方法就是数学上的追及问题.
由于环的结构,导致了两个速度不同的指针在环内跑的时候回相遇.
如果不存在环,速度快的指针会先到达链表尾,而速度慢的指针后到达.

注意,两个指针的速度要成倍数关系.最好是1:2.方便寻找到环的起点.

占坑待补充