将节点移动到单链表的开头

Question

In Pascal, when I have a singly linked list with nodes defined like this,

pNode = ^Node;
Node = record
    data : data;
    next : pNode;
end;

and when I iterate through the list like this

while y<>z do begin
        if y^.data < x^.data then begin
          { HERE I WOULD LIKE TO MOVE y IN FRONT OF X }
        end;
        y:=y^.next;
end;

where x is the pivot (beginning of the list), y is the 'index', z is the tail (the end) of the list (yes, I am trying to perform a quicksort on a singly linked list). How would I accomplish the task in the comment?

I made the procedure insertAfter :

procedure List.insertAfter(n : pNode; var what : data);
var newn : pNode;
begin
  new(newn);
  newn^.data := what;
  newn^.next := n^.next;
  n^.next := newn;
end;

and insertInstead

procedure List.insertInstead(n : pNode; var what : data);
begin
    List.insterAfter(n, n^.data);
    n^.data:=what;
end;

and similarly deleteAfter(n : pNode)

procedure List.deleteAfter(n : pNode);
var q : pNode;
begin
    q := n^.next;
    n^.next := n^.next^.next;
    dispose(q);
end;

and delete(n : pNode)

procedure List.delete(n : pNode);
begin
    if n^.next <> tail then begin
        n^.data := n^.next^.data;
        deleteAfter(n);
    end
    else begin
        dispose(tail);
        tail:=n;
        tail^.next := nil;
    end;
end;

Now when I put in the iteration, instead of the comment

list.insertInstead(x,y^.data);
list.delete(y);

, it doesn't work, presumably because y^.next now doesn't point to the same node as before the move.

So the question is: how do I move the node to the beginning with y^.next still pointing to the same node?

PS.: I have tried the obvious: using and auxiliary variable to store the actual value of y before the move, but it seems to change along with y.

Here is the original code: Stack , List , Quicksort .

Answer 1

Maybe the easiest way is only to change (swap) the values of the nodes.

{ HERE I WOULD LIKE TO MOVE y IN FRONT OF X }
tmp := x^.data
x^.data := y^.data
y^data := tmp

UPDATE: Here is the similar answer: https://stackoverflow.com/a/1536046/2490538

Zdravím.

Answer 2

I think I might see the problem. The first line of your insert code

 list.insertInstead(x,y^.data);

works fine. It puts a new node immediately after x and populates it with y's data (so you effectively now have a copy of node y after node x.

But I don't think the second line

 list.delete(y);

does what you want it to. It does 'remove' the node y from the list (as you want), but does so by moving data from the node following y into y's location, and deleting that node. So now y.next points at the node following the node following the original y. Maybe a diagram would help.

Before list.delete(y)

 node:     ... - y - a - b - c - ... - z
 data:     ... - Y - A - B - C - ... - Z
                     ^ 
                     y.next points here (data is A)

After list.delete(y)

 node:     ... - y - b - c - ... - z
 data:     ... - A - B - C - ... - Z
                     ^ 
                     y.next points here (data is B)
                 ^
                 y points here (data is A)

so if you 'increment y as in your line

 y:=y^.next;

in your iteration loop you will miss out on testing data A. You can fix that by removing the y:=y^.next; line. But then there will still be a problem with your while loop in the line

 while y<>z do begin

Because the pointer to node y doesn't change anymore (as you have removed y := y^.next), y will never equal z. The simplest (but possibly not the most elegant) way to fix this might be to replace the line with

 while y^.next <>z do begin

and add a final case to test the last node.

The main loop would then look like something like (without testing):

 while y^.next <> z do begin
         if y^.data < x^.data then begin
                 list.insertInstead(x,y^.data);
                 list.delete(y);
         end;
 end;
 if y^.data < x^.data then begin
         list.insertInstead(x,y^.data);
         list.delete(y);
 end;

or, by defining a new procedure

 procedure list.moveiflessthan(x,y : pnode);
 begin
      if y^.data < x^.data then begin
              list.insertInstead(x,y^.data);
              list.delete(y);
      end;
 end;

you get

 while y^.next <> z do
         if y^.data < x^.data then 
                 list.moveiflessthan(x,y);
 if y^.data < x^.data then
         list.moveiflessthan(x,y);

There may still be an end-case error if you reach the end of the list (I haven't checked) but I am sure you can work that out...