LeetCode——2——两数相加

原题地址： https://leetcode-cn.com/problems/add-two-numbers/description/

题目：给定两个非空链表来表示两个非负整数。位数按照逆序方式存储，它们的每个节点只存储单个数字。将两数相加返回一个新的链表。

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

示例：

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

编程思想：
① 同时遍历这两个链表，求出这两个数的的和
② 将这两个数的和逆序存在一个新的链表

这道题并不难，只是本博主的设计思路比较怪，所以需要解决很多怪的情况，废话不多说，上代码（此代码可以直接运行）

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
class ListNode {
            int val;
            ListNode next;
            ListNode(int x) { val = x; }
}
public class Test {
       public static void main(String[] args) {
              ListNode l1 = new ListNode(1);
              ListNode l2 = new ListNode(9);
              //l1.next = new ListNode(8);
              l2.next = new ListNode(9);
              ListNode result = addTwoNumbers(l1,l2);
               while(result!=null) {
                      System.out.print(result.val);
                      result=result.next;
               }
       }
public static ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        //如果两个节点都为空，那就返回一个头结点，值为0
              if(null==l1||null==l2) {
                     return new ListNode(0);
              }
              /*① 先计算两个数字的总和，为什么使用result来进行统计呢？这个问题问的好，因为我用Long的统计的时候会导致内存溢出*/
              String result = "";
              //是否进位
              Boolean flag =false;
              //遍历这两个链表直到这两个链表都到达尾节点
              while(l1!=null||l2!=null) {
                  //在遍历完了l1链表之后就单独遍历l2
                     while(l1==null&&l2!=null) {
                     /*flag表示前一位相加是否有进位，有就为true，这里是防止l1最后一位和l2相加的时候有进位*/
                           if(flag==true) {
                                  flag=false;
                                  int temp = l2.val+1;
                                  result+=temp%10;
                                  l2=l2.next;
                                  if(temp/10==1) {
                                         flag=true;
                                         if(l1==null&&l2==null&&flag==true) {
                                                result+=1;
                                         }
                                  }
                           }else {
                                  result+=l2.val;
                                  l2=l2.next;
                           }
                     }
                     while(l2==null&&l1!=null) {
                           if(flag==true) {
                                  flag=false;
                                  int temp = l1.val+1;
                                  result+=temp%10;
                                  l1=l1.next;
                                  if(temp/10==1) {
                                         flag=true;
                                         if(l1==null&&l2==null&&flag==true) {
                                                result+=1;
                                         }
                                  }
                           }else {
                                  result+=l1.val;
                                  l1=l1.next;
                           }
                     }
                     if(l1==null&&l2==null) {
                           break;
                     }
                     if(flag) {
                           int temp = l1.val+l2.val+1;
                                  result+=temp%10;
                                  if(temp/10==0) {
                                         flag = false;
                                  }

                     }else {
                           int temp = l1.val+l2.val;
                           result+=temp%10;
                           if(temp/10==1)
                                  flag = true;  
                     }
                     l1=l1.next;
                     l2=l2.next;
                     if(l1==null&&l2==null&&flag==true) {
                           result+=1;
                     }
              }

              ListNode nodeLast = new ListNode((int)(result.charAt(result.length()-1)-'0'));
              //防止两个链表都是0
              ListNode nodePre=new ListNode((int)(result.charAt(result.length()-1)-'0'));
              //② 新建链表，然后逆序存储该数  !!!这里咱们从尾节点开始生成，然后赋值resultLong的余数
              for(int i=result.length()-2;i>=0;i--) {
                     nodePre = new ListNode((int)(result.charAt(i)-'0'));
                     nodePre.next=nodeLast;
                     nodeLast = nodePre;
              }

        return nodePre;
    }
}

虽然代码很冗余，不过也是博主的一片心血，如果觉得还行的请点个赞。顺便一提，感兴趣的可以进入一开始给的那个网站，那里的例子只用了十多行代码就搞定了，这就是咸鱼和大佬的差距……慢慢努力，坚信勤能补拙！