删除链表的倒数第n个节点---正则表达式匹配---两两交换链表中的节点

19.删除链表的倒数第n个节点

给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。
示例：
给定一个链表: 1->2->3->4->5, 和 n = 2.
当删除了倒数第二个节点后，链表变为 1->2->3->5.

说明：
给定的 n 保证是有效的。

进阶：
你能尝试使用一趟扫描实现吗？

思路：定义两个指针，快指针先走n步，之后快慢指针一起走，快指针走到头，慢指针刚好指向倒数第n个节点。在进行处理时候，定义了一个虚假头部dummyHead节点，dummyHead->next=head，原因是head节点可能是要删除的节点，比如测试用例是[1],1。最终返回dummyHead->next（如果head节点是要删除的节点，那么此时dummyHead->next指向的是head->next）。

/**
 * 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* dummyHead = new ListNode(0);
        dummyHead->next = head;

        ListNode* after = dummyHead;
        ListNode* front = dummyHead;
        for( int i = 0 ; i < n + 1 ; i ++ ){
            front = front->next;
        }

        while(front){
            front = front->next;
            after = after->next;
        }
        //front和after从head的前一个节点开始移动了n个节点，此时after->next是需要删除的节点
        ListNode* delNode = after->next;
        after->next = delNode->next;
        delete delNode;

        ListNode* retNode = dummyHead->next;
        delete dummyHead;

        return retNode;
        //为什么不直接返回head，因此测试用例是[1],1时候，head指向[1],而结果应该是[]
    }
};

题目来自于：https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/

10.正则表达式匹配

给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。

'.' 匹配任意单个字符
'*' 匹配零个或多个前面的那一个元素
所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。

说明:

s 可能为空，且只包含从 a-z 的小写字母。
p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。
示例 1:

输入:

s = "aa"
p = "a"

输出: false
解释: "a" 无法匹配 "aa" 整个字符串。
示例 2:

输入:

s = "aa"
p = "a*"

输出: true
解释: 因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此，字符串 "aa" 可被视为 'a' 重复了一次。
示例 3:

输入:

s = "ab"
p = ".*"

输出: true
解释: ".*" 表示可匹配零个或多个（'*'）任意字符（'.'）。
示例 4:

输入:

s = "aab"
p = "c*a*b"

输出: true
解释: 因为 '*' 表示零个或多个，这里 'c' 为 0 个, 'a' 被重复一次。因此可以匹配字符串 "aab"。
示例 5:

输入:

s = "mississippi"
p = "mis*is*p*."

输出: false

class Solution {
public:
    bool isMatch(string s, string p) {
        return isMatch(s,p,0,0);
    }
    bool isMatch(string& s,string& p,int i,int j){
        if(s[i]=='\0'&&p[j]=='\0') return true;
        if(s[i]!='\0'&&p[j]=='\0') return false;
        if(p[j+1]=='*'){
            if(s[i]==p[j]||(s[i]!='\0'&&p[j]=='.'))
                return isMatch(s,p,i,j+2)||isMatch(s,p,i+1,j);
            else
                return isMatch(s,p,i,j+2);
        }else{
            if(s[i]==p[j]||(s[i]!='\0'&&p[j]=='.'))
                return isMatch(s,p,i+1,j+1);
            else
                return false;
        }
    }
};

该题在这里有详细分析：https://blog.youkuaiyun.com/Vickers_xiaowei/article/details/89434230
题目来自于：https://leetcode-cn.com/problems/regular-expression-matching/

24.两两交换链表中的节点

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
示例:
给定 1->2->3->4, 你应该返回 2->1->4->3.
b=a->next;
a->next=b->next;
b->next=a;
如此两个相邻的节点a->b便成了b->a

上面成功交换了两个相邻节点a和b，此时pp和a指向同一个节点，这个节点是b->next。如下图

此时我们需要交换b->a之后两个节点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode **pp = &head, *a, *b;
        while ( (a = *pp) && (b = a->next)){
            a->next = b->next;
            b->next = a;
            *pp = b;//将b->a->....节点接到head之后，
            //如果没有这句代码，那么head仍然指向a节点，这样就把b节点给遗漏掉
            pp = &(a->next);//pp指向b，a、b已经完成交换，pp应该在后移一位，
        }
        return head;
    }
};

题目来自于：https://leetcode-cn.com/problems/swap-nodes-in-pairs/submissions/