【每日小练】

一、 环形链表

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

为了表示给定链表中的环，我们使用整数 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
解释：链表中没有环。

解题思路一：用map存储下 如果出现过就代表有环

/**
 * 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) {
        map<ListNode*,int> mp;
        while(head){
            if(mp.count(head)){
                return true;
            }
            else{
                mp[head] = 1;
            }
            head=head->next;
        }
        return false;
    }
};

解题思路二：同时遍历一个快一个慢如果快的追上慢的就代表有环，这样空间复杂度为O（1）

/**
 * 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) {
        ListNode *low = head;
        ListNode *up = head;
        while(up!=NULL && up->next!=NULL){
            //快的走两步
            up=up->next->next;
            //慢的走一步
            low = low->next;
            if(up == low){
                return true;
            }
        }
        return false;
    }
};

二、删除链表的倒数第N个节点

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

示例：

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

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

给定的 n 保证是有效的。

解题思路：遍历一遍长度 然后删除就ok了

/**
 * 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) {
    ListNode* tmp = new ListNode();
    tmp->next = head;
    //求长度
    ListNode *i = tmp;
    //执行删除操作
    ListNode *j = tmp;
    int len = 0;
    while(i != NULL){
        len ++;
        i = i->next;
    }
    len -= n;
    while(len>1){
        len --;
        j=j->next;
    }
    j->next = j->next->next;
    return tmp->next;
    }
};

三、全排列

给定一个 没有重复 数字的序列，返回其所有可能的全排列。

示例:

输入: [1,2,3]
输出:
[
  [1,2,3],
  [1,3,2],
  [2,1,3],
  [2,3,1],
  [3,1,2],
  [3,2,1]
]

class Solution {
public:
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> ans;
        dfs(ans,nums,0,(int)nums.size());
        return ans;
    }
    void dfs(vector<vector<int>>& ans, vector<int> &tmp,int l, int len){
        if(l == len){
            ans.push_back(tmp);
            return;
        }
        for(int i=l; i<len; i++){
            //交换
            swap(tmp[i],tmp[l]);
            //继续递归
            dfs(ans,tmp,l+1,len);
            //交换回来
            swap(tmp[i],tmp[l]);
        }
    }

};

来源：力扣（LeetCode）