刷题计划（第2天）

时间：2022.4.17

题数：3

题目类型：链表

1.反转链表

###定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

第一次尝试了最简单的方法，和王道上面的3指针方法一样，属于是最容易想到的想法了

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

击败了95%，但可以尝试下其他解法

第二次使用递归，但不一定有前面迭代的快

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

意外得居然一样，第一次提交的8ms，是没有考虑特殊情况

2.从尾到头打印链表

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

第一种方式是先存入数组当中，然后反转，思路简单又好写

 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        vector<int> node;
        ListNode* q=head;
        while(q){
            node.push_back(q->val);
            q=q->next;
        }
        reverse(node.begin(),node.end());
        return node;
    }
};

3.复杂链表的复制

请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。

第一种解法：先复制每个结点，然后在分离掉，就可以得到复制后的结点

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/
class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(head==NULL) return head;
        Node* node=head;
        Node* copy=NULL;
        for (;node!=NULL; node = node->next->next) {
            Node* copy = new Node(node->val);
            copy->next = node->next;
            node->next = copy;
        }
        node=head;
        for (; node != NULL; node = node->next->next) {
            Node* copy = node->next;
            copy->random = (node->random != NULL) ? node->random->next : NULL;
        }
        Node* newhead=head->next;
        node=head;
        Node* temp=NULL;
        for(;node!=NULL&&node->next!=NULL;){
            temp=node->next;
            node->next=temp->next;
            node=temp;
        }
        return newhead;
    }
};

看起来需要大优化一下，将for循环里面的更加简洁一点

总结

链表的复制和基本应用，还有反转链表的递归和迭代写法