程序员面试金典--题目解析-2.5 编写函数对两个整数求和，整数存放在链表中

2.5 题目：

两个链表表示两个数，每个节点表示一个数位。要求实现每位相加，输出结果

比如：(7 -->1 -->6) + (5 --> 9 -->2) 即617+295

输出：2 --> 1 --> 9  即912

1、反向存放

2、正向存放（进阶）

解法：

Node Class定义：

1. public static class Node<E>{  
2.         private E item;  
3.         private Node<E> next;  
4.         private boolean isValid = true;  
5.           
6.           
7.           
8.         public boolean isValid() {  
9.             return isValid;  
10.         }  
11.         public Node(E item) {  
12.             this.item = item;  
13.         }  
14.         public E getItem() {  
15.             return item;  
16.         }  
17.         public void setItem(E item) {  
18.             this.item = item;  
19.         }  
20.         public Node<E> getNext() {  
21.             return next;  
22.         }  
23.         public void setNext(Node<E> next) {  
24.             this.next = next;  
25.         }  
26.         @Override  
27.         public String toString() {  
28.             return "Node [item=" + item + "]";  
29.         }  
30.           
31.           
32.           
33.     }  

Result类，用于存放 每位计算的结果 和是否进位

1. public static class Result{  
2.         int digit;  
3.         boolean isCarried;  
4.     }  

1、逆向存放

1. public static Node<Integer> addTwoListReverse(Node<Integer> head1,Node<Integer> head2){  
2.         if(head1 == null && head2 == null)  
3.             return null;  
4.           
5.         Node<Integer> p = head1;  
6.         Node<Integer> q = head2;  
7.         Node<Integer> head = null;  
8.         Node<Integer> tail = null;  
9.         boolean isCarried = false;  
10.           
11.         while(p != null || q != null){  
12.             Result result = null;  
13.             if(p == null){  
14.                 result = doAdd(0,q.item,isCarried);  
15.             }  
16.             else if(q == null){  
17.                 result = doAdd(p.item,0,isCarried);  
18.             }  
19.             else{  
20.                 result = doAdd(p.item,q.item,isCarried);  
21.             }  
22.               
23.             Node<Integer> newNode = new Node<Integer>(result.digit);  
24.             if(head == null){  
25.                 newNode.next = head;  
26.                 head = newNode;  
27.                 tail = newNode;  
28.             }else{  
29.                 tail.next = newNode;  
30.                 newNode.next = null;  
31.                 tail = newNode;  
32.             }  
33.               
34.             if(result.isCarried){  
35.                 isCarried = true;  
36.             }  
37.             else{  
38.                 isCarried = false;  
39.             }  
40.               
41.             if(p == null){  
42.                 q = q.next;  
43.             }  
44.             else if(q == null){  
45.                 p = p.next;  
46.             }  
47.             else{  
48.                 p = p.next;  
49.                 q = q.next;  
50.             }  
51.               
52.         }  
53.           
54.         return head;  
55.     }  
56.       
57.       
58.   
59.     private static Result doAdd(Integer item1, Integer item2, boolean isCarried) {  
60.         Result result = new Result();  
61.         if(!isCarried){  
62.             int temp = item1 + item2;  
63.             if(temp>10){  
64.                 result.digit = temp % 10;  
65.                 result.isCarried = true;  
66.             }  
67.             else{  
68.                 result.digit = temp;  
69.                 result.isCarried = false;  
70.             }  
71.         }else{  
72.             int temp = item1 + item2 + 1;  
73.             if(temp>10){  
74.                 result.digit = temp % 10;  
75.                 result.isCarried = true;  
76.             }  
77.             else{  
78.                 result.digit = temp;  
79.                 result.isCarried = false;  
80.             }  
81.         }  
82.         return result;  
83.     }  

测试用例：

1. @Test  
2.     public void test_2_5(){  
3.         Node<Integer> head1 = new Node<>(0);  
4.         createIntegerNode(head1, 10);  
5.         Node<Integer> head2 = new Node<>(0);  
6.         createIntegerNode(head2, 20);  
7.         printNodeList(head1);  
8.         printNodeList(head2);  
9.         Node<Integer> result = LinkedListUtil.addTwoList(head1, head2);  
10.         printNodeList(result);  
11.     }  
12.       
13.     private Node<Integer> createIntegerNode(Node<Integer> head,int number){  
14.         Node<Integer> p = head;  
15.         for(int i = 1;i < number;i++){  
16.             if(i<(number/2)){  
17.                 p.setNext(new Node<Integer>(i));  
18.             }  
19.             else{  
20.                 p.setNext(new Node<Integer>(i%(number/2)));  
21.             }  
22.             p = p.getNext();  
23.         }  
24.         return head;  
25.     }  
26.       
27.     private <E> void printNodeList(Node<E> head){  
28.         Node<E> node = head;  
29.         while(node != null && node.isValid()){  
30.             System.out.print(node.getItem() + " ");  
31.             node = node.getNext();  
32.         }  
33.         System.out.println();  
34.     }  

输出结果：

0 1 2 3 4 0 1 2 3 4 
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 
0 2 4 6 8 5 7 9 1 4 1 1 2 3 4 5 6 7 8 9 

2、正向存放

正向存放，可以考虑把链表翻转，然后使用逆向存放的函数求出结果，再将结果链表翻转即可。

代码如下：

1. public static <E> Node<Integer> addTwoListForward(Node<Integer> head1,Node<Integer> head2){  
2.         Node<Integer> newHead1 = reverseList(head1);  
3.         Node<Integer> newHead2 = reverseList(head2);  
4.           
5.         Node<Integer> tempResult = addTwoListReverse(newHead1, newHead2);  
6.         Node<Integer> finalResult = reverseList(tempResult);  
7.         return finalResult;  
8.     }  

翻转代码：

1. public static Node<Integer> reverseList(Node<Integer> head) {  
2.         Node<Integer> newHead = new Node<Integer>(head.item);  
3.         newHead.next = null;  
4.           
5.         if(head.next == null)  
6.             return head;  
7.           
8.         Node<Integer> p = head.next;  
9.           
10.         while(p!=null){  
11.             Node<Integer> next = p.next;  
12.             p.next = newHead;  
13.             newHead = p;  
14.             p = next;  
15.         }  
16.           
17.         return newHead;  
18.     }  

测试用例：

1. @Test  
2.     public void test_2_5_Forward(){  
3.         Node<Integer> head1 = new Node<>(1);  
4.         createIntegerNode(head1, 20);  
5.         Node<Integer> head2 = new Node<>(1);  
6.         createIntegerNode(head2, 10);  
7.         printNodeList(head1);  
8.         printNodeList(head2);  
9.         System.out.println("--------------------");  
10.         Node<Integer> result = LinkedListUtil.addTwoListForward(head1, head2);  
11.         printNodeList(result);  
12.     } 

测试结果：

11234567890123456789

+               1123401234

11234567891246858023

打印结果

1 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 
1 1 2 3 4 0 1 2 3 4 
--------------------

1 1 2 3 4 5 6 7 8 9 1 2 4 6 8 5 8 0 2 3