精华内容
下载资源
问答
  • 文章目录题目指针节点使用节点来创建链表遍历链表向链表插入数据在链表开头插入数据在链表结尾插入数据在个数据节点中间插入数据删除列表中的数据解题方案 题目 指针节点 有些情况下,存储数据的内存分配不能位于...
  • Java两数相加

    2013-11-15 16:46:11
    关于用Java实现两数相加的功能: public class ww extends javax.swing.JApplet { /** Initializes the applet ww */ public void init() { try { java.awt.EventQueue.invokeAndWait(new Runnable() { ...
  • 两数相加的c语言程序

    2015-11-16 15:46:19
    c语言程序,课本教程课后作业,得到数相加的和
  • C语言简单两数相加
  • 两数相加

    千次阅读 2020-05-02 10:13:26
    * 两数相加 * 给出两个 非空 的链表用来表示两个非负的整数。其中,它们各自的位数 * 是按照 逆序 的方式存储的,并且它们的每个节点只能存储 一位 数字。 * 如果,我们将这两个数相加起来,则会返回一个新的...
    package com.mtons.mblog.leetcode;
    
    
    import java.math.BigDecimal;
    
    /**
     * 两数相加
     * 给出两个 非空 的链表用来表示两个非负的整数。其中,它们各自的位数
     * 是按照 逆序 的方式存储的,并且它们的每个节点只能存储 一位 数字。
     * 如果,我们将这两个数相加起来,则会返回一个新的链表来表示它们的和。
     * 您可以假设除了数字 0 之外,这两个数都不会以 0 开头。
     * 示例:
     * 输入:(2 -> 4 -> 3) + (5 -> 6 -> 4)
     * 输出:7 -> 0 -> 8
     * 原因:342 + 465 = 807
     * 通过了真是不容易
     */
    public class ListNode {
        int val;
        ListNode next;
    
        ListNode(int x) {
            val = x;
        }
    }
    
    class Solution {
        public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
            StringBuilder sb1 = new StringBuilder();
            while (l1 != null) {
                sb1.append(l1.val);
                l1 = l1.next;
            }
            //Integer最大到65535 不支持特殊样例 long类型精度也不够
            //long i1 = Long.parseLong(sb1.reverse().toString());
    
            BigDecimal i1 = new BigDecimal(sb1.reverse().toString());
    
            StringBuilder sb2 = new StringBuilder();
            while (l2 != null) {
                sb2.append(l2.val);
                l2 = l2.next;
            }
            //long i2 = Long.parseLong(sb2.reverse().toString());
            BigDecimal i2 = new BigDecimal(sb2.reverse().toString());
    
            BigDecimal i3 = i1.add(i2);
            //long i3 = i1 + i2;
            String ss = new StringBuilder(String.valueOf(i3)).reverse().toString();
            char[] chars = ss.toCharArray();
            ListNode head = null;
            System.out.println("chars[0] is : " + chars[0]);
            if (chars != null && chars.length != 0) {
                //char与int的相互转化,联想ASCII码,字符‘0’对应的值为48,所以不能直接加减
                //char ch='9';
                //int ch_int=ch-'0';//此时ch_int=9
                //int i=9;
                //char i_ch=i+'0';//此时i_ch='9'
                head = new ListNode(chars[0] - '0');
                for (int i = 1; i < chars.length; i++) {
                    ListNode newLink = new ListNode(chars[i] - '0');//要插入的Link节点
                    ListNode current = head;
                    ListNode previous = null;
                    while (current != null) {//当前link不是空,插入的数据大于当前link值
                        //current为空、null时previous是最后一个节点
                        previous = current;//记录当前为前一个link节点
                        current = current.next;//当前link向下找
                    }
                    previous.next = newLink;
                }
            }
            return head;
        }
    
        public static void main(String[] args) {
            Solution solution = new Solution();
            ListNode listNode1 = new ListNode(9);
    
            ListNode listNode2 = new ListNode(1);
            ListNode listNode22 = new ListNode(9);
            ListNode listNode23 = new ListNode(9);
            ListNode listNode24 = new ListNode(9);
            ListNode listNode25 = new ListNode(9);
            ListNode listNode26 = new ListNode(9);
            ListNode listNode27 = new ListNode(9);
            ListNode listNode28 = new ListNode(9);
            ListNode listNode29 = new ListNode(9);
            ListNode listNode210 = new ListNode(9);
            listNode2.next = listNode22;
            listNode22.next = listNode23;
            listNode23.next = listNode24;
            listNode24.next = listNode25;
            listNode25.next = listNode26;
            listNode26.next = listNode27;
            listNode27.next = listNode28;
            listNode28.next = listNode29;
            listNode29.next = listNode210;
    
            ListNode listNode = solution.addTwoNumbers(listNode1, listNode2);
            System.out.println(listNode);
        }
    }
    
    
    展开全文
  • 给出个 非空 的链表用来表示个非负...如果,我们将这数相加起来,则会返回一个新的链表来表示它们的和。 您可以假设除了数字 0 之外,这个数都不会以 0 开头 本代码是该题目的解法,包括简单的测试用例
  • js代码-两数相加,返回下标; 重点:1.indexOf(第二个参数可指定查找位置) 2.return 跳不出forEach
  • # 445 两数相加 II 给你两个 非空 链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。 你可以假设除了数字 0 之外,这两个数字都不会以零开头。...
  • MATLAB实现两数相加的功能,前两个文本框显示数字,按钮按下后,可在第三个文本框中显示计算结果。
  • java 两数相加

    千次阅读 2020-04-30 09:48:36
    想了解更多数据结构以及算法题,可以关注微信...将这两数相加会返回一个新的链表。 你可以假设除了数字 0 之外,这两个数字都不会以零开头。 示例: 输入: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4) 输出:...

    想了解更多数据结构以及算法题,可以关注微信公众号“数据结构和算法”,每天一题为你精彩解答。也可以扫描下面的二维码关注
    在这里插入图片描述

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

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

    示例:

    输入: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
    输出: 7 -> 8 -> 0 -> 7
    结点类如下

    public class ListNode {
        int val;
        ListNode next;
    
        ListNode(int x) {
            val = x;
        }
    }
    

    答案:

     public ListNode addTwoNumbers(ListNode list1, ListNode list2) {
         Stack<Integer> s1 = new Stack<>();
         Stack<Integer> s2 = new Stack<>();
         while (list1 != null) {
             s1.push(list1.val);
             list1 = list1.next;
         }
         while (list2 != null) {
             s2.push(list2.val);
            list2 = list2.next;
        }
        int sum = 0;
        ListNode head = new ListNode(0);
        while (!s1.empty() || !s2.empty()) {
            if (!s1.empty())
                sum += s1.pop();
            if (!s2.empty())
                sum += s2.pop();
            head.val = sum % 10;
            ListNode node = new ListNode(sum / 10);
            node.next = head;
            head = node;
            sum /= 10;
        }
        return head.val == 0 ? head.next : head;
    }
    

    解析:

    思路其实很简单,就是分别把两个链表的结点先存放到两个栈中,因为链表的最高位是在链表的最开始的位置,所以存放到栈中之后,栈底是高位,栈顶是个位(也是低位),然后两个栈中的元素再相加,因为栈是先进后出的,最先出来的肯定是个位(也是低位),最后出来的肯定是高位,也就是这两个数是从个位开始相加,这也符合加法的运算规律。

    1,代码中第19行我们只保存相加的个位数,因为链表的每个结点只能保存一位数,如果有进位就会在下一步进行保存。

    2,第20行在保留进位的值。其中第20到22行涉及到链表的插入,这个使用的是头插法,在链表节点的头部插入,比较简单,如果看不懂的,还可以看下前面刚讲的352,数据结构-2,链表。

    3,代码第25行先判断链表相加之后的最高位是否有进位,如果有就直接返回,如果没有就返回头结点head的下一个结点即可。

    代码比较简单,我们就以上面的例子来画一个图加深一下理解,
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    我们还可以改成递归的方式来解决

     public ListNode addTwoNumbers(ListNode list1, ListNode list2) {
         int size1 = getLength(list1);
         int size2 = getLength(list2);
         ListNode head = new ListNode(1);
         head.next = size1 < size2 ? helper(list2, list1, size2 - size1) : helper(list1, list2, size1 - size2);
         if (head.next.val > 9) {
             head.next.val = head.next.val % 10;
             return head;
         }
        return head.next;
    }
    
    //这里链表list1的长度是大于等于list2的长度的
    public ListNode helper(ListNode list1, ListNode list2, int offset) {
        if (list1 == null)
            return null;
        ListNode result = offset == 0 ? new ListNode(list1.val + list2.val) : new ListNode(list1.val);
        ListNode post = offset == 0 ? helper(list1.next, list2.next, 0) : helper(list1.next, list2, offset - 1);
        if (post != null && post.val > 9) {
            result.val += 1;
            post.val = post.val % 10;
        }
        result.next = post;
        return result;
    }
    
    public int getLength(ListNode list) {
        int count = 0;
        while (list != null) {
            list = list.next;
            count++;
        }
        return count;
    }
    
    展开全文
  • C++链表实现两数相加

    2020-01-16 22:14:14
    这是LeedCode上面第2题:链表实现两数相加。复习了多文件编译,链表的相关知识。 给出两个非空的链表用来表示两个非负的整数。其中,它们各自的位数是按照逆序的方式存储的,并且它们的每个节点只能存储一位数字。...

    这是LeedCode上面第2题:链表实现两数相加。复习了多文件编译,链表的相关知识。

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

    示例:

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


    多文件编译之间的引用相关知识:举个例子,头文件addTwoNumber.h里面写写结构体和addTwoNumber.cpp当中的函数申明,源文件 main.cpp和addTwoNumber.cpp都要引用“addTwoNumber.h”这个文件


    具体代码如下

    头文件 addTwoNumber.h

    #pragma once
    #ifndef ADDTWONUMBER_H
    #define ADDTWONUMBER_H
    
    //链表结构体
    struct ListNode {
    	int val;
    	ListNode *next;
    	ListNode(int x) : val(x), next(NULL) {}
    };
    //申明addTwoNumber函数
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2);
    void DeleteList(ListNode* l1);
    #endif // !1
    

    源文件 main.cpp (这里的创建链表还需要改进)

    #include<iostream>
    #include<string>
    #include "addTwoNumber.h"  
    
    using namespace std;
    
    int main(void) {
    	//vector<int> nums = { 2, 7, 11, 15 };
    	//int target;
    	//target = 9;
    
    	//for (auto it : twoSum(nums, target))
    	//	cout << it;
    	//system("pause");
    
    	//创建链表l1
    	ListNode* l1 = new ListNode(2); //创建表头
    	ListNode*  p = l1; //创建移动指针
    	ListNode* q = new ListNode(4);
    	p->next = q;
    	p = p->next;
    	q->next = new ListNode(3);
    	q->next->next = NULL;
    
    	//输出链表l1
    	p = l1;
    	cout << "链表l1的值为:";
    	while (p != NULL) {
    		cout << p->val;
    		p = p->next;
    	}
    
    	//创建链表l2
    	ListNode* l2 = new ListNode(5); //创建表头
    	ListNode*  a = l2; //创建移动指针
    	ListNode* b = new ListNode(6);
    	a->next = b;
    	a = a->next;
    	b->next = new ListNode(4);
    	b->next->next = NULL;
    
    	//输出链表l2
    	p = l2;
    	cout << "\n链表l2的值为:";
    	while (p != NULL) {
    		cout << p->val;
    		p = p->next;
    	}
    	ListNode* l3 = addTwoNumbers(l1, l2);
    
    
    	//输出链表l3
    	p = l3;
    	cout << "\n链表l3的值为:";
    	while (p != NULL) {
    		cout << p->val;
    		p = p->next;
    
    	}
    
    	DeleteList(l1);
    	DeleteList(l2);
    	DeleteList(l3);
    	system("pause");
    }

    源文件 addTwoNumber.cpp

    #include<iostream>
    #include<string>
    
    #include "addTwoNumber.h"
    using namespace std;
    
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
    
    	//****************得到链表长度,将不足的补0****************//
    	int len1, len2; //记录链表的长度
    	len1 = 1; len2 = 1;
    	ListNode* p = l1;//创造移动的节点p和q
    	ListNode* q = l2;
    	while (p->next != NULL) {
    		len1++;
    		p = p ->next;
    	}
    	while (q->next != NULL) {
    		len2++;
    		q = q->next;
    	}
    
    	if (len1 > len2) {
    		//链表2要补0;
    		for (int i = 0; i < len1 - len2; i++) {
    			q->next = new ListNode(0);
    			q = q->next;
    		}
    		q->next = NULL;
    	}
    
    	if (len2 > len1) {
    		//链表1要补0;
    		for (int i = 0; i < len2 - len1; i++) {
    			p->next = new ListNode(0);
    			p = p->next;
    		}
    		p->next = NULL;
    	}
    
    	//****************构造新链表,对原来链表进行求和****************//
    	ListNode * head = new ListNode(-1); //这里创造头节点并且不存数的原因:方便接下来循环3次计算存储数据,从第二个值返回即可。
    	//相反,没有这一步骤,会创造4个节点,且最后一个值是多余的!
    	int carry = 0; //进位
    	p = l1;
    	q = l2;
    	ListNode *h = head;
    	while (p!= NULL) {
    		h->next = new ListNode(0);
    		h = h->next;
    		int sum = 0;
    		sum = p->val + q->val + carry;
    		
    		h->val = sum % 10;
    		carry = sum / 10;
    
    		p = p->next;
    		q = q->next;
    	}
    	if (carry == 1) {
    		h->next = new ListNode(1);
    		h = h->next;
    	}
    	h->next = NULL;
    	return head->next;
    }
    
    void DeleteList(ListNode* l1) {
    	ListNode *p;
    	p = l1;
    	while (p != NULL)
    	{
    		p = l1->next;
    		free(l1);
    		l1 = p;
    	}
    }

     

    来源:力扣(LeetCode)
    链接:https://leetcode-cn.com/problems/add-two-numbers
     

    展开全文
  • Python两数相加实现

    2020-11-28 13:23:11
    题目要求:思路:遍历第一个与第二个链表,把相同位置的相加设置一个flag,用来标记相加后大于10的部分,下一位再相加时,就要加上flag的值遍历至一个链表结束如果此时flag不为0,把未结束的链表当前的第一位加上...

    题目要求:

    1436641269-5e746fb14e83a_articlex.png

    思路:

    遍历第一个与第二个链表,把相同位置的相加

    设置一个flag,用来标记相加后大于10的部分,下一位再相加时,就要加上flag的值

    遍历至一个链表结束

    如果此时flag不为0,把未结束的链表当前的第一位加上flag

    falg记录相加大于10的部分

    直至当前列表也遍历完

    如果遍历完,flag仍然不为0,再补一位1

    核心代码:

    遍历两个链表:

    # 把链表1 2 的头赋给h1,h2

    h1 = l1

    h2 = l2

    # 创建新链表,用来保存计算完的数

    l3 = ListNode()

    h3 = l3

    # flag标志两数加完大于9的部分

    flag = 0

    # 遍历两个链表,h3当前的值为h1+h2去掉十位的部分,flag保存进位,运算完h1,h2,h3移向下一位

    while h1 and h2 :

    h3.next = ListNode((h1.val + h2.val + flag) % 10)

    flag = (h1.val + h2.val + flag) // 10

    h1 = h1.next

    h2 = h2.next

    h3 = h3.next

    – 如果链表1或2未遍历完:

    #原理如上

    if h1 :

    while h1 :

    h3.next = ListNode((h1.val + flag) % 10)

    flag = (h1.val + flag) // 10

    h1 = h1.next

    h3 = h3.next

    # 用elif,如果是h1有未遍历的,遍历结束后就不遍历h2了

    elif h2 :

    while h2 :

    h3.next = ListNode((h2.val + flag) % 10)

    flag = (h2.val + flag) // 10

    h2 = h2.next

    h3 = h3.next

    - 如果最后一位相加后,仍需进位:

    if flag == 1:

    h3.next = ListNode(1)

    完整代码:加上判断l1和l2一开始是否为空,如果l1为空,返回l2,如果l2为空,返回l1

    # Definition for singly-linked list.

    # class ListNode(object):

    # def __init__(self, x):

    # self.val = x

    # self.next = None

    class Solution(object):

    def addTwoNumbers(self, l1, l2):

    """

    :type l1: ListNode

    :type l2: ListNode

    :rtype: ListNode

    """

    if l1 is None:

    return l2

    if l2 is None:

    return l1

    h1 = l1

    h2 = l2

    l3 = ListNode()

    h3 = l3

    flag = 0

    while h1 and h2 :

    h3.next = ListNode((h1.val + h2.val + flag) % 10)

    flag = (h1.val + h2.val + flag) // 10

    h1 = h1.next

    h2 = h2.next

    h3 = h3.next

    if h1 :

    while h1 :

    h3.next = ListNode((h1.val + flag) % 10)

    flag = (h1.val + flag) // 10

    h1 = h1.next

    h3 = h3.next

    elif h2 :

    while h2 :

    h3.next = ListNode((h2.val + flag) % 10)

    flag = (h2.val + flag) // 10

    h2 = h2.next

    h3 = h3.next

    if flag == 1:

    h3.next = ListNode(1)

    return l3.next

    展开全文
  • leetcode两数相加 链表一、引言1.两数相加-Python实现2. 实验结果 一、引言 在leetcode做算法题时,并不需要写输入输出,但是在实际线上笔试的时候,需要自己调试。 本文以链表为例,讲解链表的插入以及链表的输出,...
  • leetcode 算法题: 两数相加 给出两个 非空 的链表用来表示两个非负的整数。其中,它们各自的位数是按照 逆序 的方式存储的,并且它们的每个节点只能存储 一位 数字。 如果,我们将这两个数相加起来,则会返回一个新...
  • LeetCode 2——两数相加

    千次阅读 2018-10-28 21:08:17
    个链表都非空,将个链表结点的值和进位相加求出和以及新的进位 若其中一个链表为空,则将另一个链表结点的值和进位相加求出和以及新的进位 然后将每一位的和添加到新链表中。 如果有一个链表为空,且此时...
  • 五个作业作业一两数相加,作业二10个数里找最大的一个,作业散1到20相加,作业死斐波那契数列,作业五班级成绩排序
  • 2. 两数相加

    千次阅读 2020-05-15 10:12:59
    题目来源 leetcode 题目描述 题目解析 laiyuan /**... // 更新要计算的下一个 l2 = l2 == null ? null : l2.next; } if (c != 0){ cur.next = new ListNode(c); } // 非空链表,所以至少一个 return result.next; } }
  • 两数相加 给出两个 非空 的链表用来表示两个非负的整数。其中,它们各自的位数是按照 逆序 的方式存储的,并且它们的每个节点只能存储 一位 数字。 如果,我们将这两个数相加起来,则会返回一个新的链表来表示它们...
  • js 实现两数相加的算法

    千次阅读 2020-08-17 23:26:01
    关于算法 两数相加 (leetcod上的的一道算法题) 给出两个 非空 的链表用来表示两个非负的整数。其中,它们各自的位数是按照 逆序 的方式存储的,并且它们的每个节点只能存储 一位 数字。 如果,我们将这两个数相加...
  • LeetCode两数相加(Java)

    千次阅读 2018-05-06 10:45:43
    两数相加返回一个新的链表。你可以假设除了数字 0 之外,这两个数字都不会以零开头。示例:输入:(2 -&gt; 4 -&gt; 3) + (5 -&gt; 6 -&gt; 4) 输出:7 -&gt; 0 -&gt; 8 原因:342 + 465 =...
  • 两数相加(C语言解法)

    千次阅读 2019-04-26 19:45:58
    如果,我们将这数相加起来,则会返回一个新的链表来表示它们的和。 您可以假设除了数字 0 之外,这个数都不会以 0 开头。 示例: 输入:(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出:7 -> 0 -&g...
  • 两数相加(java版本)

    2021-02-26 11:21:08
    图1,对两数相加方法的可视化: 342 + 465 = 807342+465=807,每个结点都包含一个数字,并且数字按位逆序存储。 算法 就像你在纸上计算两个数字的和那样,我们首先从最低有效位也就是列表 l1l1 和 l2l2 的表头开始...
  • 【算法实战系列】两数相加

    千次阅读 2018-12-20 12:19:32
    如果,我们将这数相加起来,则会返回一个新的链表来表示它们的和。 您可以假设除了数字 0 之外,这个数都不会以 0 开头。 示例: 输入:(2 -&gt; 4 -&gt; 3) + (5 -&gt; 6 -&gt; 4) 输出...
  • vbs中通过intpu传值进行运算的方法,需要的朋友可以参考下。
  • 这次来写一下 LeetCode 的第 2 题,两数相加。 题目描述 题目直接从 LeetCode 上截图过来,题目如下: 上面的题就是 两数相加 题目的截图,同时 LeetCode 会根据选择的语言给出了一个类的定义或者函数的...
  • 给出个非空 的链表用来表示个非负的整数。其中,它们各自的位数是按照逆序的方式存储的,并且它们的每个节点只能存储一位数字。...如果,我们将这数相加起来,则会返回一个新的链表来表示它们的和。
  • 2. 两数相加(JS实现)

    千次阅读 2020-05-30 10:54:09
    如果,我们将这数相加起来,则会返回一个新的链表来表示它们的和。 您可以假设除了数字 0 之外,这个数都不会以 0 开头。 示例: 输入:(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出:7 -> 0 -> 8 ...
  • 力扣算法第二题:两数相加

    千次阅读 2019-02-28 17:44:01
    两数相加 思路及问题 1.首先,没学过怎么用java表示链表,或者学过忘了。所以得查一下怎么表示。 JAVA表示链表*[作者YSOcean] 2.行吧,看了一下午还是不会,然后就直接看答案了,看答案还是有点一愣一愣的,理解得...
  • 请你将数相加,并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外,这个数都不会以 0开头。 示例 1: 输入:l1 = [2,4,3], l2 = [5,6,4] 输出:[7,0,8] 解释:342 + 465 = 807. 示例 2: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 285,647
精华内容 114,258
关键字:

两数相加

友情链接: stubs-32.rar