剑指 链表06、18、22、24、52、35

06、从尾到头打印链表

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

输入：head = [1,3,2]
输出：[2,3,1]

方法一：栈
时间复杂度：O(n)。正向遍历一遍链表，然后从栈弹出全部节点，等于又反向遍历一遍链表。
空间复杂度：O(n)。额外使用一个栈存储链表中的每个节点。

class Solution {
    public int[] reversePrint(ListNode head) {
        Stack<ListNode> stack = new Stack<ListNode>();
        ListNode temp = head;
        while (temp != null) {
            stack.push(temp);
            temp = temp.next;
        }
        int size = stack.size();
        int[] print = new int[size];
        for (int i = 0; i < size; i++) {
            print[i] = stack.pop().val;
        }
        return print;
    }
}

方法二：递归
时间复杂度 O(N)： 遍历链表，递归 N 次。
空间复杂度 O(N)： 系统递归需要使用 O(N)的栈空间。

class Solution {
    int[] res;
    int i;//全局变量
    public int[] reversePrint(ListNode head) 
    {

        recur(head,0);//递归函数调用
        return res;
    }
    void recur(ListNode head,int count)
   {
        if(head == null)
        {//递归终止条件
            res = new int[count];
            i = count-1;
            return;
        }
        recur(head.next,count+1);
        res[i-count] =  head.val; //这里的i-count是重点
    }

}

18、删除链表的节点

给定单向链表的头指针和一个要删除的节点的值/节点指针，定义一个函数删除该节点。返回删除后的链表的头节点。

输入: head = [4,5,1,9], val = 5
输出: [4,1,9]

1、val: ListNode（节点指针） 解法：信息交换法
把待删除节点的后一个元素赋值给待删除节点，也就相当于删除了当前元素。
举出反例：如果 val 的值是最后一个元素呢？我们无法找到最后一个元素的后一个元素（因为没有），只能重头开始找待删除元素，这样的话时间复杂度再次变成了 O(N)。

时间复杂度：O(1)。平均时间复杂度为：(O(1)\times(n-1) + O(n))/n = O(1)，仍然为 O(1)。
空间复杂度：O(1)。

class deleteNode {public static ListNode deleteNode(ListNode head, ListNode val){
        if (head == null || val == null){
            return null;
        }
        if (val.next != null){   // 待删除节点不是尾节点
            ListNode next = val.next;
            val.val = next.val;
            val.next = next.next;
        } else if (head == val){   // 待删除节点只有一个节点，此节点为头节点
            head = null;
        } else {   // 待删除节点为尾节点
            ListNode cur = head;
            while (cur.next != val){
                cur = cur.next;
            }
            cur.next = null;
        }
        return head;
    }
 
}

2、val: int（节点值） 解法：单指针常见解法
时间复杂度 O(N) ： N 为链表长度，删除操作平均需循环 N/2次，最差 N 次。
空间复杂度 O(1)

class Solution {
    public ListNode deleteNode(ListNode head, int val) {
        if (head == null) return null;
        if (head.val == val) return head.next;
        ListNode cur = head;
        while (cur.next != null && cur.next.val != val)
            cur = cur.next;
        if (cur.next != null)
            cur.next = cur.next.next;
        return head;
    }
}

22、链表中倒数第k个节点

输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如，一个链表有6个节点，从头节点开始，它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点。

给定一个链表: 1->2->3->4->5, 和 k = 2.
返回链表 4->5.

方法一：遍历链表长度，设置一个指针走 (n-k) 步，即可找到链表倒数第 k个节点。

public ListNode getKthFromEnd(ListNode head, int k) {
    int length = 0;
    ListNode p = head;
    // 第一遍
    while (p!=null){
        length++;
        p = p.next;
    }
    if (length<k) return null;
    // 第二遍
    p = head;
    for (int i=0;i<length-k;i++){
        p = p.next;
    }
    return p;
}

方法二：使用双指针则可以不用统计链表长度。第一个指针从链表的头指针开始遍历向前走k-1步，第二个指针保持不动；从第k步开始两个指针一起走，当第一个指针到达链表结尾时，第二个指针刚好走到倒数第k个节点。

时间复杂度 O(N) ： N为链表长度；总体看，former 走了 N步，latter 走了(N-k)步。
空间复杂度 O(1) ：双指针 former,latter 使用常数大小的额外空间。

class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        ListNode former = head, latter = head;
        for(int i = 0; i < k; i++) {
            if(former == null) return null;
            former = former.next;
        }
        while(former != null) {
            former = former.next;
            latter = latter.next;
        }
        return latter;
    }
}

还可以使用栈或递归实现。

public ListNode getKthFromEnd(ListNode head, int k) {
    Stack<ListNode> stack = new Stack<>();
    //链表节点压栈
    while (head != null) {
        stack.push(head);
        head = head.next;
    }
    //在出栈串成新的链表
    ListNode firstNode = stack.pop();
    while (--k > 0) {
        ListNode temp = stack.pop();
        temp.next = firstNode;
        firstNode = temp;
    }
    return firstNode;
}

int size;

public ListNode getKthFromEnd(ListNode head, int k) {
    if (head == null)
        return head;
    ListNode node = getKthFromEnd(head.next, k);
    if (++size == k)
        return head;
    return node;
}

24、反转链表

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

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

方法一：递归
空间复杂度：O(n)

class Solution {
    public ListNode reverseList(ListNode head) {
    if(head==null||head.next==null)
    {
        return head;
    }
    ListNode cur=reverseList(head.next);
    head.next.next=head;
    head.next=null;
    return cur;
    }
}

方法二：迭代（三个指针）
定义两个节点：pre, cur ，其中 cur 是 pre 的后继结点，如果是首次定义， 需要把 pre 指向 cur 的指针去掉，否则由于之后链表翻转，cur 会指向 pre， 就进行了一个环(如下)，这一点需要注意。

class Solution {
    public ListNode reverseList(ListNode head) {
    ListNode pre=null;
    ListNode cur=head;
    ListNode tmp=null;
    while(cur!=null)
    {
        tmp=cur.next;
        cur.next=pre;
        pre=cur;
        cur=tmp;
    }
    return pre;
    }
}

52、两个链表的第一个公共节点

输入两个链表，找出它们的第一个公共节点。
“本题类似二叉树两个叶子节点的最低公共祖先节点”

示例 ：输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Reference of the node with value = 8
输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

如果两个链表没有交点，返回 null.
在返回结果后，两个链表仍须保持原有的结构。
可假定整个链表结构中没有循环。
程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。

方法一：暴力（每到第一个链表的每个节点都遍历一遍第二个链表）
时间复杂度O（mn） 两链表长为m和n

方法二：栈（将两链表压栈一次比较最上面的元素，直到第一个不同，那么前一个就是第一个相同的节点）用空间换时间
时间/空间复杂度O（m+n）

方法三：首先遍历两个链表，得到两个链表的长度，在第二次遍历的时候使长链表比短链表先多走m-n步。
时间复杂度O（m+n）节省了空间

public class Solution { 
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) { 
        if(headB==null||headA==null) return null; 
        ListNode cur1=headA,cur2=headB; 
        int n=0; 
        while(cur1!=null){ 
            n++; 
            cur1=cur1.next; 
        }
        while(cur2!=null){ 
            n--;
            cur2=cur2.next; 
        } 
        cur1=n>0?headA:headB; 
        cur2=cur1==headA?headB:headA; 
        n=Math.abs(n); 
        while(n>0){ 
            cur1=cur1.next; 
            n--;
        } 
        while(cur1!=cur2){ 
            cur2=cur2.next; 
            cur1=cur1.next; 
        } 
        return cur1; 
    } 
} 

方法三（进阶）：！！通过遍历一遍的差值直接过第二遍

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) {
            return null;
        }
        ListNode node1 = headA, node2 = headB;
        while (node1 != node2) {
            node1 = node1 != null ? node1.next : headB;
            node2 = node2 != null ? node2.next : headA;
        }
        return node1;
    }

实现时需要注意的一点是：

node1=node1?node1->next:headB;

而不是

node1=node1->next?node1->next:headB;

35、复杂链表的复制*

请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。

示例 1：输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]

HashMap解法
1.创建HashMap
2.复制结点值
3.复制指向（next,random）

class Solution { //HashMap实现
    public Node copyRandomList(Node head) {
        HashMap<Node,Node> map = new HashMap<>(); //创建HashMap集合
        Node cur=head;
        //复制结点值
        while(cur!=null){
            //存储put:<key,value1>
            map.put(cur,new Node(cur.val)); //顺序遍历，存储老结点和新结点(先存储新创建的结点值)
            cur=cur.next;
        }
        //复制结点指向
        cur = head;
        while(cur!=null){
            //得到get:<key>.value2,3
            map.get(cur).next = map.get(cur.next); //新结点next指向同旧结点的next指向
            map.get(cur).random = map.get(cur.random); //新结点random指向同旧结点的random指向
            cur = cur.next;
        }
        //返回复制的链表
        return map.get(head);
    }
}