9.2链表（五）——给定两个用链表表示的整数，每个结点包含一个数位。这些数位是反向存放的，也就是个位排在链表首部

/**

 * 功能：给定两个用链表表示的整数，每个结点包含一个数位。这些数位是反向存放的，也就是个位排在链表首部。

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

 * 进阶：假设这些数位是正向存放的，请再做一遍。

 */

题目一：反向存放

      //将两个节点的值逐一相加，如有进位，则转入下一个节点
      public static LinkedListNode addLists(LinkedListNode node1,LinkedListNode node2, int carry){
             //若两个链表全部为空，且进位为0，则返回
             if( node1== null&& node2== null&& carry==0)
                   return null;
            
            LinkedListNode result= new LinkedListNode();
             int value= carry;
             if( node1!= null){
                   value+= node1. data;
            }
             if( node2!= null){
                   value+= node2. data;
            }
             result. data= value%10;
            
            LinkedListNode more= addLists(node1==null?null:node1.next, node2== null? null: node2. next, value/10==1?1:0);
             result. next= more;
             return result;
            
      }

题目二：正向存放

      //返回求和结果和进位
      public static class PartialSum{
             public LinkedListNode sum= null;
             public int carry=0;           
      }

      public static LinkedListNode addLists2(LinkedListNode node1,LinkedListNode node2){
            PartialSum sum= new PartialSum();
             int len1= length(node1);
             int len2= length(node2);
            
             //对较短的链表高位进行补零
             if( len1< len2){
                   padList(node1,len2-len1);
            } else{
                   padList(node2,len1-len2);
            }
             //对两个链表求和
             sum= addListHelper(node1, node2);
             //如果有进位，插入首位，否则直接返回
             if( sum. carry==0){
                   return sum. sum;
            } else{
                  LinkedListNode finalRes= insertBefore(sum.sum, sum. carry);
                   return finalRes;
            }
            
      }
      
      //链表求和
      public static PartialSum addListHelper(LinkedListNode node1,LinkedListNode node2){
            PartialSum sum= new PartialSum();
             if( node1== null&& node2== null){
                   return sum;
            }
                        
             //对应为相加
             sum= addListHelper(node1.next,node2.next);
             int val= sum. carry+ node1. data+ node2. data;
            
             //插入当前数字的求和结果
            LinkedListNode result= insertBefore(sum.sum, val%10);
             sum. sum= result;
             sum. carry= val/10;
            
             return sum;
      }
      
      //用零填充较短链表的开头
      public static LinkedListNode padList(LinkedListNode node, int padding){
            LinkedListNode head= node;
             for( int i=0; i< padding; i++){
                  LinkedListNode n= new LinkedListNode(0, null, null);
                   n. next= head;
                   head= n;
            }           
             return head;
      }
      
      //求链表的长度
      public static int length(LinkedListNode node){
             int len=0;
             if( node== null)
                   return 0;
            
             while( node!= null){
                   len++;
                   node= node. next;
            }
             return len;
      }
      
      //将节点插入链表首部
      public static LinkedListNode insertBefore(LinkedListNode node, int data){
            LinkedListNode n= new LinkedListNode( data);
             if( node!= null){
                   n. next= node;
            }           
             return n;
      }