Week02

第一题：两数相加

链接: https://leetcode-cn.com/problems/add-two-numbers/.
题号：leetcode2
难度：medium

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例 1：

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.

示例 2：

输入：l1 = [0], l2 = [0]
输出：[0]

示例 3：

输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

提示：

每个链表中的节点数在范围 [1, 100] 内
0 <= Node.val <= 9
题目数据保证列表表示的数字不含前导零

思路：

1.首先申请一个链表list，ListNode list = new ListNode(); 长度是1。链表指向头节点。此时是空的链表，所以list头节点的数据域是0。
2.申请一个尾指针，指向list链表的末尾节点。ListNode tail = list; 初始tail指针和list指针指向链表头节点。
3.考虑l1和l2两个链表的长度可能不相等，所以while(l1 != null || l2!= null)，只要有一个链表不为空，继续进行相加操作。
4.将l1，l2两个链表的数据域进行相加，(l1和l2也是指针，初始指向链表头节点)。
结果如果大于等于10，则会产生进位。即list链表的下一个节点数据域等于l1和l2对应数据域之和再加1。
5.相加的结果如何存储在list链表中呢？new ListNode(相加的结果);
如何插入到链表中呢？这个时候需要tail指针了。tail.next = new ListNode(相加的结果);
即将结果插入到链表中，此时tail指针需要下移一位。tail = tail.next;
6.l1和l2两个链表也需要向下移动一位（注意判断是否已经移动到末尾了。如果到末尾，则不移动）
7.循环结束，判断进位是否是1或者是否是0，不是0说明两个链表末尾相加产生进位，需要再申请一个节点存储进位1.
8.返回list链表（不能return list 因为刚开始申请的list指向链表头节点，而头节点数据是0）
return list.next;
注意：
如果最终想要return list；
那么在刚开始申请list链表时操作是ListNode list = new ListNode((l1.val+l2.val)%10);
此时list指向链表头节点，节点点数据域是两个链表头节点数据域之和。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode list = new ListNode();  //创建一个空链表list
        ListNode tail = list;  //尾指针，指像末尾节点（初始tail,list指向头节点）

        int sum = 0;  //链表对应位数据相加，（也要加上进位carry）
        int carry = 0; //进位
        while(l1 != null || l2!= null){
            //sum = l1.val + l2.val + carry;   //注意，可能出现null值
            sum = (l1!=null ? l1.val:0) + (l2!=null ? l2.val:0) + carry;  //链表对应位置数进行相加，包括进位
            carry = sum / 10;   //相加结果，进位的变化
            tail.next = new ListNode(sum % 10);   //添加一个节点元素
            tail = tail.next;   //tail指向末尾节点
            /*
            注意：在指针向下移动的时候，注意，当前指针是否已经指向末尾节点。
            l1 = l1.next;
            l2 = l2.next;
            */   
            if(l1 != null) l1 = l1.next;
            if(l2 != null) l2 = l2.next;
        }

        if(carry != 0){    //如果最终链表末尾相加之后还产生进位。则需要产生一个进位1
            tail.next = new ListNode(1);
            tail = tail.next;
        }
        return list.next;
    }
}

第二题：反转链表

链接: https://leetcode-cn.com/problems/reverse-linked-list/.
题号：leetcode206
难度：easy

反转一个单链表

示例：

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

进阶:
你可以迭代或递归地反转链表。你能否用两种方法解决这道题？

思路：

1.申请list链表，ListNode list = new ListNode(head.val); 将head的头节点作为list尾节点(不能ListNode list = new ListNode()，这样数据域是0)
2.head = head.next; head指针下移一位
3.while(head != null) 当head没有到达末尾时，循环
4.使用头插法插入节点。

头插法核心代码：

ListNode tem = new ListNode(head.val); //将head指向的数据域封装成链表节点
tem.next = list; //使用头插法插入节点
list = tem; //list指向头节点
head = head.next; //head指针下移一位

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        //边界条件判断
        if(head == null) return null;  

        //将head的头节点作为list尾节点(不能ListNode list = new ListNode()，这样数据域是0)
        ListNode list = new ListNode(head.val); 
        head = head.next;         //head指针下移一位
        while(head != null){      //当head没有到达末尾时，循环
            ListNode tem = new ListNode(head.val);  //将head指向的数据域封装成链表节点
            tem.next = list;      //使用头插法插入节点
            list = tem;           //list指向头节点
            head = head.next;     //head指针下移一位
        }
        return list;     //因为list指向头节点，返回list
    }
}