当前位置：首页 > news >正文

链表题型-链表操作-JS

news 来源：原创 2025/5/1 14:04:42

一定要注意链表现在的头节点是空节点还是有值的节点。

一、移除链表中的元素

有两种方式，直接使用原来的链表进行删除操作；设置一个虚拟头节点进行删除操作。

直接使用原来的链表进行删除操作时，需要考虑是不是头节点，因为移除头节点和移除其他节点的操作是不一样的。链表的其他节点都是通过前⼀个节点来移除当前节点，⽽头结点没有前⼀个节点。而头结点向后移动⼀位就可以，这样就从链表中移除了⼀个头结点。

而设置虚拟头节点就没有这个问题了，因为虚拟头节点代替了原本头节点的位置，那么所有的节点就可以按照统一的方式进行移除了。

return 头结点的时候，别忘了 return dummyNode->next; ，这才是真正的头结点

JS中新建节点：


    let dummyNode = new ListNode(0);

203.移除链表元素

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

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

列表中的节点数目在范围 [0, 104] 内
1 <= Node.val <= 50
0 <= val <= 50

不采用虚拟头节点

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @param {number} val
 * @return {ListNode}
 */
var removeElements = function(head, val) {
    // 删除头节点，注意这里是循环，不是if
    while(head!==null && head.val===val){
        head=head.next
    }

    // 删除非头节点
    let cur=head
    while(cur!==null&&cur.next!==null){
        if(cur.next.val===val){
            cur.next=cur.next.next
        }else{
            cur=cur.next
        }
    }
    return 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
 * @param {number} val
 * @return {ListNode}
 */
var removeElements = function(head, val) {
    let dummyNode = new ListNode(0);
    dummyNode.next=head;
    let cur=dummyNode;

    while (cur.next !== null) {
    if (cur.next.val === val) {
        cur.next = cur.next.next; // 删除节点
    } else {
        cur = cur.next; // 移动指针
    }
}

    head=dummyNode.next
    return head
};

二、设计链表

在链表类中实现这些功能：

get(index) ：获取链表中第 index 个节点的值。如果索引⽆效，则返回 -1 。

addAtHead(val) ：在链表的第⼀个元素之前添加⼀个值为 val 的节点。插⼊后，新节点将成为链表的第⼀个节点。

addAtTail(val) ：将值为 val 的节点追加到链表的最后⼀个元素。

addAtIndex(index,val) ：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的⻓度，则该节点将附加到链表的末尾。如果 index ⼤于链表⻓度，则不会插⼊节点。如果 index ⼩于 0 ，则在头部插⼊节点。

deleteAtIndex(index) ：如果索引 index 有效，则删除链表中的第 index 个节点。

链表操作的两种⽅式：

1. 直接使⽤原来的链表来进⾏操作。

2. 设置⼀个虚拟头结点在进⾏操作。

707.设计链表

你可以选择使用单链表或者双链表，设计并实现自己的链表。

单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。

如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。

实现 MyLinkedList 类：

MyLinkedList() 初始化 MyLinkedList 对象。
int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。

示例：
输入
["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
[[], [1], [3], [1, 2], [1], [1], [1]]
输出
[null, null, null, null, 2, null, 3]

解释
MyLinkedList myLinkedList = new MyLinkedList();
myLinkedList.addAtHead(1);
myLinkedList.addAtTail(3);
myLinkedList.addAtIndex(1, 2);    // 链表变为 1->2->3
myLinkedList.get(1);              // 返回 2
myLinkedList.deleteAtIndex(1);    // 现在，链表变为 1->3
myLinkedList.get(1);              // 返回 3
提示：

0 <= index, val <= 1000
请不要使用内置的 LinkedList 库。
调用 get、addAtHead、addAtTail、addAtIndex 和 deleteAtIndex 的次数不超过 2000 。

下标 0 代表的是第一个数据节点（this.head.next）。
虚拟头节点 只是一个占位符，它本身并不算作链表的第一个有效节点。

function ListNode(val) {
    this.val = val;  // 节点的值
    this.next = null;  // 下一个节点的指针，默认为 null
}

var MyLinkedList = function() {
    this.head = new ListNode(0); // 创建一个虚拟头节点
    this.size = 0;               // 链表的大小
};

/** 
 * @param {number} index
 * @return {number}
 */
MyLinkedList.prototype.get = function(index) {
    if (index < 0 || index >= this.size) {
        return -1; // 如果 index 无效，返回 -1
    }

    let cur = this.head.next; // 从虚拟头节点后的第一个节点开始遍历
    for (let i = 0; i < index; i++) {
        cur = cur.next; // 移动到下一个节点
    }

    return cur.val; // 返回当前节点的值
};

/** 
 * @param {number} val
 * @return {void}
 */
MyLinkedList.prototype.addAtHead = function(val) {
    let newNode = new ListNode(val);    
    newNode.next = this.head.next; // 新节点指向原来头节点的下一个节点
    // 原来的节点变成第一个有效节点
    this.head.next=newNode
    this.size++;
};

/** 
 * @param {number} val
 * @return {void}
 */
MyLinkedList.prototype.addAtTail = function(val) {
    let cur = this.head; // 从虚拟头节点开始遍历
    while (cur.next) {
        cur = cur.next; // 遍历到最后一个节点
    }
    let newNode = new ListNode(val);
    cur.next = newNode; // 将新节点添加到链表末尾
    this.size++;
};

/** 
 * @param {number} index 
 * @param {number} val
 * @return {void}
 */
MyLinkedList.prototype.addAtIndex = function(index, val) {
    if (index > this.size) {
        return; // 如果 index 大于链表长度，直接返回
    }

    let cur = this.head; // 从虚拟头节点开始
    for (let i = 0; i < index; i++) {
        cur = cur.next; // 遍历到插入位置的前一个节点
    }

    let newNode = new ListNode(val);
    newNode.next = cur.next; // 新节点的 next 指向原来该位置的节点
    cur.next = newNode; // 前一个节点的 next 指向新节点
    this.size++;
};

/** 
 * @param {number} index
 * @return {void}
 */
MyLinkedList.prototype.deleteAtIndex = function(index) {
    if (index < 0 || index >= this.size) {
        return; // 如果 index 无效，直接返回
    }

    let cur = this.head; // 从虚拟头节点开始
    for (let i = 0; i < index; i++) {
        cur = cur.next; // 遍历到删除位置的前一个节点
    }

    cur.next = cur.next.next; // 删除该节点
    this.size--;
};