【链表】使用链表做加法

问题1:

给定两个用链表表示的整数，每个节点包含一个数位。

这些数位是反向存放的，也就是个位排在链表首部。

编写函数对这两个整数求和，并用链表形式返回结果。

示例：

输入：(7 -> 1 -> 6) + (5 -> 9 -> 2)，即617 + 295
输出：2 -> 1 -> 9，即912

解法: 

从最低位到最高位做加法，增加一个temp用于记录是否要进位，如果链表是a->b->c  和 d->e->f，那么就是

v1 = (temp+a+d) / 10.  temp =  (temp+a+b) %10

v2 = (temp+b+e) / 10.  temp =  (temp+b+e) %10

v3 = (temp+c+f) / 10.  temp =  (temp+c+f) %10

最后构造链路：

v1->v2->v3->(temp>0则增加一个节点)

构造链表

package org.example;

public class ListNode {
    public int val;
    public ListNode next;

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

做加法

package org.example.leetcode_02_05;

import org.example.ListNode;

class Solution {
    //输入：(7 -> 1 -> 6) + (5 -> 9 -> 2)，即617 + 295
    //输出：2 -> 1 -> 9，即912
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {

        int temp = 0;
        ListNode head = new ListNode(0);
        ListNode head0 = head;
        ListNode pre = null;
        while (l1 != null && l2 != null) {
            int v1 = l1.val;
            int v2 = l2.val;

            int v = v1 + v2 + temp;

            temp = v / 10;
            head0.val = v % 10;

            l1 = l1.next;
            l2 = l2.next;

            head0.next = new ListNode(0);
            pre = head0;
            head0 = head0.next;

        }

        while (l1 != null) {
            int v1 = l1.val;

            int v = v1 + temp;

            temp = v / 10;
            head0.val = v % 10;

            l1 = l1.next;

            head0.next = new ListNode(0);
            pre = head0;
            head0 = head0.next;

        }

        while (l2 != null) {

            int v2 = l2.val;

            int v = v2 + temp;

            temp = v / 10;
            head0.val = v % 10;


            l2 = l2.next;

            head0.next = new ListNode(0);
            pre = head0;
            head0 = head0.next;

        }

        if(temp != 0) {
            head0.val = temp;
            head0.next = new ListNode(0);
            pre = head0;
            head0 = head0.next;
        }

        if(head0.val == 0) {
            pre.next = null;
        }

        return head;
    }
}

问题2:

进阶：思考一下，假设这些数位是正向存放的，又该如何解决呢?

示例：

输入：(6 -> 1 -> 7) + (2 -> 9 -> 5)，即617 + 295
输出：9 -> 1 -> 2，即912

在原来代码基础上增加reverse功能:

package org.example.leetcode_02_05;

import org.example.ListNode;

public class SolutionOtherQuestion {

    //输入：(6 -> 1 -> 7) + (2 -> 9 -> 5)，即617 + 295
    //输出：9 -> 1 -> 2，即912
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        Solution solution = new Solution();
        // 调用之前的方法,多次reverse解决问题
        return reverse(solution.addTwoNumbers(reverse(l1), reverse(l2)));
    }

    // 链表reverse功能
    private ListNode reverse(ListNode l1) {

        if (l1.next == null) {
            return l1;
        } else {
            ListNode next = l1.next;
            ListNode node = reverse(next);
            l1.next = null;
            next.next = l1;
            return node;
        }

    }


    public static void main(String[] args) {
        SolutionOtherQuestion solutionOtherQuestion = new SolutionOtherQuestion();


        ListNode node = new ListNode(1);
        node.next = new ListNode(2);
        node.next.next = new ListNode(3);
        node.next.next.next = new ListNode(4);
        ListNode res = solutionOtherQuestion.reverseListNode(node);
        while (res != null) {
            System.out.println(res.val);
            res = res.next;
        }

        System.out.println("=========================");
        // =========================


        //输入：(6 -> 1 -> 7) + (2 -> 9 -> 5)，即617 + 295
        //输出：9 -> 1 -> 2，即912
        ListNode node0 = new ListNode(6);
        node0.next = new ListNode(1);
        node0.next.next = new ListNode(7);


        ListNode node1 = new ListNode(2);
        node1.next = new ListNode(9);
        node1.next.next = new ListNode(5);

        ListNode r = solutionOtherQuestion.addTwoNumbers(node0, node1);
        while (r != null) {
            System.out.println(r.val);
            r = r.next;
        }
    }

    
    private ListNode reverseListNode(ListNode l1) {

        if (l1.next == null) {
            return l1;
        } else {
            ListNode next = l1.next;
            ListNode node = reverseListNode(next);
            l1.next = null;
            next.next = l1;
            return node;
        }
    }
}