LeetCode刷题--点滴记录002

最新推荐文章于 2022-09-20 16:57:13 发布

鲁棒最小二乘支持向量机

最新推荐文章于 2022-09-20 16:57:13 发布

阅读量161

点赞数

分类专栏：一起刷刷题笔记文章标签： leetcode 链表 c++ java python

本文链接：https://blog.csdn.net/qq_42078934/article/details/125135378

版权

笔记同时被 2 个专栏收录

221 篇文章 164 订阅

订阅专栏

一起刷刷题

23 篇文章 0 订阅

订阅专栏

2. 两数相加

要求

给你两个非空的链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

解题

C++版本

#include <iostream>
using namespace std;

//定义结构体
struct ListNode {
    int val;//当前结点的值
    ListNode* next;//指向下一个结点的指针
    ListNode() : val(0), next(nullptr) {}  // 重载函数，默认值为1
    ListNode(int x) : val(x), next(NULL) {}// 重载函数，初始化当前结点值为x，指针为空
    ListNode(int x, ListNode* next) : val(x), next(next) {}  // 重载函数，使用新的结点初始化
};
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        /* 定义一个新的链表用于存储求和的结果 */
        ListNode* dummyHead = new ListNode(0);
        ListNode* cur = dummyHead;
        /* 定义一个变量用于保存进位 */
        int carry = 0;

        while (l1 || l2 || carry) {
            /* 只要不为空就继续求和 */
            if (l1 != NULL) carry += l1->val;
            if (l2 != NULL) carry += l2->val;
            /* 创建一个结点插入到新的链表并且值初始化为l1->val+l2->val的个位数 */
            ListNode* tmp = new ListNode(carry % 10);
            /* 插入结点tmp因为是从头开始插入所以只需要每次更新cur */
            cur->next = tmp;
            cur = cur->next;
            /* 只要链表不为空就继续遍历下一个节点 */
            if (l1 != NULL) l1 = l1->next;
            if (l2 != NULL) l2 = l2->next;
            /* 获取上个结点的进位值 加到下个结点的运算中 */
            carry /= 10;
        }
        /* 不返回dummyHead因为这里相当于一个虚拟头结点 下一个才是真正的头结点 */
        return dummyHead->next;
    }
};

void AddToTail(ListNode* head, int val)//插入数据
{
    ListNode* prev = new ListNode(0); // 定义哨兵结点
    prev->next = head;  // 将哨兵结点放到头节点前
    ListNode* pNew = new ListNode(val);  // 初始化要加入的尾结点 
    ListNode* node = prev;
    while (node->next != nullptr)
        node = node->next;
    node->next = pNew;
    head = prev->next; // 从哨兵节点后取回头结点
    delete prev; // 释放哨兵结点的内存
}

void print(ListNode* phead)//输出
{
    ListNode* p = phead->next;
    while (p != NULL)
    {
        cout << p->val << " ";
        p = p->next;
    }
    cout << endl;
}

void test01()
{
    Solution s;
    ListNode* l1 = new ListNode(); // 初始化链表
    AddToTail(l1, 2);
    AddToTail(l1, 4);
    AddToTail(l1, 3);
    print(l1);
    ListNode* l2 = new ListNode(); // 初始化链表
    AddToTail(l2, 5);
    AddToTail(l2, 6);
    AddToTail(l2, 4);
    print(l2);
    ListNode* l3 = new ListNode(); // 初始化链表
    l3 = s.addTwoNumbers(l1, l2);
    print(l3);
}

void test02()
{
    Solution s;
    ListNode* l1 = new ListNode(); // 初始化链表
    AddToTail(l1, 0);
    print(l1);
    ListNode* l2 = new ListNode(); // 初始化链表
    AddToTail(l2, 0);
    print(l2);
    ListNode* l3 = new ListNode(); // 初始化链表
    l3 = s.addTwoNumbers(l1, l2);
    print(l3);
}

void test03()
{
    Solution s;
    ListNode* l1 = new ListNode(); // 初始化链表
    AddToTail(l1, 9);
    AddToTail(l1, 9);
    AddToTail(l1, 9);
    AddToTail(l1, 9);
    AddToTail(l1, 9);
    AddToTail(l1, 9);
    AddToTail(l1, 9);
    print(l1);
    ListNode* l2 = new ListNode(); // 初始化链表
    AddToTail(l2, 9);
    AddToTail(l2, 9);
    AddToTail(l2, 9);
    AddToTail(l2, 9);
    print(l2);
    ListNode* l3 = new ListNode(); // 初始化链表
    l3 = s.addTwoNumbers(l1, l2);
    print(l3);
}

int main()
{
    test01();
    cout << "------------------" << endl;
    test02();
    cout << "------------------" << endl;
    test03();

    system("pause");
    return 0;
}

在这里插入图片描述

Python版本

class ListNode(object):
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

class ListNode_handle():
    def __init__(self):
        self.cur_node = None
        
    def addNode(self,data):
        prehead = ListNode()
        p = prehead
        for item in data:
            node = ListNode(item)
            p.next = node
            p = node
        return prehead.next

    def print_ListNode(self,node):
        while node:
            # print ('\nnode: ', node, ' value: ', node.val, ' next: ', node.next)
            print(node.val, end=' ')
            node = node.next
        
class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        # 定义一个新的链表用于存储求和的结果
        result = ListNode()
        cur = result
        # 进位项
        carry = 0

        while l1 or l2 or carry :

            if l1 : carry += l1.val
            if l2 : carry += l2.val

            tmp = ListNode(carry%10)
            cur.next = tmp
            cur = cur.next
            
            if l1 : l1 = l1.next
            if l2 : l2 = l2.next
            
            carry = carry//10
            
        return result.next
                       
            
def test01():
    solution = Solution()
    l1 = ListNode()
    ListNode_1 = ListNode_handle()
    l1_list = [2, 4, 3]
    l1 = ListNode_1.addNode(l1_list)
    ListNode_1.print_ListNode(l1)
    print()
    l2 = ListNode()
    ListNode_2 = ListNode_handle()
    l2_list = [5, 6, 4]
    l2 = ListNode_2.addNode(l2_list)
    ListNode_2.print_ListNode(l2)
    print()
    l3 = ListNode()
    ListNode_3 = ListNode_handle()
    l3 = solution.addTwoNumbers(l1,l2)
    ListNode_3.print_ListNode(l3)
    print()

def test02():
    solution = Solution()
    l1 = ListNode()
    ListNode_1 = ListNode_handle()
    l1_list = [0]
    l1 = ListNode_1.addNode(l1_list)
    ListNode_1.print_ListNode(l1)
    print()
    l2 = ListNode()
    ListNode_2 = ListNode_handle()
    l2_list = [0]
    l2 = ListNode_2.addNode(l2_list)
    ListNode_2.print_ListNode(l2)
    print()
    l3 = ListNode()
    ListNode_3 = ListNode_handle()
    l3 = solution.addTwoNumbers(l1,l2)
    ListNode_3.print_ListNode(l3)
    print()    

def test03():
    solution = Solution()
    l1 = ListNode()
    ListNode_1 = ListNode_handle()
    l1_list = [9, 9, 9, 9, 9, 9, 9]
    l1 = ListNode_1.addNode(l1_list)
    ListNode_1.print_ListNode(l1)
    print()
    l2 = ListNode()
    ListNode_2 = ListNode_handle()
    l2_list = [9, 9, 9, 9]
    l2 = ListNode_2.addNode(l2_list)
    ListNode_2.print_ListNode(l2)
    print()
    l3 = ListNode()
    ListNode_3 = ListNode_handle()
    l3 = solution.addTwoNumbers(l1,l2)
    ListNode_3.print_ListNode(l3)
    print()  
            
if __name__=="__main__":
    test01()
    print("--------------")
    test02()
    print("--------------")
    test03()

在这里插入图片描述

Java版本

package com.hailei;

import javax.swing.event.ListDataEvent;
import java.util.List;

public class AddTwoNumbers {
    public static void main(String[] args) {
        int[] arr1 = {2,4,3};
        ListNode listNode1 = endAdd(null,arr1);
        printListNode(listNode1);
        int[] arr2 = {5,6,4};
        ListNode listNode2 = endAdd(null,arr2);
        printListNode(listNode2);
        printListNode(addTwoNumbers(listNode1,listNode2));
        System.out.println("-----------------------");
        ListNode listNode3 = new ListNode(0);
        printListNode(listNode3);
        ListNode listNode4 = new ListNode(0);
        printListNode(listNode4);
        printListNode(addTwoNumbers(listNode3,listNode4));
        System.out.println("-----------------------");
        int[] arr3 = {9,9,9,9,9,9,9};
        ListNode listNode5 = endAdd(null,arr3);
        printListNode(listNode5);
        int[] arr4 = {9,9,9,9};
        ListNode listNode6 = endAdd(null,arr4);
        printListNode(listNode6);
        printListNode(addTwoNumbers(listNode5,listNode6));
        System.out.println("-----------------------");

    }
    public static class ListNode {
        int val;
        ListNode next;
        ListNode() {}
        ListNode(int val) { this.val = val;}
        ListNode(int val, ListNode next) { this.val = val; this.next = next; }
    }
    public static ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode dummyHead = new ListNode(0);
        ListNode cur = dummyHead;
        int carry = 0;
        while (l1 != null || l2 != null) {
            int x = (l1 != null) ? l1.val : 0;
            int y = (l2 != null) ? l2.val : 0;
            int sum = carry + x + y;
            carry = sum / 10;
            cur.next = new ListNode(sum % 10);
            cur = cur.next;
            if (l1 != null) l1 = l1.next;
            if (l2 != null) l2 = l2.next;
        }
        if (carry > 0) {
            cur.next = new ListNode(carry);
        }
        return dummyHead.next;
    }

    public static ListNode endAdd(ListNode headNode, int[] val) {
        //头结点为空
        if (headNode == null) {
            headNode = new ListNode(val[0]);
        }else {
            //移动结点
            ListNode listNode = headNode ;
        }
        //移动结点
        ListNode listNode = headNode ;
        for (int i = 1; i < val.length; i++) {
            //插值
            ListNode listNode1 = new ListNode(val[i]);
            //连接下个结点
            listNode.next = listNode1;
            //指针移到末尾
            listNode = listNode.next;
        }
        return headNode;
    }

    public static void printListNode(ListNode headNode) {
        ListNode listNode = headNode;
        while(listNode!=null) {
            System.out.print(listNode.val+" ");
            listNode = listNode.next;
        }
        System.out.println();
    }

}