动态算法（基础七）笔记回顾

1、删除链表中的节点

示例 1：

输入：head = [4,5,1,9], node = 5
输出：[4,1,9]
解释：指定链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9
示例 2：

输入：head = [4,5,1,9], node = 1
输出：[4,5,9]
解释：指定链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9

function ListNode(val) {
     this.val = val;
     this.next = null;
 }
/**
 * @param {ListNode} node
 * @return {void} Do not return anything, modify node in-place instead.
 */

var deleteNode = function(node) {                     //node为第几个（举个例子是第四个）
    node.val = node.next.val;                         //直接将下一个结点的值进行覆盖（用第五个的值覆盖第四个）
    node.next = node.next.next;                       //原本node.next指向第三个，node.next.next是第五个指向第四个，现在直接让第五个指向第三个。
};

2、删除链表的倒数第N个节点

示例 1：

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]
示例 2：

输入：head = [1], n = 1
输出：[]
示例 3：

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

function ListNode(val, next) {
     this.val = (val===undefined ? 0 : val)
     this.next = (next===undefined ? null : next)
 }
/*
 * @param {ListNode} head
 * @param {number} n
 * @return {ListNode}
 */
var removeNthFromEnd = function(head, n) {
     let slow = head, fast = head;                         //定义一个fast和slow指针指向第一个
                                                           // 先让 fast 往后移 n 位
     while(n--) {
         fast = fast.next;
     }

                                                           // 如果 n 和 链表中总结点个数相同，即要删除的是链表头结点时，fast 经过上一步已经到外面了
     if(!fast) {
         return head.next;
     }

                                                           // 然后 快慢指针 一起往后遍历，当 fast 是链表最后一个结点时，此时 slow 下一个就是要删除的结点
     while(fast.next) {
         slow = slow.next;                                 //slow向后移动
         fast = fast.next;                                 //fast向后移动
     }
     slow.next = slow.next.next;                           //目前fast已经指向了null，而slow也指向了要删除的那个结点，（假设slow是第四个，slow.next = slow.next.next也是让第五个直接指向第三个）
     return head                                           //把链表输出
};

3、反转链表

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]
示例 2：

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

输入：head = []
输出：[]

借用大佬的演示图，更加清晰（推荐观看）

 

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var reverseList = function(head) {
    if(!head || !head.next) return head;      // 如果链表为空或者只有一个节点，直接返回head
    let index=head,temp=null,point=null;      //定义temp用来存放下一个结点的值，定义point来搞定上一个结点，index指向初始链表的第一个
    while(index){                             //当初始链表的下一个为null时结束循环，也就是遍历完成
        temp=index.next;                      //用temp存放下一个结点的信息
        index.next=point;                     //使得当前结点指向point，也就是往前指
        point=index;                          //把point指针指向下一个
        index=temp;                           //把index指针指向下一个
    } 
    return point;                             //遍历完成返回point，输出链表
};