[LeetCode] 链表反转相关题目

暂时接触到LeetCode上与链表反转相关的题目一共有3道，在这篇博文里面总结一下。首先要讲一下我一开始思考的误区：链表的反转，不是改变节点的位置，而是改变每一个节点next指针的指向。

下面直接看看LeetCode上的题目：

206. 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 *p = head;
        ListNode *q = head->next;
        head->next = NULL;
        while (q) {
            ListNode *r = q->next;
            q->next = p;
            p = q;
            q = r;
        }
        return p;
    }
};

其实就是不断地将当前访问到的位置的next指针指向它前面的指针，这是最基本的操作了。

 

92. Reverse Linked List II

这道题目规定了要进行反转的位置区间，比上一题加大了难度。我们要先添加一个头指针，指向head节点（最后返回头指针的next即可）；然后一直往后访问，一直到要反转的节点的前一位停下来。

我们要记录下两个节点的位置：开始反转位置的节点的前一位、开始反转位置的节点。因为在反转后，开始反转的节点的前一个节点的next指针要指向反转的最后一个节点，开始反转的节点的next要指向反转的最后一个节点的后一个节点。

然后进行与上面一题同样的反转即可。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        if (m == n) return head;
        ListNode *cur = new ListNode(0);
        cur->next = head;
        ListNode *copy = cur;
        for (int i = 0; i < m - 1; i++) {
            cur = cur->next;
        }
        ListNode *temp1 = cur, *temp2 = cur->next;
        cur = cur->next;
        ListNode *p = cur, *q = cur->next;
        for (int i = m; i < n; i++) {
            ListNode *r = q->next;
            q->next = p;
            p = q;
            q = r;
        }
        temp1->next = p;
        temp2->next = q;
        return copy->next; 
    }
};

 

234. Palindrome Linked List

这一题要求在O(n)的时间复杂度和O(1)的空间复杂度下，判断一个链表是否回文链表。

我们可以利用一快一慢两个指针同时前进，当快指针到链表的末尾（即不能往后走）时，慢指针就走到序列中间。（这里有一点值得注意，就是无论节点个数是奇数还是偶数，此时从慢指针指向的节点的后一个节点开始反转就可以了）。反转后，对链表的前半部分和后半部分逐个比较即可。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        ListNode *copy = head;
        if (head == NULL || head->next == NULL) return true;
        ListNode * slow = head, *fast = head;
        while (fast->next && fast->next->next) {
            slow = slow->next;
            fast = fast->next->next;
        }
        slow = slow->next;
        ListNode *p = slow;
        ListNode *q = slow->next;
        slow->next = NULL;
        while (q) {
            ListNode *r = q->next;
            q->next = p;
            p = q;
            q = r;
        }
        while (p) {
            if (p->val != copy->val) {
                return false;
            }
            p = p->next;
            copy = copy->next;
        }
        return true;
    }
};