LeekCode2_链表反向存储+求和(中等)

题目

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

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

解题

将长度较短的链表在末尾补零使得两个连表长度相等，再一个一个元素对其相加（考虑进位）

就是将取模后的数值放到结点中，每次相加都算上进位的数，到最后判断如果进位数字大于一，再创建一个结点放入数值。

//两个数相加
    public listNode2 addSum(listNode2 l1,listNode2 l2){
        //首先设置头结点和引用
        listNode2 head = null,tail = null;
        //设置进位
        int carry = 0;
        while (l1 != null || l2 != null){
            // 取出一个值,如果没有结点,则自动补零
            int i1 = l1 != null ? l1.val:0;
            int i2 = l2 != null ? l2.val:0;
            int sum = i1 + i2 + carry;  //得到本身加进位的
            int other = sum % 10;    //取模得出余数
            if (head == null) {        //如果不存在首节点创建
                head = new listNode2(other);    //给结点赋值
                tail = head;
            }else {
                tail.next = new listNode2(other);
                tail = tail.next;          //将指 针向后移动指向当前结点
            }

            if (l1!= null){
                l1 = l1.next;
            }
            if (l2!=null){
                l2 = l2.next;
            }
        }
        //如果最后还有进位，就需要再创建一个
        if (carry > 0 ){
            tail.next = new listNode2(carry);
        }
        return head;
    }

创建链表并反向存储

正好复习下链表的知识，以下用java写的创建和遍历

public class listNode2 {

    private int val;            //存放数据
    private listNode2 next;     //引用,相当于指针

    //无参构造用于初始化这个类 调用方法
    public listNode2(){}

    //用于初始化结点
    public listNode2(int x){
        this.val = x;
        this.next = null;
    }

    //用于创建结点(逆序存储数组中的数)
    public void create(int a[],listNode2 head){

        listNode2 tail = head;//一个变量,相当于指针移动
        for (int i = a.length-2; i >=0 ; i--) {
            listNode2 first = new listNode2(a[i]);//下一个结点
            tail.next = first;  //将结点连接起来
            tail = tail.next;   //移动到下一个结点
        }
        //遍历
        list(head);
    }

    //遍历链表
    public void list(listNode2 head){

        listNode2 tail = head;//定义一个变量用于遍历
        System.out.print("链表:");
        while (tail != null){
            System.out.print(tail.val+" ");
            tail = tail.next;
        }
        System.out.println();
    }

    //两个数相加
    public listNode2 addSum(listNode2 l1,listNode2 l2){
        //首先设置头结点和引用
        listNode2 head = null,tail = null;
        //设置进位
        int carry = 0;
        while (l1 != null || l2 != null){
            // 取出一个值,如果没有结点,则自动补零
            int i1 = l1 != null ? l1.val:0;
            int i2 = l2 != null ? l2.val:0;
            int sum = i1 + i2 + carry;  //得到本身加进位的
            int other = sum % 10;    //取模得出余数
            if (head == null) {        //如果不存在首节点创建
                head = new listNode2(other);    //给结点赋值
                tail = head;
            }else {
                tail.next = new listNode2(other);
                tail = tail.next;          //将指 针向后移动指向当前结点
            }

            if (l1!= null){
                l1 = l1.next;
            }
            if (l2!=null){
                l2 = l2.next;
            }
        }
        //如果最后还有进位，就需要再创建一个
        if (carry > 0 ){
            tail.next = new listNode2(carry);
        }
        return head;
    }
}

测试

public static void main(String[] args) {
        int l1[]={2,4,3};
        listNode2 list = new listNode2(l1[l1.length-1]);  //逆序数组创建头结点
        list.create(l1,list);

        int l2[]={5,6,4};
        listNode2 list2 = new listNode2(l2[l2.length-1]);  //逆序数组创建头结点
        list2.create(l2,list2);

        //测试结果两数之和
        listNode2 listNode2 = list.addSum(list, list2);
        list.list(listNode2);

    }

结果

链表:3 4 2
链表:4 6 5
链表:7 0 8