反向链表-Javascript-使用类还是只定义一个函数？以及如何计算时间/空间复杂性

我知道有一些使用javascript的反向链接列表问题，但我希望其他人提供的解决方案更加清晰

是否需要使用

类LinkedList

来声明LinkedList，还是像下面的示例那样进行

我只是不清楚这个函数是如何声明一个名为

reverseLinkedList

的变量并解决它，而不是实际使用这个类

不确定这是否有任何意义，但除此之外，这个解决方案是否足够清晰，可以解决反转链表的问题

另外，对于时间复杂度，这会被认为是O（n）吗？因为它有一个while循环，该循环设置为有限的运行时间。我不确定空间的复杂性

// reverse a linked list
const reverseLinkedList = (linkedlist) => {
  let node = linkedlist;
  let previous = null;

  while(node) {
// save next or you lose it!!!
  let save = node.next;
// reverse pointer
  node.next = previous;
// increment previous to current node
  previous = node;
// increment node to next node or null at end of list
  node = save;
}
  return previous;   // Change the list head !!!
}
linkedlist = reverseLinkedList(linkedlist);

---

这里发生了几件事

首先此声明

let reverseLinkedList=函数（linkedlist）{

与此声明类似

函数反转linkedList（linkedList）{

除了在第一个示例中声明之前不能调用

reverseLinkList

。您可以在这里阅读更多关于提升的信息

其次使用一个类或函数其实没什么大不了的。你会发现Javascript中的类实际上只是语法上的糖分（但这里有一些你可以读到的技巧）

最后此函数的时间复杂度为O（n），因为它只在列表中循环一次

---

希望这能有所帮助！

这里有几件事要做

首先此声明

let reverseLinkedList=函数（linkedlist）{

与此声明类似

函数反转linkedList（linkedList）{

除了在第一个示例中声明之前不能调用

reverseLinkList

。您可以在这里阅读更多关于提升的信息

其次使用一个类或函数其实没什么大不了的。你会发现Javascript中的类实际上只是语法上的糖分（但这里有一些你可以读到的技巧）

最后此函数的时间复杂度为O（n），因为它只在列表中循环一次

---

希望这会有帮助！

任何一种方法都可以。创建类

链接列表将允许您向其中添加方法，但对于解决单个反向链接列表问题来说，这都是一种过分的做法

链表只是节点的集合，其中每个节点都使用
next
对象属性引用下一个节点

如果您想向LinkedList添加一系列方便的方法，那么是的，一个类会很有用。但是对于列表反转这样的单个问题，您发布的解决方案假设函数将列表中的第一个节点作为输入，并且每个节点（仅一个JavaScript对象）都有一个
next
属性

例如，假设我正在解决多个链表问题，并且我还需要从一个值数组中创建一个链表。假设我还想轻松测试一个函数（如ReverseLinedList）是否返回正确的列表。我可以使用

然后，测试上述解决方案将非常简单：

首先，重写反向解决方案，使其采用linkedList而不仅仅是head&这样，在列表被反向后，您可以修改列表的
head
属性：

const reverseLinkedList = (linkedlist) => {
  let node = linkedlist.head;
  let previous = null;

  while(node) {
// save next or you lose it!!!
  let save = node.next;
// reverse pointer
  node.next = previous;
// increment previous to current node
  previous = node;
// increment node to next node or null at end of list
  node = save;
}
  linkedlist.head = previous
  return previous;   // Change the list head !!!
}


然后可以运行此测试：

var inputList = new LinkedList([1,2,3,4])
var expectedReversedList = new LinkedList([4,3,2,1])
var actualReversedList = reverseLinkedList(inputList)
console.log(inputList.isEqualTo(actualReversedList))

此外，就空间和时间复杂性而言，由于上述解决方案对对象进行了变异，因此它是O（1）空间，并且由于它只在节点上迭代一次，因此它是O（N）时间复杂度
任何一种方法都可以。创建类
链接列表
将允许您向其中添加方法，但对于解决单个反向链接列表问题来说，这是一种过度的操作

链表只是节点的集合，其中每个节点都使用
next
对象属性引用下一个节点

如果您想向LinkedList添加一系列方便的方法，那么是的，一个类会很有用。但是对于列表反转这样的单个问题，您发布的解决方案假设函数将列表中的第一个节点作为输入，并且每个节点（仅一个JavaScript对象）都有一个
next
属性

例如，假设我正在解决多个链表问题，并且我还需要从一个值数组中创建一个链表。假设我还想轻松测试一个函数（如ReverseLinedList）是否返回正确的列表。我可以使用

然后，测试上述解决方案将非常简单：

首先，重写反向解决方案，使其采用linkedList而不仅仅是head&这样，在列表被反向后，您可以修改列表的
head
属性：

const reverseLinkedList = (linkedlist) => {
  let node = linkedlist.head;
  let previous = null;

  while(node) {
// save next or you lose it!!!
  let save = node.next;
// reverse pointer
  node.next = previous;
// increment previous to current node
  previous = node;
// increment node to next node or null at end of list
  node = save;
}
  linkedlist.head = previous
  return previous;   // Change the list head !!!
}


然后可以运行此测试：

var inputList = new LinkedList([1,2,3,4])
var expectedReversedList = new LinkedList([4,3,2,1])
var actualReversedList = reverseLinkedList(inputList)
console.log(inputList.isEqualTo(actualReversedList))

此外，就空间和时间复杂性而言，由于上述解决方案对对象进行了变异，因此它是O（1）空间，并且由于它只在节点上迭代一次，因此它是O（N）时间复杂性
感谢您的澄清，我修改了ES6格式的函数，语法是否有问题？当您提到函数的复杂性时，是O（n），你指的是时间复杂度，对吗？空间复杂度呢？@mph85，只要你在函数声明之前不调用它就可以了。对，这就是时间复杂度，额外的空间复杂度是O（1），因为你只使用了3个额外的临时变量。O（3）是O（1）因此，为了澄清，
let node
let previous
和
let save
是3个临时变量，因此只有在所有因素都被分解后，才使用O（1）？感谢澄清，我修改了ES6格式的函数，会有问题吗