LeetCode链表处理集锦(一）

273.删除链表中的节点
题目描述：
请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。
现有一个链表 – head = [4,5,1,9]，它可以表示为:

示例 1:
输入: head = [4,5,1,9], node = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.
示例 2:
输入: head = [4,5,1,9], node = 1
输出: [4,5,9]
解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.
说明:
链表至少包含两个节点。
链表中所有节点的值都是唯一的。
给定的节点为非末尾节点并且一定是链表中的一个有效节点。
不要从你的函数中返回任何结果。

个人思路：
指针移动。注意顺序。
实现代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void deleteNode(ListNode* node) {
        node->val = node->next->val;
        node->next = node->next->next;
    }
};

--------------------------------------------------------------------------------------------5月16日

206.反转链表
题目描述：
反转一个单链表。
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
进阶:
你可以迭代或递归地反转链表。你能否用两种方法解决这道题

递归方法：

/**
 * 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 *new_head = reverseList(head->next);
        head->next->next = head;
        head->next = NULL;
        return new_head;
    }
};

迭代方法：

/**
 * 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) {
        ListNode *pre = NULL, *cur = head, *r = NULL;
        while(cur != NULL) {
            r = cur->next;
            cur->next = pre;
            pre = cur;
            cur = r;
        }
        return pre;
    }
};

结果：

-------------------------------------------------------------------------------------------5月17日
160.相交链表
题目描述：
编写一个程序，找到两个单链表相交的起始节点。
如下面的两个链表：

个人思路：

（一）暴力

遍历A，A的每一个结点都从头遍历B，看是否存在相同的结点。知道找到相同结点或者A遍历完。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if(headA == NULL || headB == NULL)
            return NULL;
        while(headA != NULL)
        {
            ListNode *p = headB;
            while(p !=  NULL)
            {
                if(p == headA)
                    return p;
                else
                    p = p->next;
            }
            headA = headA->next;
        }
        return NULL;
    }
};

（二）

第二种参考大佬的方法，记录A、B长短，求得A、B的差x，若存在交点，则从最后一个到交点的位置长度应该相等，这样长的链表后移x位置，再遍历A、B，直到找到相同的结点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if(headA == NULL || headB == NULL)
            return NULL;
        ListNode *p = headA;
        ListNode *q = headB;
        int lenA = 0, lenB = 0;
        //计算A长度
        while(p->next != NULL)
        {
            p = p->next;
            lenA++;
        }
        //计算B长度
        while(q->next != NULL)
        {
            q = q->next;
            lenB++;
        }
        int x = lenA-lenB > 0 ? lenA-lenB : lenB-lenA;
        //将长的链表走x位置
        if(lenA > lenB)
        {
            for(int i = 0; i < x; ++i)
                headA = headA->next;
        }
        else
        {
            for(int i = 0; i < x; ++i)
                headB = headB->next;
        }
        while(headA != headB)
        {
            headA = headA->next;
            headB = headB->next;
        }
        return headA;
    }
};

结果显示：

-------------------------------------------------------------------------------------------5月18日