【近日力扣】（链表合集1）移除链表元素+反转链表+链表的中间结点+删除排序链表中的重复元素

链表专题

给出链表定义
/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */

移除链表元素

• 思路一：遍历链表，找到对应的节点删除，但是要注意头结点的判断，可以再创一个空链表，其下一节点指向目标链表的头，或者对头结点做一个判断

var removeElements = function(head, val) {
    let copy = new ListNode(0)
    copy.next = head
    temp = copy
    while (temp.next !== null) {
        if (temp.next.val === val) {
            temp.next = temp.next.next
        } else {
            temp = temp.next
        }
    }
    return copy.next
};

• 思路二：递归。需要捋清思路先，要确保返回的是总链表。

var removeElements = function(head, val) {
    if (head === null) return head
    // 如此赋值，可以使得整个链表被返回
    head.next = removeElements(head.next, val)
    // 返回前判断头结点是否才是要删除的节点
    return head.val === val ? head.next : head
};

反转链表

• 思路：遍历目标链表，同时将当前元素插入一个新的链表结构，自然就反序了

var reverseList = function(head) {
    let prev = null
    let list = head
    while (list) {
        const next = list.next
        list.next = prev
        prev = list
        list = next
    }
    return prev
};

链表的中间结点

• 思路一：单指针。遍历一遍，记录链表长度，再次遍历到长度为一半时则为中间节点

var middleNode = function(head) {
    let len = 0
    let copy = head
    while (copy !== null) {
        copy = copy.next
        len++
    }
    len = Math.floor(len / 2)
    while (len) {
        head = head.next
        len--
    }
    return head
};

• 思路二：双指针。快指针一次跳过一个节点遍历，慢指针一个个节点遍历，意味着快指针比慢指针快两倍，当快指针到达尾部时慢指针则到达中间节点

var middleNode = function(head) {
    let slow = head, fast = head
    while (fast !== null && fast.next !== null) {
        slow = slow.next
        fast = fast.next.next
    }
    return slow
};

删除排序链表中的重复元素

• 思路：排序好的，那就大大简化了难度，只要遍历一遍，判断当前节点与下一节点是否相等即可

var deleteDuplicates = function(head) {
    if (!head) return head
    let cur = head
    while (cur.next) {
        cur.val === cur.next.val ? cur.next = cur.next.next : cur = cur.next
    }
    return head
};

如果觉得对你有帮助的话，点个赞呗~

反正发文又不赚钱，交个朋友呗~

如需转载，请注明出处foolBirdd