给定当前节点，如何在Singly Linked List中找到其上一个节点。谢谢逻辑可以，代码值得赞赏。我们都知道，给定一个根节点可以进行顺序遍历，我想知道是否有一种更智能的方法可以避免顺序访问开销。(假设无法访问根节点(谢谢。
你不能。
根据定义，单链表只将每个节点链接到其后续节点，而不是前一节点。没有关于前任的信息；甚至根本没有关于它是否存在的信息(您的节点可能是列表的头部(。
你可以使用双重链接列表。您可以尝试重新排列所有内容，以便首先将前置项作为参数传入。
您可以扫描整个堆，寻找一个类似于具有指向您的节点的指针的前置节点的记录。(这不是一个严肃的建议。(
如果你想删除当前节点，你可以在不找到上一个节点的情况下删除。
Python代码：
def-deleteNode(self，node(:
node.val = node.next.val
node.next = node.next.next
@删除链接列表中的节点
从头开始遍历列表，直到遇到next链接指向您当前节点的节点。
但如果你需要这样做，也许你一开始就不应该使用单链表。
对于单链表，您唯一的选择是线性搜索，如下所示(类似Python的伪代码(：
find_previous_node(list, node):
current_node = list.first
while(current_node.next != null):
if(current_node.next == node):
return current_node
else:
current_node = current_node.next
return null
假设您谈论的是一个前向单链列表(每个节点只有一个指向"next"等的指针(，则必须从列表的开头开始迭代，直到找到与当前节点具有"next"的节点。显然，这是一个缓慢的O(n)操作。
希望这能有所帮助。
保持两个指针(curr，prev(最初都将指向列表的头部。
在列表上循环，直到到达列表的末尾或所需的节点。
对于每个迭代，将curr节点移动到它的下一个，但在移动到下一个之前，将其指针存储在prev指针中。
prev = curr; // first store current node in prev
curr = curr->next // move current to next
在循环结束时，prev节点将包含上一个节点。
getPrev(head, key) {
Node* curr = head;
Node* prev = head;
while(curr !=null && curr->data==key){
prev = curr;
curr = curr->next
}
return prev
}
示例：
list=1->5->10->4->3
我们想要4的前一个节点，所以密钥=4，并且头点在1，这里是
最初：
- 温度将指向1
- prev将指向1
迭代1:
- 首先，指定prev=temp(prev点为1(
- 移动温度；temp->next(温度点为5(
迭代2:
- 首先，分配prev=temp(prev点为5(
- 移动温度；temp->next(温度点为10(
迭代3:
- 首先，指定prev=temp(prev点为10(
- 移动温度；temp->next(温度点为4(
迭代4:
- temp->data==键，因此它将从循环中返回
- 返回上一个节点
这是我在解决问题时发现的某种破解方法(删除列表中的每个偶数节点(
internal void DeleteNode(int p)
{
DeleteNode(head, p);
}
private void DeleteNode(Node head, int p)
{
Node current = head;
Node prev = null;
while (current.next != null)
{
prev = current;
current = current.next;
if (current.data == p)
{
prev.next = current.next;
}
}
}
现在，在prev中，您分配当前节点，然后将当前节点移动到下一个节点，从而prev包含上一个节点。希望这能帮助。。。
你可以这样做。。您可以将当前节点的值替换为下一个节点的值。。并且在倒数第二个节点的下一个节点中，您可以放置null。这就像从字符串中删除一个元素。这是代码
void deleteNode(ListNode* node) {
ListNode *pre=node;
while(node->next)
{
node->val=node->next->val;
pre=node;
node=node->next;
}
pre->next=NULL;
}
使用nodeAt((方法并传递当前节点的头、大小和索引。
public static Node nodeAt(Node head,int index){
Node n=head;
for(int i=0;i<index;i++,n=n.next)
;
return n;
}
其中n返回前置器的节点。
这里有一个线性搜索的小技巧：只需输入您正在搜索的上一个节点的节点或其位置：
private MyNode findNode(int pos) {
//node will have pos=pos-1
pos-- = 1;
MyNode prevNode = null;
int count = 0;
MyNode p = first.next; // first = head node, find it however you want.
//this is for circular linked list, you can use first!=last for singly linked list
while (p != first) {
if (count == pos) {
prevNode = p;
break;
}
p = p.next;
count++;
}
return prevNode;
}
我们可以使用慢速和快速指针遍历LinkedList。比方说
快速指针
fast = fast.next.next慢速指针
slow = slow.next
慢速指针将始终是快速指针的前一个，因此我们可以找到它。
如果只有给定的节点而不是根或头，则可以删除节点。怎样
它可以通过反转节点中的值来实现
4->2->1->9给定2作为要删除的节点。如上所述，其他节点无法访问前一个节点，这是正确的，因为单链表我们不存储前一个。可以做的是将给定节点下一个的值交换给给定节点，并将链接更改为给定节点下一个
nextNode = node.next // assigning given node next to new pointer
node.val = nextNode.val // replacing value of given node to nextNode value
node.next = nextNode.next // changing link of given node to next to next node.
我尝试过这种方法，效果很好。
我不知道这是否有帮助，但你可以对你的列表进行索引，每个下一个都是索引+1，每个上一个都为索引-1
假设你使用的是前向单链表，你的代码应该看起来像
while(node)
{
previous = node
node = node.next
// Do what ever you want to do with the nodes
}