链表

1.LeetCode 206. 反转链表

反转一个单链表。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

 步骤：

0.初始时，pre = NULL，cur = head，pre来保存已经反转好的头节点，cur来保存正要反转的节点（即pre后面的节点）；nxt来保存要反转的节点的下一个节点，防止原链表断裂。

1.先将正要反转的节点的下一个节点用nxt保存；

2.反转，cur->next直接指向pre;

3.pre往后挪一步；

4.cur往后挪一步。

最后，pre得到了最后一个节点，也就是反转后的头节点。

 代码：

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

其他方法：（1）可以用栈，（2）递归

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head==NULL||head->next==NULL) return head;
        ListNode* pReverseNode=reverseList(head->next);
        head->next->next=head;
        head->next=NULL;
        return  pReverseNode;
    }
};

2.LeetCode 141. 环形链表

给定一个链表，判断链表中是否有环。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。

 

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        if(head == NULL || head->next == NULL || head->next->next == NULL)
            return false;
        ListNode* fast = head->next->next, *slow = head;//fast先走2步,以免头指针相等判错
        while(fast != NULL || slow != NULL){
            if(fast == slow)
                return true;
            else if(fast->next == NULL || fast->next->next == NULL){//若没环，fast肯定先到尾
                return false;
            }
            else{
                fast = fast->next->next;
                slow = slow->next;
            }
        }
        return false;
    }
};

3.LeetCode 21. 合并两个有序链表

将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 

示例：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(l1 == NULL || l2 == NULL)
            return l1 ? l2 = l1 : l2;
        ListNode *cur = l1->val > l2->val ? l2 : l1;
        if(l1->val >l2->val)
            l2 = l2->next;
        else
            l1 = l1->next;
        ListNode *head = cur;
        while(l1 != NULL && l2 != NULL){
            if(l1->val >l2->val){
                 cur->next = l2;
                l2 = l2->next;
            }else{
                 cur->next = l1;
                l1 = l1->next;
            }   
            cur = cur->next;
        }
        if(l1) cur->next = l1;
        if(l2) cur->next = l2;
        return head;
        
    }
};

4.LeetCode 19. 删除链表的倒数第N个节点

给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。

示例：

给定一个链表: 1->2->3->4->5, 和 n = 2.

当删除了倒数第二个节点后，链表变为 1->2->3->5.

说明：

给定的 n 保证是有效的。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        if(head == NULL)
            return head;
        ListNode* fast = head, *slow = head;
        while(fast != NULL){
            if(n < 0){
               slow = slow->next;
            }
             fast = fast->next;
            --n;
        }
        if(slow == head && n >= 0)//[1,2] 1 时 n<-1但是slow=head;[1,2] 2 时 亦slow=head 但 n=0
            return head->next;
        if(slow->next != NULL)//注意快慢都走到最后
        slow->next = slow->next->next;
       return head; 
    }
};

注意几个极端情况：（1）删除最后一个元素；（2）删除第一个元素；（3）n=0

5.LeetCode 876. 链表的中间结点

给定一个带有头结点 head 的非空单链表，返回链表的中间结点。

如果有两个中间结点，则返回第二个中间结点。

 

示例 1：

输入：[1,2,3,4,5]
输出：此列表中的结点 3 (序列化形式：[3,4,5])
返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。
注意，我们返回了一个 ListNode 类型的对象 ans，这样：
ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NULL.

示例 2：

输入：[1,2,3,4,5,6]
输出：此列表中的结点 4 (序列化形式：[4,5,6])
由于该列表有两个中间结点，值分别为 3 和 4，我们返回第二个结点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        ListNode* fast = head, *slow = head;
        while( fast != NULL && fast->next != NULL){//偶数个fast会走到NULL（fast==NULL）此时可以把NULL当作链表的元素，slow此时为中间的第二个结点,奇数个fast会走到链尾(fast->next==NULL)
                fast = fast->next->next;
                slow = slow->next;          
        }
        return slow;
    }
};

6.LeetCode 146. LRU缓存机制

运用你所掌握的数据结构，设计和实现一个  LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。

获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。
写入数据 put(key, value) - 如果密钥不存在，则写入其数据值。当缓存容量达到上限时，它应该在写入新数据之前删除最近最少使用的数据值，从而为新的数据值留出空间。

进阶:

你是否可以在 O(1) 时间复杂度内完成这两种操作？

示例:

LRUCache cache = new LRUCache( 2 /* 缓存容量 */ );

cache.put(1, 1);
cache.put(2, 2);
cache.get(1);       // 返回  1
cache.put(3, 3);    // 该操作会使得密钥 2 作废
cache.get(2);       // 返回 -1 (未找到)
cache.put(4, 4);    // 该操作会使得密钥 1 作废
cache.get(1);       // 返回 -1 (未找到)
cache.get(3);       // 返回  3
cache.get(4);       // 返回  4