精华内容
下载资源
问答
  • 两数相加

    千次阅读 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);
        }
    }
    
    
    展开全文
  • Java实现 LeetCode 2 两数相加

    万次阅读 多人点赞 2020-02-11 18:28:02
    两数相加 给出两个 非空 的链表用来表示两个非负的整数。其中,它们各自的位数是按照 逆序 的方式存储的,并且它们的每个节点只能存储 一位 数字。 如果,我们将这两个数相加起来,则会返回一个新的链表来表示它们...
    1. 两数相加

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

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

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

    示例:

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

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

    /**
     * Definition for singly-linked list.
     * public class ListNode {
     *     int val;
     *     ListNode next;
     *     ListNode(int x) { val = x; }
     * }
     */
    class Solution {
        public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
           if(l2 == null) {
    	     return l1;
    	}else if(l1 == null && l2 != null){
    		return l2;     
    	}else {			
    		l1.val = l1.val+l2.val;	
    		jinwei(l1);
    		l1.next = addTwoNumbers(l1.next,l2.next);	
    		return l1;
    	}
      }
      public void jinwei(ListNode l1) {
    	if(l1.val>9) {					
                if(l1.next == null){
                    l1.next = new ListNode(l1.val/10);
                }else{
                    l1.next.val += l1.val/10;
                    jinwei(l1.next);
                }
          l1.val %= 10;
          }
        }
    }
    
    展开全文
  • Java实现 LeetCode 445 两数相加 II

    万次阅读 多人点赞 2020-03-17 13:22:12
    这两数相加会返回一个新的链表。 你可以假设除了数字 0 之外,这两个数字都不会以零开头。 进阶: 如果输入链表不能修改该如何处理?换句话说,你不能对列表中的节点进行翻转。 示例: 输入: (7 -> 2 -> 4 -&...

    445. 两数相加 II

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

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

    进阶:

    如果输入链表不能修改该如何处理?换句话说,你不能对列表中的节点进行翻转。

    示例:

    输入: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
    输出: 7 -> 8 -> 0 -> 7

    /**
     * Definition for singly-linked list.
     * public class ListNode {
     *     int val;
     *     ListNode next;
     *     ListNode(int x) { val = x; }
     * }
     */
    class Solution {
          public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
            //栈
            LinkedList<Integer> s1 = new LinkedList<>();
            LinkedList<Integer> s2 = new LinkedList<>();
            while(l1 != null) {
                s1.addFirst(l1.val);
                l1 = l1.next;
            }
            while(l2 != null) {
                s2.addFirst(l2.val);
                l2 = l2.next;
            }
            int carry = 0;
            ListNode lastNode = null;
            while(!s1.isEmpty() || !s2.isEmpty()) {
                int a1 = 0, a2 = 0;
                if(!s1.isEmpty()) {
                    a1 = s1.removeFirst();
                }
                if(!s2.isEmpty()) {
                    a2 = s2.removeFirst();
                }
                ListNode curNode = new ListNode((a1 + a2 + carry) % 10);
                carry = (a1 + a2 + carry) / 10;
                curNode.next = lastNode;
                lastNode = curNode;
            }
            if(carry > 0) {
                ListNode curNode = new ListNode(carry);
                curNode.next = lastNode;
                lastNode = curNode;
            }
            return lastNode;
        }
    }
    
    展开全文
  • 两个数相加

    千次阅读 2019-07-05 20:24:58
    如果,我们将这两个数相加起来,则会返回一个新的链表来表示它们的和。 您可以假设除了数字 0 之外,这两个数都不会以 0开头。 来源:力扣(LeetCode) 链接:https://leetcode-cn.com/problems/add-two-nu...

     

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

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

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

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

    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    
    public class TowNumAcount {
         public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
            Integer sum = listNodeToInt(l1)+listNodeToInt(l2);
            int temp[] = this.dilicate(sum);
             ListNode result = new ListNode(temp[0]);
            for(int i=1 ;i < temp.length;i++){
                //System.out.println(temp[i]);
                result = this.addListNode(temp[i],result);
            }
    
             return result;
        }
        public ListNode addListNode(int val,ListNode ln){
             ListNode nextNode =new ListNode(val);
             ListNode tempNode = ln;
             while(tempNode.next != null){
                tempNode = tempNode.next;
             }
             tempNode.next = nextNode;
    
             return ln;
        }
    
        public int[] dilicate(int number){
            int temp;
            int index = (int) Math.log10(number)+1;
            int res[] = new int[index];
            int carry = this.count(index);
            for(int i=carry;i >= 1 ;i=i/10){
                temp = number / i;
                number = number % i;
                //System.out.println(temp);
                res[index-1] = temp;
                index--;
            }
        return res;
        }
    
       public int listNodeToInt(ListNode ln){
            HashMap<Integer,Integer> carryOver = new HashMap();
            List<Integer> integerList = new ArrayList<>();
            ListNode nextNode = ln;
           int temp = 1;
           int sum = 0;
           int length = 0;
           if(ln != null){
               length = 1;
               while( nextNode != null){
                   length++;
                   integerList.add(nextNode.val);
                   nextNode = nextNode.next;
               }//end while
            }//end if
            for(int i=1 ; i <= length;i++){
               carryOver.put(i,this.count(i));
           }
    
           for(int i : integerList){
                sum=sum + i * carryOver.get(temp);
                temp++;
            }
           //System.out.println(sum);
           return sum;
       }
    
       public int count(int length){
           int temp = 10;
           int result = 1;
           for(int j = 1;j <= length;j++){
               result =result * temp;
           }
           return result/10;
       }
    
    
    
       public static void main(String args[]) {
           TowNumAcount tna = new TowNumAcount();
           ListNode ln11 = new ListNode(2);
           ListNode ln12 = new ListNode(4);
           ListNode ln13 = new ListNode(3);
           ln11.next = ln12;
           ln12.next = ln13;
           ln13.next = null;
           ListNode ln21 = new ListNode(5);
           ListNode ln22 = new ListNode(6);
           ListNode ln23 = new ListNode(4);
           ln21.next = ln22;
           ln22.next = ln23;
           ln23.next = null;
           ln11 = tna.addTwoNumbers(ln11,ln21);
           System.out.println(tna.listNodeToInt(ln11));
           //System.out.println(tna.count(8));
       }
    }
    public class ListNode {
        int val;
        ListNode next;
        ListNode(int x) { val = x; }
    }

     

    展开全文
  • 数组中两数相加

    千次阅读 2019-07-26 09:47:34
    数组中两数相加 如题: 假设数组int[] array = {2, 7, 11, 15},target = 9,找出数组中是否存在array[i] + array[j] = target,i不等于j,如果有,返回[i, j],没有则返回0。 道题题目虽短,但却很经典,最简单...
  • 简单算法题-两个数相加

    千次阅读 2018-10-14 21:46:15
    简单算法题-两个数相加 题目的大意大概是个样子的: 给定一个整数数组和一个目标值,找出数组中和为目标值的两个数。 你可以假设每个输入只对应一种答案,且同样的元素不能被重复利用。 示例: 给定 nums = [2,...
  • Leetcode算法Java全解答--002. 两数相加

    千次阅读 2018-10-08 19:06:25
    两数相加 题目 两数相加 给定两个非空链表来表示两个非负整数。位数按照逆序方式存储,它们的每个节点只存储单个数字。将两数相加返回一个新的链表。 你可以假设除了数字 0 之外,这两个数字都不会以零开头...
  • Leetcode 2. 两数相加

    千次阅读 2020-05-31 18:35:58
    两数相加1、问题分析2、问题解决3、总结 1、问题分析 题目链接:https://leetcode-cn.com/problems/add-two-numbers/ 基本思路是根据 l1 链表和 l2 链表,对应位置的和然后赋值给新的链表,然后要考虑: 1、链表...
  • leetcode445. 两数相加 II

    千次阅读 多人点赞 2020-06-06 02:57:40
    这两数相加会返回一个新的链表。 你可以假设除了数字 0 之外,这两个数字都不会以零开头。 进阶: 如果输入链表不能修改该如何处理?换句话说,你不能对列表中的节点进行翻转。 示例: 输入:(7 -> 2 ->...
  • Leetcode 两数相加

    千次阅读 2020-12-06 11:15:55
    如果,我们将这两个数相加起来,则会返回一个新的链表来表示它们的和。 您可以假设除了数字 0 之外,这两个数都不会以 0 开头。 题目链接 /** * Definition for singly-linked list. * struct ListNode { * int...
  • 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 =...
  • 不用+号实现两个数相加

    千次阅读 2013-05-19 22:44:39
    第一步,两数相加,但不进位得 937 第二步,两数相加,只进位, 0110 第三步,前两步的结果相加,不进位得 047 第四步,前两步的结果相加,只进位得1000 第五步,3,4步的结果相加,不进位得1047 第六步...
  • js解决两个数相加的问题

    万次阅读 2015-12-21 17:18:19
    我需要得到js实现两个数字相加的结果,可是js总是默认按照字符串处理,将两个数字连接起来。 解决个问题,代码如下: var a = 1; var b = 2; var sum = parseInt(a) + parseInt(b); </script>parseInt()是js的...
  • 两数相加(C语言解法)

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

    万次阅读 2020-10-27 03:16:24
    然后将转换后的两个数字相加,得到个值807,然后想利用StringBuilder的reverse方法得到708,但是结果报了数值越界异常。 因此一题的坑:没有提示链表所表示的值可能超过基本类型 转换思路的解法 既然链表是倒叙...
  • LeetCode-2. 两数相加

    千次阅读 2018-12-05 19:46:59
    如果,我们将这两个数相加起来,则会返回一个新的链表来表示它们的和。 您可以假设除了数字 0 之外,这两个数都不会以 0 开头。 示例: 输入:(2 -&gt; 4 -&gt; 3) + (5 -&gt; 6 -&gt; 4) 输出:7 -...
  • LeetCode 2——两数相加

    千次阅读 2018-10-28 21:08:17
    两个链表都非空,将两个链表结点的值和进位相加求出和以及新的进位 若其中一个链表为空,则将另一个链表结点的值和进位相加求出和以及新的进位 然后将每一位的和添加到新链表中。 如果有一个链表为空,且此时...
  • 2.两数相加-Python-LeetCode

    千次阅读 2018-04-03 20:15:23
    题目两数相加:给定两个非空链表来代表两个非负整数,位数按照逆序方式存储,它们的每个节点只存储单个数字。将这两数相加会返回一个新的链表。你可以假设除了数字 0 之外,这两个数字都不会以零开头。示例:输入:...
  • LeetCode 2. 两数相加 Add Two Numbers

    万次阅读 2018-08-29 00:43:54
    两数相加返回一个新的链表。 你可以假设除了数字 0 之外,这两个数字都不会以零开头。 示例: 输入:(2 -&gt; 4 -&gt; 3) + (5 -&gt; 6 -&gt; 4) 输出:7 -&gt; 0 -&gt; 8 原因:342...
  • leetcode 之 两数相加 C/python解法

    千次阅读 2021-01-05 19:34:59
    请你将两个数相加,并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外,这两个数都不会以 0开头。 示例 1: 输入:l1 = [2,4,3], l2 = [5,6,4] 输出:[7,0,8] 解释:342 + 465 = 807. 示例 2: ...
  • 【算法实战系列】两数相加

    千次阅读 2018-12-20 12:19:32
    如果,我们将这两个数相加起来,则会返回一个新的链表来表示它们的和。 您可以假设除了数字 0 之外,这两个数都不会以 0 开头。 示例: 输入:(2 -&gt; 4 -&gt; 3) + (5 -&gt; 6 -&gt; 4) 输出...
  • LeetCode第二题:两数相加(Java)

    千次阅读 2021-07-22 21:29:33
    文章目录前言一、题目内容二、解题过程1....请你将两个数相加,并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外,这两个数都不会以 0 开头。 示例1: 输入: l1 = [2,4,3], l2 = [5,6,4]
  • 两数相加JavaScript

    千次阅读 2018-07-20 12:14:09
    两数相加题目详情:https://leetcode-cn.com/problems/add-two-numbers/description/ 对博主而言,道题可能更侧重JavaScript如何去实现链表的操作。不过leetcode题解注释中已经指明了链表的方式。 参考博客...
  • LeetCode——两数相加

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

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

    千次阅读 2019-11-08 14:33:18
    题目:        ...如果,我们将这两个数相加起来,则会返回一个新的链表来表示它们的和。您可以假设除了数字 0 之外,这两个数都不会以 0 开头。 输入:(2 ->...
  • leetcode_445. 两数相加 II

    千次阅读 2020-11-27 14:58:15
    这两数相加会返回一个新的链表。 你可以假设除了数字 0 之外,这两个数字都不会以零开头。 进阶: 如果输入链表不能修改该如何处理?换句话说,你不能对列表中的节点进行翻转。 示例: 输入:(7 -> 2 ...
  • LeetCode-两数相加

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

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 249,283
精华内容 99,713
关键字:

两数相加这两个数叫什么