【解题报告】 LeetCode

JYSimilar

于 2022-05-12 17:01:09 发布

阅读量315

点赞数 1

文章标签： leetcode 链表算法

本文链接：https://blog.youkuaiyun.com/JYSimilar/article/details/124733529

版权

这篇博客介绍了四个关于链表的操作：如何将一个表示二进制数的链表转换为十进制数，如何在不访问头节点的情况下删除链表中的指定节点，如何反转链表，以及如何找到链表中每个节点的下一个更大值。通过示例代码展示了具体的实现方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、1290. 二进制链表转整数

题目描述

给你一个单链表的引用结点 head。链表中每个结点的值不是 0 就是 1。已知此链表是一个整数数字的二进制表示形式。
请你返回该链表所表示数字的十进制值。

代码示例

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
    int GetListLength(ListNode *head){
        ListNode *tmp=head;
        int cnt=0;
        while(tmp){
            ++cnt;
            tmp=tmp->next;
        }
        return cnt;
    }
public:
    int getDecimalValue(ListNode* head) {
        ListNode* use=head;
        int len=GetListLength(head);
        int res=0;
        while(len>0){
            res+=use->val*pow(2,len-1);
            use=use->next;
            --len;
        }
        return res;
    }
};

解题记录

先求得链表长度，并用二进制转换至十进制的方法，求得结果

二、237. 删除链表中的节点

题目描述

请编写一个函数，用于删除单链表中某个特定节点。在设计函数时需要注意，你无法访问链表的头节点 head ，只能直接访问要被删除的节点。
题目数据保证需要删除的节点不是末尾节点。

代码示例

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void deleteNode(ListNode* node) {
        ListNode* tmp=node->next;
        node->val=node->next->val;
        node->next=node->next->next;
        delete tmp;
        tmp=NULL;
    }
};

解题记录

这道题给我们讲了一个道理，想要杀掉一个人，就成为他，并让他被变成无关的人，然后再杀掉他

用一个指针指向需要删除node的下一位，等下需要释放这一位
然后让需要删除的node的val next都复制为下一位的值，
最后删除刚刚指针指向的内存

三、剑指 Offer II 024. 反转链表

题目描述

给定单链表的头节点 head ，请反转链表，并返回反转后的链表的头节点。

代码示例

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode *pre=nullptr,*vtx;
        vtx=head;
        while(vtx){
            ListNode *tmp=vtx->next;
            vtx->next=pre;
            pre=vtx;
            vtx=tmp;
        }
        return pre;
    }
};

解题记录

相当于将链表的指针翻转即可。

四、1019. 链表中的下一个更大节点

题目描述

给定一个长度为 n 的链表 head
对于列表中的每个节点，查找下一个更大节点的值。也就是说，对于每个节点，找到它旁边的第一个节点的值，这个节点的值严格大于它的值。
返回一个整数数组 answer ，其中 answer[i] 是第 i 个节点( 从1开始 )的下一个更大的节点的值。如果第 i 个节点没有下一个更大的节点，设置 answer[i] = 0 。

代码示例

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
    int FindNextLargerNode(ListNode* head){
        ListNode *use=head;
        int lar=use->val;
        use=use->next;
        while(use){
            if(use->val > lar){
                return use->val;
            }
            use=use->next;
        }
        return 0;
    }
public:
    vector<int> nextLargerNodes(ListNode* head) {
        vector<int> ans;
        ListNode *use=head;
        while(use){
            int tmp=FindNextLargerNode(use);
            ans.push_back(tmp);
            use=use->next;
        }
        return ans;
    }
};