两个数相加

给出两个 非空 的链表用来表示两个非负的整数。其中,它们各自的位数是按照 逆序 的方式存储的,并且它们的每个节点只能存储 一位 数字。

如果,我们将这两个数相加起来,则会返回一个新的链表来表示它们的和。

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

输入:(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出:7 -> 0 -> 8
原因:342 + 465 = 807
package com.leetcode.part1;

/**
 * @author :shix
 * @date :Created in 2020/1/26 14:09
 * @description:两数相加
 * @modified By:
 */
public class AddTwoNumbers {

    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode head = null;//返回结果
        ListNode previousNode = null;//存储上一个节点
        boolean flag = false;//是否进位
        ListNode p1 = l1;
        ListNode p2 = l2;
        while (p1 != null && p2 != null) {
            int temp = p1.val + p2.val + (flag ? 1 : 0);
            ListNode node;
            if (temp >= 10) {
                node = new ListNode(temp - 10);
                flag = true;
            } else {
                node = new ListNode(temp);
                flag = false;
            }
            if (head == null && previousNode == null) {
                head = node;
                previousNode = node;
            } else {
                previousNode.next = node;
            }
            node.next = null;
            previousNode = node;

            p1 = p1.next;
            p2 = p2.next;
        }
        while (p1 != null) {
            int temp = p1.val + (flag ? 1 : 0);
            ListNode node;
            if (temp >= 10) {
                node = new ListNode(temp - 10);
                flag = true;
            } else {
                node = new ListNode(temp);
                flag = false;
            }
            node.next = null;
            previousNode.next = node;
            previousNode = node;
            p1 = p1.next;
        }
        while (p2 != null) {
            int temp = p2.val + (flag ? 1 : 0);
            ListNode node;
            if (temp >= 10) {
                node = new ListNode(temp - 10);
                flag = true;
            } else {
                node = new ListNode(temp);
                flag = false;
            }
            node.next = null;
            previousNode.next = node;
            previousNode = node;
            p2 = p2.next;
        }
        if (flag == true) {
            ListNode node = new ListNode(1);
            previousNode.next = node;
        }
        return head;
    }

    /**
     * 初始化ListNode
     *
     * @param num
     * @return
     */
    public ListNode initNode(int num) {
        int temp = num % 10;
        ListNode head = null;
        ListNode previousNode = null;
        while (temp != 0) {
            ListNode node = new ListNode(temp);
            node.next = null;
            if (head == null && previousNode == null) {
                head = node;
                previousNode = node;
            } else {
                previousNode.next = node;
            }
            num = num / 10;
            temp = num % 10;
            previousNode = node;
        }
        return head;
    }

    public static void main(String[] args) {
        AddTwoNumbers add = new AddTwoNumbers();
        //初始化两个链表
        ListNode l1 = add.initNode(342);
        ListNode l2 = add.initNode(465);
        //两数相加
        ListNode result = add.addTwoNumbers(l1, l2);
        // 打印结果
        add.printResult(result);
    }

    private void printResult(ListNode result) {
        //打印结果
        System.out.print("结果:");
        while (result != null) {
            System.out.print(result.val);
            if (result.next != null) {
                System.out.print("->");
            }
            result = result.next;
        }
        System.out.println("");
    }

    class ListNode {
        int val;
        ListNode next;

        ListNode(int x) {
            val = x;
        }
    }
}

来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/add-two-numbers
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。

码code玩~~~

原文地址:https://www.cnblogs.com/shix0909/p/12234297.html

时间: 2024-10-08 07:14:50

两个数相加的相关文章

实现两个数相加不用四则运算

分析:实现两个是相加不用四则运算,根据计算机中的运算不用四则运算那么肯定是位运算了. (以下分析来自剑指offer)比如我们计算5+17=22这个结果,世界上,我们可以分为3个步骤计算,第一步各位数相加不进位,此时的结果是12(个位相加不进位是2,十位相加是1),所以结果是12: 第二步做进位,5+7有进位,进位值是10:第三步是把前两步计算结果加起来.12 + 10 = 22. 那么运用位运算二进制的数字也可以这么考虑,5是二进制的101,17是二进制的10001.试着把计算分为3步走,第一步

2-36进制的 两个数相加

最近在很多场合都看见设计模式的影子,一直以来,都投入主要时间在搞算法与数据结构,很来发现设计模式真的很重要.有的时候代码的可维护.可重用.可扩展确实胜过单纯的算法效率高.所以拾起大牛书籍<大话设计模式>同时参考网上诸大牛的博客,开始我的设计模式之旅.由于平时编程时用C/C++,现在是Java,也练练Java语法. 今天先介绍一下命令模式. 概念: 命令模式(Command):将一个请求封装成一个对象,从而使你可用不同的请求对象对客户进行参数化,对请求排队或记录请求日志,以及支持可撤销的操作.

CUDA学习(三)之使用GPU进行两个数相加

在CPU上定义两个数并赋值,然后使用GPU核函数将两个数相加并返回到CPU,在CPU上显示 #include "cuda_runtime.h" #include "device_launch_parameters.h" #include <iomanip> #include <iostream> #include <stdio.h> using namespace std; //检测GPU bool CheckCUDA(void)

leetcode 1: 找出两个数相加等于给定数 two sum

问题描述 对于一个给定的数组,找出2个数,它们满足2个数的和等于一个特定的数,返回这两个数的索引.(从1开始) Given an array of integers, find two numbers such that they add up to a specific target number. The function twoSum should return indices of the two numbers such that they add up to the target,

用链表实现两个数相加

说明:使用链表实现两个数的和,数的高位存储在链表的头部,最后输出结果.注:使用了翻转链表的功能. #include<stdio.h> #include<stdlib.h> struct Node { int value; Node *next; }; Node *reverseList(Node *head) { Node *pCur=head; Node *pPre=NULL; Node *rHead=NULL; while(pCur!=NULL) { Node *pNext=p

[LeetCode]2. Add Two Numbers用链表逆序存储的两个数相加

You are given two linked lists representing two non-negative numbers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list. Input: (2 -> 4 -> 3) + (5 -> 6 ->

02027_线程池练习:返回两个数相加的结果

1.要求:通过线程池中的线程对象,使用Callable接口完成两个数求和操作. 2.代码实现: (1)Callable接口实现类 1 import java.util.concurrent.Callable; 2 3 public class MyCallable implements Callable<Integer> { 4 // 成员变量 5 int x = 5; 6 int y = 3; 7 8 // 构造方法 9 public MyCallable() { 10 } 11 12 pu

用链表表示的两个数相加

1 题目 You are giventwo linked lists representing two non-negative numbers. The digits are storedin reverse order and each of their nodes contain a single digit. Add the twonumbers and return it as a linked list. Input: (2 -> 4 -> 3)+ (5 -> 6 ->

LeetCode Add Two Numbers 两个数相加

1 /** 2 * Definition for singly-linked list. 3 * struct ListNode { 4 * int val; 5 * ListNode *next; 6 * ListNode(int x) : val(x), next(NULL) {} 7 * }; 8 */ 9 class Solution { 10 public: 11 ListNode *creatnode(int a){ 12 ListNode *nod=new ListNode(a);