【原創】java實現兩單鏈表相加求和

題目要求：

用單向鏈表表示十進制整數，求兩個正整數的和。

示例一：9999+999=10998，鏈表表示爲：9->9->9->9->null和9->9->9->null的結果爲1->0->9->9->8->null

示例二：12+34=46。，鏈表表示爲：1->2->null和3->4->null的結果爲4->6->null

注意單項鍊表的方向從前向後，不容許使用其餘數據結構。

 

思路：

1. 若是有空鏈表，直接返回

2. 判斷兩個鏈表是否等長，不等長則左補0使之等長

3. 十進制加法須要進位，反轉鏈表再相加更方便

4. 相加後，再次反轉鏈表即爲結果

 

代碼：

鏈表定義：

public class ListNode {
    ListNode next = null;
    int value; // 節點數據
    public ListNode(int value) {
        this.value = value;
    }
}

主要方法代碼以下：

public ListNode addTwoNumbers(ListNode listNode1, ListNode listNode2){
        // 若是有空鏈表，直接返回
        if(listNode1 == null) {
            return listNode2;
        }else if(listNode2 == null) {
            return listNode1;
        }
        
        // 判斷兩個鏈表是否等長，不等長則左補0使之相等
        if(size(listNode1) > size(listNode2)) {
            listNode2 = complete(listNode2, size(listNode1) - size(listNode2));
        }else if(size(listNode1) < size(listNode2)) {
            listNode1 = complete(listNode1, size(listNode2) - size(listNode1));
        }
        
        // 反轉鏈表
        listNode1 = reserveLink(listNode1);
        listNode2 = reserveLink(listNode2);
        
        ListNode resultListNode = new ListNode(0);
        ListNode listNode = resultListNode;   
        int sum = 0; // 相加總和
        int prog = 0;  // 進位值
        while(listNode1 != null && listNode2 != null) {
            sum = listNode1.value + listNode2.value + prog;
            prog = sum / 10;
            sum = sum % 10;
            listNode.next = new ListNode(sum); // 尾插法
            listNode = listNode.next; // 後移
            listNode1 = listNode1.next;
            listNode2 = listNode2.next;
        }
        // 最高位還有進位
        if(prog != 0){
            listNode.next = new ListNode(prog);
        }else {
            // 去掉最前面的0,防止反轉後數值不對
            resultListNode = resultListNode.next;
        }
        
        return reserveLink(resultListNode);
    }

獲取鏈表長度：

public int size(ListNode node) {
        if(node == null) {
            return 0;
        }
        int size = 0;
        while(node != null) {
            node = node.next;
            size++;
        }
        
        return size;
    }

左補N個0：

public ListNode complete(ListNode node, int num) {
        if(node == null) {
            return node;
        }
        if(num <= 0) {
            return node;
        }
        for (int i = 0; i < num; i++) {
            ListNode n0 = new ListNode(0);
            n0.next = node;
            node = n0;
        }
        
        return node;
    }

反轉鏈表：

private ListNode reserveLink(ListNode head) {
        ListNode preNode = null;
        while(head != null) {
            ListNode nextNode = head.next; // 保留下一個結點
            head.next = preNode; //指針反轉
            preNode = head; //前結點後移
            head = nextNode; //當前結點後移
        }
        
        return preNode;
    }