C ++：链接列表中节点的交换错误

Question

I have 2 simple structures:

struct Address
{
    char city[255];
};
typedef Address* AddressPtr;

struct Person
{
    char fullName[255];
    Address* address;
    Person* next;
};
typedef Person* PersonPtr;

The Person structure forms the Linked list where new elements are added to the beginning of the list. What I want to do is to sort them by fullName . At first I tried to swap links, but I lost the beginning of the list and as a result my list was sorted partially. Then I decided to sort list by swapping the values of nodes. But I get strange results. For a list with names: Test3, Test2, Test1 , I get Test3, Test3, Test3 .

Here is my sorting code:

void sortByName(PersonPtr& head)
{
    TaskPtr currentNode, nextNode;
    for(currentNode = head; currentNode->next != NULL; currentNode = currentNode->next)
    {
        for(nextNode = currentNode->next; nextNode != NULL; nextNode = nextNode->next)
        {
            if(strcmp(currentNode->fullName, nextNode->fullName) > 0)
            {
                swapNodes(currentNode, nextNode);
            }
        }

    }
}

void swapNodes(PersonPtr& node1, PersonPtr& node2)
{
    PersonPtr temp_node = node2;
    strcpy(node2->fullName, node1->fullName);
    strcpy(node1->fullName, temp_node->fullName);

    strcpy(node2->address->city, node1->address->city);
    strcpy(node1->address->city, temp_node->address->city);
}

After the sorting completion, nodes values are a little bit strange.

UPDATED

This is how I swapped links:

void swapNodes(PersonPtr& node1, PersonPtr& node2)
{
    PersonPtr temp_person;
    AddressPtr temp_address;

    temp_person = node2;
    node2 = node1;
    node1 = temp_person;

    temp_address = node2->address;
    node2->address = node1->address;
    node1->address = temp_address;
}

Answer 1

In order to swap nodes in a singly-linked list, you need more than just the two nodes you're swapping. There are at least three pointers to modify.

+--------+ next +---------+ next +---------+ next +---------+
| before |----->|  node1  |----->|  node2  |----->|  after  |
+--------+      +---------+      +---------+      +---------+

To swap node1 and node2 , you need to swap node1->next and node2->next , and then point before->next at node2 . Of course, in order to modify before->next , you need to know before . (And if the nodes aren't adjacent, you'd have to update node2 's parent as well.)

Now, if you're just swapping the data rather than the pointers, you'd be OK with just the two nodes you're swapping. But you're doing two things horribly wrong, if that's the goal.

1. temp_node == node2 . That means they're both pointing at the same object . So when you copy data from *node1 into *node2 , you're modifying the same object temp_node points to. Then when you copy from *temp_node into *node1 , you're actually copying that data you've just overwritten. End result: all nodes' address objects contain the same bits.

   You need temp_node to point to an independent object, or simply let it be a node object rather than a pointer, or copy the data into a buffer or something.

2. Swapping the pointers and swapping the data are mutually exclusive if you want to get something done. Here, you swap the node pointers, and then you swap data pointers...? Kinda defeats the purpose, doesn't it?

   Watch:

     // node1 node2 // +----------+ next +----------+ // | node |----->| node | // +----------+ +----------+ // | address | address // vv // +----------+ +----------+ // | address1 | | address2 | // +----------+ +----------+ temp_person = node2; node2 = node1; node1 = temp_person; // node2 node1 // +----------+ next +----------+ // | node |----->| node | // +----------+ +----------+ // | address | address // vv // +----------+ +----------+ // | address1 | | address2 | // +----------+ +----------+ 

   So far, so good. The two pointers are swapped. And that means node1->address sees the second node's address.

   But wait: Then you swap address pointers.

     temp_address = node2->address; node2->address = node1->address; node1->address = temp_address; // node2 node1 // +----------+ next +----------+ // | node |----->| node | // +----------+--+ +----------+ // address| | address // +-------|--------+ // v | // +----------+ | +----------+ // | address1 | +-->| address2 | // +----------+ +----------+ 

   So now, node1->address points at address1 . You have unswapped the data.

   So decide whether you want to swap pointers or data. If you swap the data, you only need the two nodes' pointers, and don't modify the next pointers. If you're swapping whole nodes, on the other hand, you need the "before" node, and you don't touch the data pointers -- the whole point of swapping the pointers is to rearrange the data.

Answer 2

As you are using single linked list to swap two elements you should run it from the beginning till the last element to swap. While running it is necessary to find two previous pointers to these two elements which have to be swapped (one previous pointer may be null if element is the first in the list). Then this loop finished (at the seconds element to swap) you must have four: first element to swap (first), previous to first element (first_prev; may be null), second element (second) and the previous element to swap (second_prev; may be null). Then you need just to swap them in way like this:

  temp_first_next = first->next;
  temp_second_next = second->next;

  /* put first element at place of the second */
  first->next = temp_second_next;
  if (second_prev) {
    second_prev->next = first;
  }

  /* put second element at place of the first */
  second->next = temp_first_next;
  if (first_prev) {
    first_prev->next = next;
  }

And if you are really using C++ it is better to switch to using std::string , std::list and use classes for each element. It will be easier, less pointers. :)

Answer 3

You don't need to use strcpy. When you swap nodes, you can accomplish that by swapping the .next member variable. The only reason to use linked lists is to copy a bunch of data around.

In times like these, it's a good idea to draw out the situation on paper. Draw several boxes in a line:

 W["1"] -> X["3"] -> Y["2"] -> Z["4"]

Ok, so, we have four nodes, WXY and Z, set up so that W points to X, X points to Y, and Y points to Z.

Each node has a string value. W's value is 1, X's value is 3, Y's value is 2, and Z's value is 4.

We want to sort the nodes so that the string values go in ascending order: 1, 2, 3, 4.

Now, you've been trying to accomplish that by swapping the actual data values around:

swap(X.data, Y.data)

... resulting in:

W["1"] -> X["2"] -> Y["3"] -> Z["4"]

That would work, but it's not a good idea, for many reasons. It's very bug-prone, for one. For two, you give up the main benefit of using linked lists: swapping around the links, rather than the data.

Here's what it would look like if you swap the node linkages around:

 W["1"] -> Y["2"] -> X["3"] -> Z["4"]

Notice how none of the data moved -- W's value is still 1, X's value is still 3, Y's value is still 2, and Z's value is still 4. But we've rearranged the traversal order: now W leads to Y, which leads to X, which leads to Z, giving the expected result of 1, 2, 3, 4.

This may sound confusing, but it's simple once you get into the right mindset. Let's break down the steps one at a time.

What's the difference between our initial state...

 W["1"] -> X["3"] -> Y["2"] -> Z["4"]

... and our desired state?

 W["1"] -> Y["2"] -> X["3"] -> Z["4"]

Aha, the difference is that we've swapped the middle two nodes. So that's the operation we need to figure out how to do: How do you swap two adjacent nodes?

Well, let's look at it like this. W used to lead to X, which lead to Y, which lead to Z.

We want W to lead to Y; we want Y to lead to X; we want X to lead to Z.

Do you see? That involves modifying three nodes. You can't do it if you only know about two of the nodes. You have to be able to modify three in a row.

Let's get rid of some clutter:

A -> B -> C -> D

We want to swap B and C, so that it winds up looking like:

A -> C -> B -> D

How?

Well, that graph is equivalent to the following:

A -> A.next -> A.next.next -> A.next.next.next

So here's what we can do. Let's define an operation that takes a node, and swaps the two nodes after it. So if we use our operation on A, then it will swap B and C around. Or if we use our operation on B, then it will swap C and D around.

Here's how.

void swapAfter( Node* node ) {
  Node* A = node;
  Node* B = node->next;
  Node* C = node->next->next;
  Node* D = node->next->next->next;

  A->next = C; // Lead A to C
  C->next = B; // Lead C to B
  B->next = D; // Lead b to D

  // Now we have A->C->B->D!
}

And there we go. Now we have a way of swapping around any two nodes.

The reason I decided to explain it this (roundabout) way is to help you understand and visualize what's going on with linked lists. Beginners often have trouble mentally following what happens during the operations. Usually they'll just blindly do what a book tells them to do and not really grok why it works. Whereas with this example, each step is very obvious.

But that "swapAfter" function might not be very useful to you if you try to use it directly. For one thing, it'll crash if you try to use it on the last node, because it has no error checking. But the point was to give you an understanding of how linked lists work rather than give you a swapNodes function. :-)

The main takeaway is that you're not providing enough parameters to your swapNodes function... if you want to swap "curNode" and "nextNode", then at that point you must know which node comes before curNode ("prevNode"). Then you'd do something like:

Node* finalNode = nextNode->next;

// right now, we have..
//   prevNode -> curNode -> nextNode -> finalNode

// we want..
//   prevNode -> nextNode -> curNode -> finalNode

// so..
prevNode->next = nextNode;
nextNode->next = curNode;
curNode->next = finalNode;

Note that you'll have to do error checking in order to get this to work completely... eg what if nextNode is NULL? Or what if prevNode is NULL (meaning curNode is the first node?) Just work through each case one by one.

If you want to sidestep all of this complexity, there's really no reason to use linked lists. Instead, you can make an array of pointers:

Person** people = new Person*[4];
for ( int i = 0; i < 4; i++)
  people[i] = new Person();

and then you can sort that array by just swapping around its elements:

if ( strcmp(people[1]->fullName, people[2]->fullName) > 0 )
  swap( people[1], people[2] );

No more dealing with 'next' pointers. But now if you want to add more than 4 people to your array, you'll have to reallocate it, since it's a fixed size. So that's the tradeoff.

Anyway, I hope this was somewhat helpful. This is my first real Stack Overflow comment, so I apologize if it's a little rough.

Answer 4

The problem arises from the fact that you are swapping the elements of the list while iterating through it.

Another approach could be to run through the list and swap objects until it runs through the list once without swapping any elements.