【LeetCode】2.两数相加

(请认真看，足够解决你的问题了。)

题目要求： 

                  （来源地址）：https://leetcode-cn.com/problems/add-two-numbers/description/

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

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

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

实例：

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

Java 编程答案 模板： 

/**
 * 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) {
        
    }
}

博主本人的解答思路：

1. 首先了解 ListNode 的机制。链表从 头结点开始，添加其他结点。

    构建ListNode结点：

public class leetCode_2 {
    
    public static void main(String[] args){
        ListNode root = new ListNode(0);
        ListNode first = new ListNode(2);
        ListNode two = new ListNode(4);
        ListNode three = new ListNode(3);
        root.next = first;
        first.next = two;
        two.next = three;
        
        ListNode pos = root;
       do{
            System.out.println(pos.next.val);
            pos = pos.next;
        }while(pos.val > 0);
    }
}
class ListNode{
    int val;
    ListNode next;
    ListNode(int x){
        val = x;
    }
}

2. 按要求 解题:（leetCode提交的代码）

 public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
         ListNode result = new ListNode(0); // 链表头结点
        ListNode curr = result;               // 当前在计算的 node
        int plus = 0;                          // 和
        int carry = 0;                       // 进位
        while(l1 != null || l2 !=null){
            int x = (l1 != null)?l1.val:0;
            int y = (l2 != null)?l2.val:0;
            plus = x + y + carry;
            curr.next = new ListNode((plus % 10));
            carry = plus / 10;
            if(l1 != null ) l1 = l1.next;
            if(l2 != null) l2 = l2.next;
            curr = curr.next;
        }
        if(carry > 0){ curr.next = new ListNode(carry);}
        return result.next;
  }

可以用来测试的代码，可以在 本地测试。eclipse 或者 其他工具测试。

import java.util.List;

// 自定义 listNode 格式， 计算两个数的和， 题目来源 leetCode 第二题。
public class leetCode_2 {
    // 程序中使用的链表是 自己创建的，如果需要修改内容，请在程序中手动修改。
    //  如果修改了 链表的程度，控制台中输出时，调用 println_ListNode_Type 需要传递的 size 需要响应改变。
   
    private static int size = 3;  // 定义一个长度值，为了输出，在leetCode 提交时 请删除

    public static void main(String[] args){
        ListNode root1 = new ListNode(0); // 链表根节点
        ListNode root11 = new ListNode(2);
        ListNode root12 = new ListNode(4);
        ListNode root13 = new ListNode(3);
        root1.next = root11;
        root11.next = root12;
        root12.next = root13;

        ListNode root2 = new ListNode(0);// 链表根节点
        ListNode root21 = new ListNode(5);
        ListNode root22 = new ListNode(6);
        ListNode root23 = new ListNode(4);
        root2.next = root21;
        root21.next = root22;
        root22.next = root23;

        // 传入 两个节点，计算两个数的和 并且 以链表节点形式输出
        ListNode result = leetCode_2.addTwoNumbers(root1.next, root2.next);
        ListNode pos = result;
        System.out.println("您输入的值为：" );
        println_ListNode_Type(root1.next,3);
        println_ListNode_Type(root2.next,3);
        System.out.print("结果输出值为：" );
        println_ListNode_Type(pos,size);
    }
    // leetCode 请提交 以下代码
    public static ListNode addTwoNumbers(ListNode l1, ListNode l2){
        ListNode result = new ListNode(0); // 链表头结点
        ListNode curr = result;               // 当前在计算的 node
        int plus = 0;                          // 和
        int carry = 0;                       // 进位
        while(l1 != null && l2 !=null){
            int x = (l1 != null)?l1.val:0;
            int y = (l2 != null)?l2.val:0;
            plus = l1.val + l2.val + carry;
            curr.next = new ListNode((plus % 10));
            carry = plus / 10;
            if(l1 != null) l1 = l1.next;
            if(l2 != null) l2 = l2.next;
            curr = curr.next;
            size ++; // 为了输出，leetCode 提交时不需要。
        }
        return result.next;
    }
    //  控住 console 的输出格式，为了调试。
    public static void println_ListNode_Type(ListNode node,int size){
        size = 3;
        System.out.print("(");
        while((size --) > 1 ) {
            System.out.print(node.val+"->");
            node = node.next;
        }
        System.out.println(node.val+")");
    }
}
class ListNode{
    int val;
    ListNode next;
    ListNode(int x){
        val = x;
    }
}

 

关于 这个题目。自己的一些理解。

1. 不要被它的 逆序 吓到。 因为 它的链表就是 定义的 单向链表，而且是只有 next 的前置链表。只支持 逆序 计算，而且是最合适的。

2. 链表 包括单向链表 和 双向链表，单向分为 头结点 链表 和 尾结点链表。通过头结点 或者 尾结点 创建和遍历。

     头结点单向链表  只有 val  和 next属性。只支持 从右向左 遍历。

     尾结点单向链表 只有  val 和 pre属性。   只支持 从左往右 遍历。

     双向链表 结构 有 val   pre   next ，支持 从左往右 和 从右往左 遍历。

 

...............................