力扣刷题Day1 --- 2.两数相加以及扩展

第一题比较简单就没有记录啦。每日两题冲冲冲！！

直接进入第二题两数相加

题目描述：

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

力扣题目地址：https://leetcode-cn.com/problems/add-two-numbers/

解题思路：

乍一看我们能想到肯定是每个链表的每个结点相加，而又恰巧这道题数字是按逆序存储，也就是符合我们日常进行数字相加时的从个位开始加起来。

但是这里有一个需要注意的地方：那就是两个数加起来超过10的进位问题。所以我们在写程序时就需要再定义一个变量代表进位！！

ok，接下来给出一个万能加法模板：

加法模板伪代码：

while ( A 还没遍历完 || B 还没遍历完)
{
    A 的当前位
    B 的当前位

    和 = A 的当前位 + B 的当前位 + 进位carry

    当前位 = 和 % 10;
    进位 = 和 / 10;
} 
判断还有进位吗?
   if(有){
        再new一个结点存放这个进位  
   }

 代码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode head=null,tail=null;
        int carry=0;//进位
        while(l1!=null || l2!=null){
            int n1= l1==null ? 0 : l1.val; //如果链表1为空，那么就相当于数字为0，不为空的话返回存放的数字
            int n2= l2==null ? 0: l2.val;
            int sum=n1+n2+carry;  //和 = A的当前位 + B的当前位 + 进位carry
            if(head==null){
                head =new ListNode(sum%10);
                tail=head;
            }else{
                tail.next=new ListNode(sum%10);
                tail=tail.next;
            }
            if(l1!=null){ //如果第一个链表还有数字的话就继续往后移
                l1=l1.next;
            }
            if(l2!=null){ //如果第二个链表还有数字的话就继续往后移
                l2=l2.next;
            }
            carry=sum/10;
        }
        if(carry>0){ 
            //这里进位大于0，说明最后相加的两个数字是大于10的，所以需要向前进一位，那么链表就需要再附加一个一个结点。（就像8+8=16，是不是就需要再附加一个结点了）
            tail.next=new ListNode(carry); //其实这里的carry就相当于1，因为两个一位整数数字相加最多等于18。也就是进位最多为1
        }
        return head;
    }
}

这里其实也可以不用tail指针，可以把他替换成pre预先指针指向head。

小技巧：对于链表问题，返回结果为头结点时，通常需要先初始化一个预先指针 pre，该指针的下一个节点指向真正的头结点head。使用预先指针的目的在于链表初始化时无可用节点值，而且链表构造过程需要指针移动，进而会导致头指针丢失，无法返回结果。

 扩展：

那么如果链表存储的顺序反过来这道题该如何做呢？

我首先想到的是链表先逆序计算，然后将结果再逆序，这就转换到我们之前的情况了。下边分析下单链表逆序的思路。

一、迭代思想（这里是取自github大神的图解）

首先看一下原链表。

总共需要添加两个指针，pre 和 next。

初始化 pre 指向 NULL 。

然后就是迭代的步骤，总共四步，顺序一步都不能错。

• next 指向 head 的 next ，防止原链表丢失（next = head -> next; ）

  

• head 的 next 从原来链表脱离，指向 pre 。（head -> next = pre;）

  

• pre 指向 head，其实就是右移（pre=head;）

  

• head 指向 next，其实就是右移（head=next）

  

一次迭代就完成了，如果再进行一次迭代就变成下边的样子。

可以看到整个过程无非是把旧链表的 head 取下来，添加的新的链表上。代码怎么写呢？

next = head -> next; //保存 head 的 next , 以防取下 head 后丢失
head -> next = pre; //将 head 从原链表取下来，添加到新链表上
pre = head;// pre 右移
head = next; // head 右移

接下来就是停止条件了，我们再进行一次循环。

可以发现当 head 或者 next 指向 null 的时候，我们就可以停止了。此时将 pre 返回，便是逆序了的链表了。

public ListNode reverseList(ListNode head){
        if(head==null) return null;
        ListNode pre=null;
        ListNode next;
        while(head!=null){
            next=head.next;
            head.next=pre;
            pre=head;
            head=next;
        }
        return pre;
    }

二、通过单链表头插法逆序建表实现