given a node how can I find previous node in a singly linked list

问题

Given the current node, how can I find its previous node in a Singly Linked List. Thanks. Logic will do , code is appreciated. We all know given a root node one can do a sequential traverse , I want to know if there is a smarter way that avoids sequential access overhead. (assume there is no access to root node) Thanks.

回答1:

You can't.

Singly-linked lists by definition only link each node to its successor, not predecessor. There is no information about the predecessor; not even information about whether it exists at all (your node could be the head of the list).

You could use a doubly-linked list. You could try to rearrange everything so you have the predecessor passed in as a parameter in the first place.

You could scan the entire heap looking for a record that looks like a predecessor node with a pointer to your node. (Not a serious suggestion.)

回答2:

Walk through the list from the beginning until you meet a node whose next link points you your current node.

But if you need to do this, perhaps you oughtn't be using a singly linked list in the first place.

回答3:

Assuming that you're talking about a forward singly linked list (each node only has a pointer to 'next' etc) you will have to iterate from the start of the list until you find the node that has 'next' equal to your current node. Obviously, this is a slow O(n) operation.

Hope this helps.

回答4:

Your only option for a singly-linked list is a linear search, something like below (Python-like pseudo code):

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

回答5:

Use a nodeAt() method and pass the head,size and the index of the current node.

 public static Node nodeAt(Node head,int index){
    Node n=head;
    for(int i=0;i<index;i++,n=n.next)
      ;
    return n;
  }

where n returns the node of the predecessor.

回答6:

This is some kind of hack which I found out while solving the problem(Delete every even node in a list)

    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;
            }
        }
    }

Now here, in prev you assign the current and then move the current to next thereby prev contains the previous node. Hope this helps...

回答7:

Here is a small trick with linear search: just pass in the node or its position whose previous node you are searching for:

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;
    }

回答8:

Keep two-pointer(curr, prev) initially both will point to head of the list.

do a loop on the list until you either reach at the end of the list or at the required node.

for each iteration move curr node to the next of it but before moving to next store its pointer in prev pointer.

    prev = curr; // first store current node in prev
    curr = curr->next // move current to next

at the end of loop prev node will contain previous node.

getPrev(head, key) {    
    Node* curr = head;
    Node* prev = head;
    while(curr !=null && curr->data==key){
        prev = curr;
        curr = curr->next
    }
    return prev
}

Example:

list = 1->5->10->4->3

We want prev node of 4 So key = 4 and head point at 1 here

initially:

temp will point to 1
prev will point to 1

iteration 1:

First, assign prev=temp (prev point to 1)
move temp; temp->next (temp point to 5)

iteration 2:

First, assign prev=temp (prev point to 5)
move temp; temp->next (temp point to 10)

iteration 3:

First, assign prev=temp (prev point to 10)
move temp; temp->next (temp point to 4)

iteration 4:

temp->data == key so it will return out of loop.
return prev node

回答9:

We can traverse through the LinkedList using slow and fast pointers. Let's say

fast pointer fast = fast.next.next

slow pointer slow = slow.next

Slow pointer will be always a previous of the fast pointer, and so we can able to find it.

回答10:

assuming you are using forward singly linked list your code should look like

while(node)
{
      previous = node
      node = node.next
      // Do what ever you want to do with the nodes
}

来源：https://stackoverflow.com/questions/7198508/given-a-node-how-can-i-find-previous-node-in-a-singly-linked-list

标签

java

list

data-structures

linked-list