js怎么写链表题目

链表（Linked List）是一种数据结构，它通过节点（Node）来存储数据，每个节点包含两个部分：一个是存储数据的部分，另一个是指向下一个节点的指针。链表在很多算法和数据结构题目中都有广泛的应用。下面将详细介绍如何使用JavaScript编写链表以及解决一些常见的链表题目。

一、链表的基本结构

链表通常分为单链表、双向链表和循环链表。最基本的是单链表。下面是一个单链表的基本结构：

class Node {
    constructor(value) {
        this.value = value;
        this.next = null;
    }
}
class LinkedList {
    constructor() {
        this.head = null;
    }
    // 添加节点到链表的末尾
    append(value) {
        let newNode = new Node(value);
        if (this.head === null) {
            this.head = newNode;
        } else {
            let current = this.head;
            while (current.next !== null) {
                current = current.next;
            }
            current.next = newNode;
        }
    }
    // 打印链表
    print() {
        let current = this.head;
        let result = [];
        while (current !== null) {
            result.push(current.value);
            current = current.next;
        }
        console.log(result.join(" -> "));
    }
}

二、常见链表题目及解决方案

1、反转链表

反转链表是链表题目中最经典的一道题，要求将链表的节点顺序反转。

function reverseLinkedList(head) {
    let prev = null;
    let current = head;
    while (current !== null) {
        let nextNode = current.next;
        current.next = prev;
        prev = current;
        current = nextNode;
    }
    return prev;
}

详细描述：反转链表的核心思想是使用三个指针：prev、current和nextNode。prev用于存储当前节点的前一个节点，current用于存储当前节点，nextNode用于存储当前节点的下一个节点。通过不断调整current的next指针指向prev，逐步反转整个链表。

2、检测链表中的环

检测链表中是否存在环也是常见的题目，可以使用快慢指针（Floyd’s Cycle-Finding Algorithm）来解决。

function hasCycle(head) {
    if (head === null || head.next === null) {
        return false;
    }
    let slow = head;
    let fast = head.next;
    while (fast !== null && fast.next !== null) {
        if (slow === fast) {
            return true;
        }
        slow = slow.next;
        fast = fast.next.next;
    }
    return false;
}

详细描述：使用快慢指针，慢指针每次移动一步，快指针每次移动两步。如果链表中存在环，快慢指针最终会相遇；否则，快指针会到达链表的末尾。

3、合并两个有序链表

合并两个有序链表也是常见的链表题目，要求将两个有序链表合并成一个新的有序链表。

function mergeTwoLists(l1, l2) {
    let dummy = new Node(0);
    let current = dummy;
    while (l1 !== null && l2 !== null) {
        if (l1.value < l2.value) {
            current.next = l1;
            l1 = l1.next;
        } else {
            current.next = l2;
            l2 = l2.next;
        }
        current = current.next;
    }
    if (l1 !== null) {
        current.next = l1;
    }
    if (l2 !== null) {
        current.next = l2;
    }
    return dummy.next;
}

详细描述：使用一个虚拟节点dummy作为新链表的头节点，current指针用于构建新的链表。在比较两个链表的节点值时，将较小的节点连接到current，并移动指针，直到一个链表到达末尾。最后，将剩余的节点连接到新的链表。

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

删除链表的倒数第N个节点可以使用双指针方法来解决。

function removeNthFromEnd(head, n) {
    let dummy = new Node(0);
    dummy.next = head;
    let first = dummy;
    let second = dummy;
    for (let i = 0; i <= n; i++) {
        first = first.next;
    }
    while (first !== null) {
        first = first.next;
        second = second.next;
    }
    second.next = second.next.next;
    return dummy.next;
}

详细描述：使用双指针first和second，first指针先移动N步，然后first和second指针同时移动，直到first指针到达链表末尾。此时，second指针指向待删除节点的前一个节点，通过调整second的next指针实现删除操作。

三、链表相关的高级题目

1、链表排序

对链表进行排序是一个高级题目，可以使用归并排序（Merge Sort）来实现。

function sortList(head) {
    if (head === null || head.next === null) {
        return head;
    }
    let mid = getMiddle(head);
    let left = head;
    let right = mid.next;
    mid.next = null;
    return merge(sortList(left), sortList(right));
}
function getMiddle(head) {
    let slow = head;
    let fast = head.next;
    while (fast !== null && fast.next !== null) {
        slow = slow.next;
        fast = fast.next.next;
    }
    return slow;
}
function merge(l1, l2) {
    let dummy = new Node(0);
    let current = dummy;
    while (l1 !== null && l2 !== null) {
        if (l1.value < l2.value) {
            current.next = l1;
            l1 = l1.next;
        } else {
            current.next = l2;
            l2 = l2.next;
        }
        current = current.next;
    }
    if (l1 !== null) {
        current.next = l1;
    }
    if (l2 !== null) {
        current.next = l2;
    }
    return dummy.next;
}

详细描述：使用归并排序将链表拆分为两个子链表，递归排序每个子链表，然后合并两个有序子链表。getMiddle函数用于找到链表的中间节点，merge函数用于合并两个有序链表。

2、链表相交

判断两个链表是否相交，并找出相交的起始节点。

function getIntersectionNode(headA, headB) {
    if (headA === null || headB === null) {
        return null;
    }
    let a = headA;
    let b = headB;
    while (a !== b) {
        a = (a === null) ? headB : a.next;
        b = (b === null) ? headA : b.next;
    }
    return a;
}

详细描述：使用两个指针a和b遍历两个链表，当一个指针到达链表末尾时，切换到另一个链表的头部继续遍历。如果两个链表相交，指针最终会在交点相遇；否则，两指针会同时到达链表末尾的null。

四、总结

链表是基础的数据结构之一，掌握链表的基本操作和常见题目的解决方法是非常重要的。通过本文的介绍，希望你能够理解和应用JavaScript来解决各种链表题目。对于团队协作和项目管理，推荐使用研发项目管理系统PingCode和通用项目协作软件Worktile来提高效率和协作效果。

参考资料

通过不断练习和深入理解链表的操作，相信你能够在面试和实际项目中游刃有余地处理各种链表相关的问题。