删除链表的倒数第 n 个结点，并且返回链表的头结点

删除链表的倒数第 n 个结点，并且返回链表的头结点

方式一，使用普通方法

public class ListNodeDemo2 {
    public static void main(String[] args) {
        ListNode head = new ListNode(1);
        ListNode data1 = new ListNode(2);
        ListNode data2 = new ListNode(3);
        ListNode data3 = new ListNode(4);
        ListNode data4 = new ListNode(5);
        data3.next = data4;
        data2.next = data3;
        data1.next = data2;
        head.next = data1;
        ListNode listNode = removeNthFromEnd(head, 2);
        for (ListNode temp = listNode; temp != null; temp = temp.next) {
            System.out.println(temp.val);
        }
    }

    //给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
    public static ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode temp = head;
        Map<Integer, ListNode> map = new HashMap<>();
        //把数据封装到一个map集合中
        int index = 1;
        while (temp != null) {
            map.put(index++, temp);
            temp = temp.next;
        }
        //对map集合中的数据进行处理，移除掉倒数第n个数据
        int size = map.size();

        //假设删除最后一个元素
        if (size == 1)
            return null;

        //根据不同的情况进行删除
        if (n == 1) {
            //假设删除的为最后一个元素，那么把最后一个元素的上一个元素的next设置为null
            map.get(size - 1).next = null;
        } else if (n == size) {//假设删除第一个元素
            head = head.next;
        } else {//假设删除中间的元素
            //找到要删除倒数第n个元素的上一个元素，让上一个元素的下一个元素为n的下一个元素
            map.get(size - n).next = map.get(size - n + 2);
        }
        return head;
    }
}

方式二，使用双指针思想

    //方式二，使用快慢指针
    public static ListNode removeNthFromEnd(ListNode head, int n) {
        //双指针思想
        //定义一个快指针，定义一个慢指针
        ListNode slow = head;
        ListNode fast = head;
        //先让快指针走n步
        while (n-- != 0){
            fast = fast.next;
        }
        //如果快指针走到了最后说明删除的是第一个节点
        if (fast == null){
            return head.next;
        }
        //使的slow每次都是在待删除的前一个节点，所以要先让fast先走一步
        fast = fast.next;
        while (fast != null){
            fast = fast.next;
            slow = slow.next;
        }
        //因为已经保证了是待删除节点的前一个节点，直接删除即可
        slow.next = slow.next.next;
        return head;
    }

方式三，破坏原有链表结构，构建新的链表

   //方式三,使用重新拼接一条链表的方式
    public static ListNode removeNthFromEnd(ListNode head, int n) {
        //创建一个新的链表头部
        ListNode newHead = new ListNode(0);
        ListNode cur = newHead;
        //把链表各个数据节点保存在map中
        int index = 1;
        Map<Integer,ListNode> map = new HashMap<>();

        for (ListNode temp = head; temp != null; temp = temp.next) {
            map.put(index++,temp);
        }

        //把原来的链表结构进行破坏
        for (ListNode listNode : map.values()){
            listNode.next = null;
        }
        //删除map中的倒数第n个元素
        map.remove(map.size() - n + 1);

        for (ListNode node : map.values()){
            cur.next = node;
            cur = cur.next;
        }
        return newHead.next;
    }