javascript链表 listnode

JavaScript 链表 Listnode 是一种数据结构，用于在 JavaScript 中存储和操作链表。每个 Listnode 都有一个指向下一个节点的指针，可以通过这些指针遍历链表。链表 Listnode 在某些情况下比数组更优，因为它们允许动态添加和删除元素，而不必重新分配内存。

相关问题

用js代码实现链表反转

好的，我知道了。以下是使用 JavaScript 语言实现链表反转的示例代码：

// 定义链表节点类
class ListNode {
  constructor(val, next = null) {
    this.val = val;
    this.next = next;
  }
}

// 定义链表类
class LinkedList {
  constructor() {
    this.head = null;
  }

  // 添加新节点
  add(val) {
    const node = new ListNode(val);
    node.next = this.head;
    this.head = node;
  }

  // 反转链表
  reverse() {
    let prev = null;
    let curr = this.head;
    while (curr !== null) {
      const next = curr.next;
      curr.next = prev;
      prev = curr;
      curr = next;
    }
    this.head = prev;
  }

  // 输出链表
  toString() {
    let curr = this.head;
    let str = '';
    while (curr !== null) {
      str += `${curr.val} -> `;
      curr = curr.next;
    }
    str += 'null';
    console.log(str);
  }
}

// 测试代码
const list = new LinkedList();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
console.log('原始链表：');
list.toString(); // 4 -> 3 -> 2 -> 1 -> null
list.reverse();
console.log('反转后的链表：');
list.toString(); // 1 -> 2 -> 3 -> 4 -> null

你可以在浏览器的控制台或 Node.js 环境中执行该代码并查看结果。希望这个例子对你有所帮助！

js 合并K个升序链表

可以使用归并排序的思想来解决这个问题：

1. 将 K 个链表两两合并，得到 K/2 个链表；
2. 将上一步得到的 K/2 个链表再两两合并，得到 K/4 个链表；
3. 重复上述步骤，直到只剩下一个链表。

以下是 JavaScript 代码实现：

function mergeKLists(lists) {
  if (lists.length === 0) {
    return null;
  }
  while (lists.length > 1) {
    let mergedLists = [];
    for (let i = 0; i < lists.length; i += 2) {
      let l1 = lists[i];
      let l2 = (i + 1 < lists.length) ? lists[i + 1] : null;
      mergedLists.push(mergeTwoLists(l1, l2));
    }
    lists = mergedLists;
  }
  return lists[0];
}

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

其中 `ListNode` 表示链表节点的类，`val` 表示节点的值，`next` 表示指向下一个节点的指针。