C++算法之指针三剑客一

指针一：链表

1.数据结构介绍

（单）链表是由节点和指针构成的数据结构，每个节点存有一个值，和指向下一个节点的指针，因此很多链表问题可以用递归来处理。不同于数组，链表并不能直接获取任意节点的值，必须要通过指针找到该节点后才能获取其值。同理，在未遍历到链表结尾时，我们也无法知道链表的长度。除非以来其他数据结构储存长度。LeetCode默认的链表表示方法如下：

struct ListNode{
    int val;
    ListNode *next;
    ListNode(int x):val(x),next(nullptr){}
};

由于在进行链表操作时，尤其是删除节点时，经常会因为对当前节点进行操作而导致内存或指针出现问题。有两个小技巧可以解决这个问题：一是尽量处理当前节点的下一个节点而非当前节点本身，二是建立一个虚拟节点 (dummy node)，使其指向当前链表的头节点，这样即使原链表所有节点全被删除，也会有一个 dummy 存在，返回 dummy->next 即可。

2.链表的基本操作

题目一：翻转一个链表

链表翻转是非常基础也一定要掌握的技能。我们提供了两种写法——递归和非递归，且我们建议你同时掌握这两种写法。

递归的写法为：

ListNode* reverseList(ListNode*head,ListNode* prev=nullptr)
{
    if(!head){
        return prev;
    }
    ListNode* next=head->next;
    head->next=prev;
    return reverseList(next,head);
}

非递归的写法：

ListNode* reverseList(ListNode* head)
{
    ListNode *prev = nullptr,*next;
    while(head)
    {
        next = head->next;
        head->next = prev;
        prev = head;
        head = next;
    }
    return prev;
}

题目二：给定两个增序的链表，试将其合并成一个增序的链表。

我们提供了递归和非递归，共两种写法。递归的写法为：

ListNode* mergeTwoLists(ListNode* l1,ListNode* l2)
{
    if(!l2)
    {
        return l1;
    }
    if(!l1){
        return l2;
    }
    if(l1->val > l2->val){
        l2->next = mergeTwoLists(l1,l2->next);
        return l2;
    }
    l1->next = mergeTwoList(l1->next,l2);
    return l1;
}

非递归的写法：

ListNode* mergeTwoLists(ListNode *l1,ListNode *l2)
{
    ListNode *dummy = new ListNode(0),*node = dummy;
    while(l1 && l2){
        if(l1->val <= l2->val){
            node->next = l1;
            l1 = l1->next;
        }
        else{
            node->next = 12;
            l2 = l2->next;
        }
    }
    node->next = l1? l1:l2;
    return dummy->next;
}
                 

题目三：给定一个矩阵，交换每个相邻的一对节点。

利用指针进行交换操作，没有太大难度，但一定要细心。

ListNode* swapPairs(ListNode* head)
{
    ListNode *p = head, *s;
    if(p && p->next)
    {
        s=p->next;
        p->next=s->next;
        s->next=p;
        head=s;
        while(p->next && p->next->next)
        {
            s=p->next->next;
            p->next->next=s->next;
            s->next=p->next;
            p->next=s;
            p=s->next;
        }
    }
    return head;
}

3.其他链表技巧

题目一：给定两个链表，判断它们是否相交于一点，并求这个相交节点。

假设链表 A 的头节点到相交点的距离是 a，链表 B 的头节点到相交点的距离是 b，相交点到链表终点的距离为 c。我们使用两个指针，分别指向两个链表的头节点，并以相同的速度前进，若到达链表结尾，则移动到另一条链表的头节点继续前进。按照这种前进方法，两个指针会在a + b + c 次前进后同时到达相交节点。

ListNode *getIntersectionNode(ListNode *headA,ListNode *headB)
{
    ListNode *l1 = headA, *l2 = headB;
    while(l1 != l2){
        l1 = l1?l1->next:headB;
        l2 = l2?l2->next:headA;
    }
    return l1;
}

题目二：以 O(1) 的空间复杂度，判断链表是否回文。

先使用快慢指针找到链表中点，再把链表切成两半；然后把后半段翻转；最后比较两半是否相等。

//主函数
bool isPalindrome(ListNode* head)
{
    if(!head || !head->next)
    {
        return true;
    }
    ListNode *slow = head, *fast = head;
    while(fast->next && fast->next->next)
    {
        slow = slow->next;
        fast = fast->next->next;
    }
    slow->next = reserveList(slow->next);
    solw = slow->next;
    while(slow)
    {
        if(head->val != slow->next){
            return false;
        }
        head = head->next;
        slow = slow->next;
    }
    return true;
}
//辅函数
ListNode* reverseList(ListNode* head)
{
    ListNode *prev = nullptr, *next;
    while(head){
        head->next = prev;
        prev = head;
        head = next;
    }
    return prev;
}

ps:中秋节后第一天上班，上午多少有些困乏，不过下午整了点东西，也不算虚度，眼看LeetCode快要刷完了，其中算法还基本是一知半解，后期道阻且长，如果偶尔停止思考，那接下来便是长时间的弥补前期失误，所以既来之，则安之。