【剑指Offer】链表

刷题 专栏收录该内容
36 篇文章 0 订阅

今天是《剑指Offer》系列的第二天,主要内容是链表,题目还是比较容易的,三道题,两道简单一道中等,加油。

从尾到头打印链表

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

示例 1:

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

限制:

0 <= 链表长度 <= 10000

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void reverse(ListNode *head, vector<int> &ans){
        if(head == nullptr)return;
        reverse(head->next, ans);
        ans.push_back(head->val);
    }
    vector<int> reversePrint(ListNode* head) {
        vector<int> ans;
        if(head == nullptr)return ans;
        reverse(head->next, ans);
        ans.push_back(head->val);
        return ans;
    }
};

算法思路:

这道题是要求是从尾到头输出,第一想到的就是栈,栈有先进后出的特性,该题用栈存储就可以很容易地解决,而解法一用的是递归,其实也是栈的一种,对于题一来说有点小题大作,但递归也是栈的一种,而且递归可扩充性很强,遇到比较复杂一点的题在原本的框架上稍加修改就能解决。
结果

ps:这题其实要容易有很多解法,比如直接存数组然后反转还有直接用栈,题目太简单了,所以不详细说。

反转链表

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

示例:

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

限制:

0 <= 节点个数 <= 5000

解法一:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverse(ListNode *head){
        if(head->next == nullptr)return head;
        ListNode *h = reverse(head->next);
        head->next->next = head;
        head->next = nullptr;
        return h;
    }
    ListNode* reverseList(ListNode* head) {
        if(head == nullptr)return nullptr;
        return reverse(head);
    }
};

算法思路:

和第一题相比,第二题加了next指针指向的改变,在第一题框架的基础上,我在函数上加了个返回值,返回的是链表反转后的头指针,而函数传递的参数是要反转的链表,调用reverse(head->next)后,以head->next为头的链表已经反转完成且head->next成为反转后的尾结点,此时只需对head->next->next修改一下则完成反转。

解法一结果

解法二:

/**
 * 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 *pre = nullptr, *p = head;
        while(p){
            ListNode *tmp = p->next;
            p->next = pre;
            pre = p;
            if(tmp != nullptr){
                p = tmp;
            }else{
                return p;
            }
        }
        return nullptr;
    }
};

算法思路:

遍历每个结点然后将结点指向pre结点。
解法二结果

复杂链表的复制

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

示例 1:

输入:head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出:[[7,null],[13,0],[11,4],[10,2],[1,0]]

示例 2:

输入:head = [[1,1],[2,1]]
输出:[[1,1],[2,1]]

示例 3:

输入:head = [[3,null],[3,0],[3,null]]
输出:[[3,null],[3,0],[3,null]]

示例 4:

输入:head = []
输出:[]
解释:给定的链表为空(空指针),因此返回 null。

提示:

  • -10000 <= Node.val <= 10000
  • Node.random 为空(null)或指向链表中的节点。
  • 节点数目不超过 1000

解法一:

/*
// 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 == nullptr)return nullptr;
        Node *ans = new Node(head->val), *p = head->next, *p1 = ans;
        ans->random = head->random;
        map<Node*, Node*> mp;
        mp[head] = ans;
        while(p){
            Node * nn = new Node(p->val);
            mp[p] = nn;
            nn->next = p->next;
            nn->random = p->random;
            p1->next = nn;
            p = p->next;
            p1 = p1->next;
        }
        p = head, p1 = ans;
        while(p1){
            if(p1->random != nullptr)p1->random = mp[p1->random];
            p = p->next;
            p1 = p1->next;
        }
        return ans;
    }
};

算法思路:

链表的复制比较简单,重点是random指针的改变,我用的是hash算法存储前后两个链表对应结点的关系,然后再一一转换,还是比较容易的,就是hash会占用较大的空间。
解法一结果

解法二:

/*
// 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 == nullptr)return nullptr;
        Node *p = head, *ans;
        while(p){
            Node *nn = new Node(p->val);
            nn->next = p->next;
            p->next = nn;
            p = nn->next;
        }
        p = head;
        while(p){
            if(p->random != nullptr)p->next->random = p->random->next;
            else p->next->random = nullptr;
            p = p->next->next;
        }
        p = head;
        ans = head->next;
        while(p){
            Node* tmp = p->next;
            p->next = p->next->next;
            p = p->next;
            if(tmp->next != nullptr)tmp->next = tmp->next->next;
        }

        return ans;
    }
};

算法思路:

解法二比较巧妙,每个新生成的结点并没有脱离原链表,而是接在老结点后面,复制一遍链表后,对偶数位的结点上的random指针进行修改,然后再对所有结点的next指针进行修改,分别改为指向下一个结点的下一个结点,就是奇偶位的结点分开,分成两个链表,奇结点为旧链表,偶结点则为答案。

解法二结果

最后

今天的题依旧比较简单,考察的是链表的应用,希望我的博客能对你有所帮助。

新人博主发博,恳请各位不吝赐教,不胜感激,晚安。

题目链接:
从头到尾打印链表
反转链表
复杂链表复制

【剑指Offer】系列:
【剑指Offer】栈

  • 1
    点赞
  • 0
    评论
  • 1
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 深蓝海洋 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值