算法习题-链表求和2

题目要求：假定用链表表示两个数，其中每个节点仅包含一个数字。假设这两个数的数字顺序排列，请设计一种方法将两个数相加，并将其结果表现为链表的形式。
解体思路：
1、先获取同阶低位，进行求和运算
2、再获取低位的进位，利用进位运算高位
3、最后判断最高位是否进位

public class Solution {
    public ListNode addLists2(ListNode l1, ListNode l2) {
        int le1 = getLength(l1);
        int le2 = getLength(l2);
        if(le1 != le2) {
            int d = le1 - le2;
            ListNode tNode = d > 0 ? l1 : l2;
            // 获取参与运算的链表
            ListNode blank = blank(tNode, Math.abs(d));
            // 低位的求和结果 和 进位
            ListNode[] sum = getSum(blank, tNode == l1 ? l2 : l1);
            // 高位有进位
            if(sum[1].val != 0) {
                int jin = addJinWei(tNode,blank,sum[1].val);
                // 最高位也有进位
                if(jin != 0) {
                    ListNode node = new ListNode(jin);
                    addMaxWei(tNode,blank,sum[0]);
                    node.next = tNode;
                    return node;
                }
            }
            // 没有进位直接拼接
            addMaxWei(tNode,blank,sum[0]);
            return tNode;
        } else {
            ListNode[] sum = getSum(l1, l2);
            if(sum[1].val != 0) {
                ListNode node = new ListNode(sum[1].val);
                node.next = sum[0];
                return node;
            }
            return sum[0];
        }
    }
    
    // 求和的方法，返回值为：求和结果+最后的进位
    ListNode[] getSum(ListNode l1, ListNode l2){
        if(l1 == null || l2 == null)
            return new ListNode[]{null,new ListNode(0)};
        ListNode[] nodes = getSum(l1.next, l2.next);
        int t = l1.val + l2.val + nodes[1].val;
        nodes[1].val = t / 10;
        ListNode[] listNodes = new ListNode[2];
        listNodes[0] = new ListNode(t % 10);
        listNodes[0].next = nodes[0];
        listNodes[1] = new ListNode(nodes[1].val);
        return listNodes;
    }
   
    // 加进位的方法，如果求和的结果的最高位有进位，那末
    //就找到刚刚不参与运算的高位的最低位开始加进位
    int addJinWei(ListNode node,ListNode base,int jin){
        if(node == base)
            return jin;
        jin = addJinWei(node.next,base,jin);
        int t = node.val + jin;
        node.val = t % 10;
        jin = t / 10;
        return jin;
    }

    // 将高位的正确值与低位的正确值进行拼接
    void addMaxWei(ListNode node,ListNode base,ListNode diWei){
        ListNode t = node;
        while(t.next != base)
            t = t.next;
        t.next = diWei;
    }
   
    // 同步链表长度，多余的高位不参与运算
    ListNode blank(ListNode node,int i){
        if(i == 0) return node;
        return blank(node.next,i-1);
    }

    // 获取链表的长度
    int getLength(ListNode node){
        if(node == null) return 0;
        return 1 + getLength(node.next);
    }
}