LeetCode--单链表--2.两数相加

单链表

概述

• 采用链式存储方法的线性表叫做链表

• 链表通常由一连串节点组成，每个节点包含任意的实例数据（data fields）和一或两个用来指向上一个/或下一个节点的位置的链接（“links”） （data 和 指针）

• 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)

性质：

• 其节点的存储单元可以不连续，每个节点中除存储原表结点中的数据外，还须存储上一个/下一个节点的地址，以反映节点之间的逻辑关系
• 获取数据麻烦，需要遍历查找，比数组慢
• 方便插入、删除

实现原理

① 创建一个节点类，其中节点类包含两个部分，第一个是数据域（你到时候要往节点里面储存的信息），第二个是引用域（相当于指针，单向链表有一个指针，指向下一个节点；双向链表有两个指针，分别指向下一个和上一个节点）。

② 创建

一个链表类，其中链表类包含三个属性：头结点、尾节点和大小，方法包含添加、删除、插入等等方法。

package com.security.controller;

/**
 * 单向链表
 */
public class MyLink {
    //头节点
    Node head = null;

    /**
     * 链表中的节点
     */
    class Node{
        //节点的引用，指向下一个节点
        Node next = null;
        //节点的对象，即内容
        int data;

        public Node(int data){
            this.data = data;
        }
    }

    /**
     * 向链表中插入数据
     * @param d
     */
    public void addNode(int d){
        //实例化一个节点
        Node newNode = new Node(d);
        if (head == null) {
            head = newNode;
            return;
        }
        Node tmp = head;
        while (tmp.next != null){
            tmp = tmp.next;
        }
        tmp.next = newNode;
    }

    /**
     * 除第index个节点
     * @param index
     * @return
     */
    public boolean deleteNode(int index){
        if (index < 1 || index > length()){
            return false;
        }
        if (index == 1){
            head = head.next;
            return true;
        }
        int i = 1;
        Node preNode = head;
        Node curNode = preNode.next;
        while (curNode != null){
            if (i == index){
                preNode.next = curNode.next;
                return true;
            }
            preNode = curNode;
            curNode = curNode.next;
            i++;
        }
        return false;
    }

    /**
     * 返回节点长度
     * @return
     */
    public int length(){
        int length = 0;
        Node tmp = head;
        while (tmp != null){
            length++;
            tmp = tmp.next;
        }
        return length;
    }

    /**
     * 在不知道头指针的情况下删除指定节点
     * @param n
     * @return
     *不知道头结点就无法遍历到这个节点，就不能采用将上一个节点的指针跳过该节点，只能造一个“前一个节点”
     */
    public boolean deleteNode11(Node n){
        if (n == null || n.next == null){
            return false;
        }
        int tmp = n.data;
        n.data = n.next.data;
        n.next.data = tmp;
        n.next = n.next.next;
        System.out.println("删除成功！");
        return true;
    }

    public void printList(){
        Node tmp = head;
        while (tmp != null){
            System.out.println(tmp.data);
            tmp = tmp.next;
        }
    }

    public static void main(String[] args) {
        MyLink list = new MyLink();
        list.addNode(88);
        list.addNode(66);
        list.addNode(77);
        list.addNode(2);
        list.addNode(55);
        list.addNode(36);
        System.out.println("linkLength:" + list.length());
        System.out.println("head.data:" + list.head.data);
        list.printList();
        list.deleteNode(4);
        System.out.println("After deleteNode(4):");
        list.printList();
    }

}

链表的创建和遍历（头插法和尾插法）

public class LinkList {
    
    //定义链表的头结点
     ListNode head = null;
    

       /**
     * 尾插法添加元素生成链表 
     * @param val 值
     */
    public  void EndInsert(int val) {
        //每次执行这个方法的时候，都要新建路一个节点用来存储数据、
        ListNode listNode = new ListNode(val);
        //判断头特点是否为空,如果是那么将头结点指向新的节点，然后结束
        if (head == null) {
            head = listNode;
            return;
        }
        
        //定义一个临时结点由他的充当指针，指针最开始指向头节点
        ListNode indexNode = listNode;
        //从头结点可是遍历，到最尾部插入
        while (indexNode.next != null) {
            indexNode = indexNode.next;
            
        }
        indexNode.next = listNode;
    }
    
 
     /**
     * 头插法添加元素生成链表 
     * @param val
     */
    public  void HeadInsert(int val) {
        //每次执行这个方法的时候，都要新建路一个节点用来存储数据、
        ListNode listNode = new ListNode(val);
        //判断头特点是否为空,如果是那么将头结点指向新的节点，然后结束
        if (head == null) {
            head = listNode;
            return;
        }
        
        listNode.next = head;
        head= listNode;
    }
    
    /**
     * 链表的输出
     */
    public void printLink() {
        //定义一个临时结点充当指针，从头结点喀什不断想向后移动
        ListNode tempListNode = head;
        
        //将临时结点不断的往后边移动，直到临时结点指向了 null;
        while (tempListNode  !=null) {
            System.out.print(tempListNode.val);
            tempListNode = tempListNode.next;
        }
        System.out.println();
    }
    
    /**
     * @return  链表的长度
     */
    public int GetListLenght() {
        //定义一个节点指向该链表
        ListNode tempListNode = head;
        int length = 0;
        while (tempListNode != null) {
            length ++;
            tempListNode = tempListNode.next;
        }
        
        return length;
    }	
}

判断链表是否有环

方法一：循环遍历节点，遍历一个便标记一个，遍历过程判断是否被标记，若已被标记则表示有环

方法二：声明两个指针，一个指针走一次经过两个节点(快指针quick)，另一个走一次经过一个节点(慢指针slow)

public class Solution {
public boolean hasCycle(ListNode head) {
==//声明两个节点从头开始遍历节点==
ListNode quick = head;
ListNode slow = head;
//当快指针能够走到头表示无环
while(quick!=null&&quick.next!=null){
quick = quick.next.next;
slow = slow.next;
if(quick==slow){
return true;
}
}
return false;
}
}

2.两数相加

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

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

你可以假设除了数字 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
题目数据保证列表表示的数字不含前导零

/**
 * 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 pre =new ListNode(0);
        ListNode cur = pre;
        int carry =0;
        int sum =0;
        while(l1!=null || l2!= null){
            int x =l1==null? 0 :l1.val;
            int y =l2==null? 0: l2.val;
            sum = x+y+carry;
            carry = sum/10;
            sum = sum%10;

            cur.next = new ListNode(sum);
            cur = cur.next;
            if(l1!=null){
                l1 = l1.next;
            }
            if(l2!=null){
                l2 = l2.next;
            }

        }
        if(carry!=0){
            cur.next = new ListNode(carry);

        }
        return pre.next;
       
}}

//判断两个链表至少有一个有数值，才继续计算，不然直接返回当前新链表
//该思路进行循环的条件是，两个列表至少一个不为空
//通过设置预先节点pre和当前节点cur来进行结果链表的生成
//假设两个链表长度一致，短链表缺的部分补0即可
//要注意处理最后一位的进位，若为1要新建节点加上