Question

这是我的链表构造函数和插入函数：

template <class T>
   List<T>::List() {
   _first = nullptr;
}

template <class T>
bool List<T>::insert(const T& item, const int& position) {
Node* ptr = new Node();

// sets node data members
ptr->data = item;
ptr->next = nullptr;

if (position == 1) {
    ptr->next = _first;
    _first = ptr;
    return true;
}

// iterates through list until reached position passed into function
Node* predptr = _first;
for (int i = 0; i < position - 2; i++) {
    predptr = predptr->next;
}

// repoints pointer of previous node to it and its pointer to what previous pointer was pointing too
ptr->next = predptr->next;
predptr->next = ptr;
return true;
}

我之前尝试过这个但是搞砸了我的整个程序并迷失了所以我只是回到了我的工作起点。

在我的笔记中，它说要遍历列表，请执行以下操作：

(_first != 0) {
   ptr = first;
   do 
   {   // process ptr->data
       ptr = ptr->next; }
       while (ptr != _first);
}

但是当我尝试更改代码来添加它时，它只是搞砸了一切。如果我能指出正确的方向，我会很感激，谢谢！

Answer 1

我没有你的代码所以它没有经过测试。但我认为这会奏效。首先要明确的是，我使用从零开始的索引。

第一部分：

Tipp 您可以将位置作为副本传递，因为对int的引用与int本身的大小相同。对于较大的物体虽然有意义。

我添加了一个成员size函数，用于计算元素的数量。这两个断言确保您不传递大于列表中元素数量的position。第二个保证特殊情况是正确的，因为它测试_first == nullptr然后position必须为零，因为之前没有添加其他元素。

  // create the node
  Node* ptr = new Node();

  // just to make sure position is not out of bounds
  assert(position <= size);
  size++;

  // sets node data members
  ptr->data = item;

  // special case, list is empty
  if (_first == nullptr)
  {
    // position must be 0 if you insert for the first time
    assert(position == 0);

    ptr->next = ptr;
    _first = ptr;
    return true;
  }

好的第二部分：

当您已插入一个元素时，您可以遍历所有元素。我使用了一个指向_first的特殊节点，并在位置-1处开始循环，这应该确保您获得前一个元素来相应地重新分配指针。

  // create special-node pointing to first node
  Node* predptr = new Node();
  predptr->next = _first;
  for (int i = -1; i < position; ++i)
  {
    if (i == position - 1)
    {
      ptr->next = predptr->next;
      predptr->next = ptr;
    }
    predptr->next = predptr;
  }
  return true;

我希望这适合你。

如何将链表转换为循环链表？

1 个答案: