【leetcode】2.两数相加

最新推荐文章于 2023-05-29 20:30:00 发布

YEGE学AI算法

最新推荐文章于 2023-05-29 20:30:00 发布

阅读量202

点赞数 1

文章标签：深度学习算法人工智能

本文链接：https://blog.csdn.net/yegeli/article/details/118343176

版权

【leetcode】2.两数相加

题目描述

给出两个非空的链表用来表示两个非负的整数。其中，它们各自的位数是按照逆序的方式存储的，并且它们的每个节点只能存储一位数字。如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

题目示例
示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

解题思路:

利用哑结点和进位值求解链表l1和l2的结果集res，在求解进位的时候，需要注意进位值carry为或者，因为链表l1和l2值的范围在0~9之间，按照最大的算也是9+9+1=19，进位值carry=1，所以不存在溢出的情况。
Step1：初始化哑结点dummyHead和进位值carry=0；
Step2：链表l1和l2逐位求和，即sum=l1->val + l2->val + carry；
Step3：判断是否有进位值，即carry = sum /10，若结果为0表示没有进位，否则更新进位值carry；
Step4：创建一个数值为sum%10的新节点，并将其设置为当前节点的下一个节点，也就是结果集的第一个节点；
Step5：移动当前节点至下一个节点，并更新链表l1和l2；

程序解法

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        int carry = 0;
        ListNode sumHead = new ListNode(-1);
        ListNode sumNode = sumHead;   
        while (l1 != null || l2 != null) {
            // 求和
            int x = l1 != null ? l1.val : 0;
            int y = l2 != null ? l2.val : 0;
            int sum = x + y + carry;
            if (sum >= 10) {
                carry = 1;
                sum = sum - 10;
            } else {
                carry = 0;
            }
            sumNode.next = new ListNode(sum);
            // 三个指针后移
            l1 = l1 != null ? l1.next : null;
            l2 = l2 != null ? l2.next : null;
            sumNode = sumNode.next;
        }
        if (carry != 0) {
            sumNode.next = new ListNode(carry);
        }
        return sumHead.next;
    }
}

/**

Definition for singly-linked list.
struct ListNode {
```
int val;
```
```
ListNode *next;
```

ListNode(int x) : val(x), next(NULL) {}

};
/
class Solution {
public:
ListNode addTwoNumbers(ListNode* l1, ListNode* l2) {
if(l1 == nullptr) return l2;
if(l2 == nullptr) return l1;
ListNode* dummyHead = new ListNode(-1); //哑结点
ListNode* curNode = dummyHead;
int carry = 0; //进位值，其值为0或者1
while(l1 || l2)
{
int sum = 0;
if(l1 != nullptr)
{
sum += l1->val;
l1 = l1->next;
}
if(l2 != nullptr)
{
sum += l2->val;
l2 = l2->next;
}
sum += carry;
carry = sum / 10;
curNode->next = new ListNode(sum % 10);
curNode = curNode->next;
}
if(carry == 1)
{
curNode->next = new ListNode(carry);
}
return dummyHead->next;
}
};

class Solution {
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
ListNode *head = nullptr, *tail = nullptr;
int carry = 0;
while (l1 || l2) {
int n1 = l1 ? l1->val: 0;
int n2 = l2 ? l2->val: 0;
int sum = n1 + n2 + carry;
if (!head) {
head = tail = new ListNode(sum % 10);
} else {
tail->next = new ListNode(sum % 10);
tail = tail->next;
}
carry = sum / 10;
if (l1) {
l1 = l1->next;
}
if (l2) {
l2 = l2->next;
}
}
if (carry > 0) {
tail->next = new ListNode(carry);
}
return head;
}
};

**复杂度分析**

- 时间复杂度：$O(\max(m,n))$，其中 m 和 n 分别为两个链表的长度。我们要遍历两个链表的全部位置，而处理每个位置只需要 $O(1)$的时间。

- 空间复杂度：$O(1)$。注意返回值不计入空间复杂度。




## 知识点
#### 一：链表是什么
1、链表是物理存储单元上非连续的、非顺序的存储结构，数据元素的逻辑顺序是通过链表的指针地址实现，有一系列结点（地址）组成，结点可动态的生成。

2、结点包括两个部分：（1）存储数据元素的数据域（内存空间），（2）存储指向下一个结点地址的指针域。

3、相对于线性表顺序结构，操作复杂。

4.链表分为 （1）单链表 （2）双链表 （3）单向循环链表 （4）双向循环链表

 

#### 二：链表的作用
1、实现数据元素的存储按一定顺序储存，允许在任意位置插入和删除结点。

2、包括单向结点，双向结点，循环接点

 

### 三：链表与数组的区别
说到链表那肯定要聊一下数组，为什么会出现链表呢？

（1）数组：使用一块连续的内存空间地址去存放数据

	例如：
	int  a[5]={1,2,3,4,5}；       突然我想继续加两个数据进去，但是已经定义好的数组不能往后加，只能通过定义新的数组
	int b[7]={1,2,3,4,5,6,7};     这样就相当不方便比较浪费内存资源,对数据的增删不好操作。

（2）链表：使用多个不连续的内存空间去存储数据， 可以 节省内存资源（只有需要存储数据时，才去划分新的空间），对数据的增删比较方便。
#### 四：如何理解链表
理论的东西我就不说太多了，下面我将以代码+图形的方式让大家很通俗易懂的理解链表。

（1）单链表的结构体

struct node
{
int data;//存放数据
struct node *next; //地址域（与节点的类型地址相匹配）

};

![](https://img-blog.csdnimg.cn/d44bcc73790644349c59e126b12ca88a.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5Zu-5YOP566X5rOVQUk=,size_15,color_FFFFFF,t_70,g_se,x_16)
（2）创建链表的新节点

struct node *creat_node(int data)
{
struct node *new = malloc(sizeof(struct node));
new->data = data;
new->next = NULL;

return  new;

}

![](https://img-blog.csdnimg.cn/af620e0c624e471fa1669e2d67ce314c.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5Zu-5YOP566X5rOVQUk=,size_20,color_FFFFFF,t_70,g_se,x_16)
（3）插入节点

struct node* insert_node(struct nodep,struct nodenew)
{
p->next = new;
}t

![](https://img-blog.csdnimg.cn/a5131c68708b4e02a9b79608356bcb2c.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5Zu-5YOP566X5rOVQUk=,size_20,color_FFFFFF,t_70,g_se,x_16)
（4）显示链表

void show(struct node *p)
{
while(1)
{
if(p== NULL) //假设p已经为NULL则返回
{
return ;
}
printf(“p=%d\n”,p->data);
p = p->next; //链表的重要知识点！！！遍历节点向下走
}
}

![](https://img-blog.csdnimg.cn/f9490ae49cd541669e1c3204e9f7b3e1.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5Zu-5YOP566X5rOVQUk=,size_20,color_FFFFFF,t_70,g_se,x_16)
### 五：单链表完整代码

#include <stdio.h>
#include <stdlib.h>
//设计链表的节点
struct node
{
int data;//存放数据
struct node *next; //存放地址（与节点的类型地址相匹配）

};

//创建节点
struct node *creat_node(int data)
{
struct node *new = malloc(sizeof(struct node));
new->data = data;
new->next = NULL;
return new;
}

//插入节点（链接节点）
struct node* insert_node(struct nodep,struct nodenew)
{
p->next = new;
}

//显示节点数据（遍历节点）
void show(struct node *p)
{
while(1)
{
if(p== NULL) //假设p已经为NULL则返回
{
return ;
}
printf(“p=%d\n”,p->data);
p = p->next; //链表的重要知识点！！！遍历节点向下走
}
}

int main()
{

//1.分配节点空间
struct node  *a0 = creat_node(100); 
struct node  *a1 = creat_node(200); 
struct node  *a2 = creat_node(300);


inser_node(a0,a1);
inser_node(a1,a2);


//通过a0  访问a0  a1  a2的数据    //3.访问节点中的数据 
//printf("a0=%d,a1=%d,a2=%d\n",a0.data,a0.next->data,a0.next->next->data);


show(a0);

}

YEGE学AI算法

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
【leetcode】2.两数相加

题目描述给出两个非空的链表用来表示两个非负的整数。其中，它们各自的位数是按照逆序的方式存储的，并且它们的每个节点只能存储一位数字。如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。您可以假设除了数字 0 之外，这两个数都不会以 0 开头。题目示例示例：输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)输出：7 -> 0 -> 8原因：342 + 465 = 807解题思路利用哑结点和进位值求解链表l1和l2的结果
复制链接

扫一扫