2021-10-10周总结

最新推荐文章于 2025-12-18 17:00:31 发布

原创最新推荐文章于 2025-12-18 17:00:31 发布 · 102 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#链表 #算法

算法专栏收录该内容

89 篇文章

订阅专栏

本文介绍了LeetCode上的四道链表题目，包括两数相加、排序链表、K个一组翻转链表和两数相加II。通过详细的问题分析、解题思路及代码实现，展示了如何处理链表结构的数学运算、排序和反转操作，是提升链表处理能力的好资料。

一、问题总结

二、问题复盘

2.1LeetCode: 2. 两数相加

(1)问题描述

给你两个非空的链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例 1：

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.
示例 2：

输入：l1 = [0], l2 = [0]
输出：[0]
示例 3：

输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

(2)问题分析

这道题可以定义一个辅助指针，当链表不为NULL的时候,定义一个整数t分别加上两个节点的值，最后利用除以和取余来获取链表。

(3)代码实现

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
       ListNode dummy=new ListNode(-1);
       ListNode pre=dummy;
       int t=0;
       while(t!=0||l1!=null||l2!=null){
           if(l1!=null){
               t+=l1.val;
               l1=l1.next;
           }
           if(l2!=null){
               t+=l2.val;
               l2=l2.next;
           }
          pre.next=new ListNode(t%10);
          pre=pre.next;
            t=t/10;
       }
       return dummy.next;
    }
}

2.2LeetCode:148. 排序链表

(1)题目描述:

示例 1：

输入：head = [4,2,1,3]
输出：[1,2,3,4]
示例 2：

输入：head = [-1,5,3,4,0]
输出：[-1,0,3,4,5]
示例 3：

输入：head = []
输出：[]

(3)题目分析

做这道题之前，可以先看看合并两个链表那道题，所以这块的思路可以往合并方向想，将一个链表分成两个链表，按照两个链表合并的方法做，就可以解决问题。这道题用递归的时候不要忘记递归结束条件。

(4)代码实现

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode sortList(ListNode head) {
      return sortList(head,null);
    }

    public ListNode sortList(ListNode head, ListNode tail) {
        if(head==null){
            return head;
        }if(head.next==tail){
            head.next=null;
            return head;
        }
        ListNode slow=head;ListNode fast=head;
       while(fast!=tail){
           slow=slow.next;
           fast=fast.next;
           if(fast!=tail){
               fast=fast.next;
           }
       }
        ListNode mid=slow;
        ListNode list1 = sortList(head,mid);
        ListNode list2 = sortList(mid,tail);
        ListNode sorted=merge(list1,list2);
        return sorted;
    }
        public ListNode merge(ListNode head1,ListNode head2){
            ListNode dummyHead=new ListNode(0);
            ListNode temp=dummyHead,temp1=head1,temp2=head2;
            while(temp1!=null&&temp2!=null){
                if(temp1.val<=temp2.val){
                    temp.next=temp1;
                    temp1=temp1.next;
                }else{
                    temp.next=temp2;
                    temp2=temp2.next;
                }
                temp=temp.next;
            }
            if(temp1!=null){
                temp.next=temp1;
            }else if(temp2!=null){
                temp.next=temp2;
            }
            return dummyHead.next;
        }
}

2.3LeetCode:25. K 个一组翻转链表

(1)题目描述

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。

k 是一个正整数，它的值小于或等于链表的长度。

如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

进阶：

你可以设计一个只使用常数额外空间的算法来解决此问题吗？
你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

示例 1：

输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]
示例 2：

输入：head = [1,2,3,4,5], k = 3
输出：[3,2,1,4,5]
示例 3：

输入：head = [1,2,3,4,5], k = 1
输出：[1,2,3,4,5]
示例 4：

输入：head = [1], k = 1
输出：[1]

(2)题目分析:

做这道题之前应该先做一遍反转链表，这道题目主要是在反转链表的基础上利用一个for循环循环到K个节点，然后反转，如果链表剩下的不足K个则不反转,这里主要注意的是链表的断开和连接。

(3)代码实现

/**
 * 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* reverse(ListNode* head){
        ListNode temp=NULL;
        ListNode cur=head;
        while(cur!=nullptr){
            ListNode* temp1=cur.next;
            cur.next=temp;
            temp=cur;
            cur=temp1;
        }
        return temp;
    }
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode* dummy=new ListNode(0);
        dummy->next=head;
        ListNode* curr=dummy;
        ListNode* tail=dummy;
        ListNode* start,next;
        while(tail.next!=null){
            for(int i=0;i<k&&tail!=null;i++){
                tail=tail.next;
            }
            if(tail==nullptr){
                break;
            }
            next=tail->next;
            start=pre->next;
            tail->next=NULL;
            pre->next=reverse(start);
            start->next=next;
            pre=start;
            tail=pre;
    }
    return curr->next;
};

2.4LeetCode:445. 两数相加 II

(1)问题描述:

给你两个非空链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。

你可以假设除了数字 0 之外，这两个数字都不会以零开头。

示例1：

输入：l1 = [7,2,4,3], l2 = [5,6,4]
输出：[7,8,0,7]
示例2：

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[8,0,7]
示例3：

输入：l1 = [0], l2 = [0]
输出：[0]

(2)问题解析

像这种逆序的题一般都用栈来解答，创建两个栈，分别将两个链表放入栈中，最后栈不为空，弹出元素，相加，使用除以或取余获得逆序后的链表

(3)代码实现

/**
 * 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* addTwoNumbers(ListNode* l1, ListNode* l2) {
        stack<int>s1,s2;
        while(l1!=NULL){
            s1.push(l1->val);
            l1=l1->next;
        }
        while(l2!=NULL){
            s2.push(l2->val);
            l2=l2->next;
        }
        ListNode* ans=NULL;
        int carry=0;
        while(!s1.empty()||carry!=0||!s2.empty()){
             int a = s1.empty() ? 0 : s1.top();
            int b = s2.empty() ? 0 : s2.top();
            if (!s1.empty()) s1.pop();
            if (!s2.empty()) s2.pop();
            int cur=a+b+carry;
            carry=cur/10;
            cur%=10;
            ListNode* curnode=new ListNode(cur);
            curnode->next=ans;
            ans=curnode;
        }
        return ans;
    }
};