在链表java中切换节点时遇到问题

Question

I am attempting to switch two nodes in a linked list in java and am having some issues. My sorting algorithm works properly as I checked it by switching the contents of the node, but when attempting to switch the nodes themselves I am getting issues.

The following is my node switch code:

                Node tmp = current;
                tmp.next = current.next.next;

                Node tmp2 = current.next;
                tmp2.next = current;


                current.next = tmp;
                current = tmp2;

With this code however, my loop keeps looping so I am sure there is a problem with my switching logic. If anyone could help me figure this out I would greatly appreciate it.

** to clarify: I am aiming to switch current and current.next.

Thank you!

Answer 1

You're almost there. Back when I did this in college, in order to swap 2 nodes you want to grab the node that's before the first node you wish to swap. For instance. If you have

----> currNode -> node_A -> node_B -> node_C ------>

Here we wish to swap node_A with node_B so we stop at currNode since we need to set currNode.next to node_B .

Following this, we have the following (i'm assuming it'll get passed into some method):

Node tmp = curr;
Node A = curr.next;
Node B = curr.next.next;
Node C = curr.next.next.next;

Now we just need to set the right things.

tmp.setNext(B);  //Now we have ----> tmp -> B
B.setNext(A);   //Now we have  ----> tmp -> B -> A
A.setNext(C);   //Now we have ----> tmp -> B -> A -> C --->

Now if node_A happens to be the first node or if node_B happens to be the last node then there's gotta be some extra conditions in there you might want to keep in mind.
You can tell if node_A happens to be the first node in your linked list, You can have some for of check like:

public void swap (NodeStructure nodeStructure, Node Node_A, Node Node_B){
    Node A = Node_A;
    Node B = Node_b;
    if(nodeStructure.head == A){
       //Node A is the first Node, so we need to handle it in a special way.
       Node tmp = Node_A;
       nodeStructure.setHead(B); //Now we have -> B
       B.setNext(tmp);           //Now we have -> B -> A
       A.setNext(C);             //Now we have -> B -> A -> C ------>
    }

    //or in the case of the tail 

    if(nodeStructure.tail == B){
       //Node B is the last Node, in this case, we don't need node_C
       /*Iterate through nodeStructure until you reach node before A and  
         assign this to tmp.*/
       nodeStructure.setTail(A); //Let's set the tail first
       tmp.setNext(B);  //Now we have ----> tmp -> B
       B.setNext(A);   //Now we have  ----> tmp -> B -> A
    }

     /* Depeding on how you decide to implement, you might also have a third 
        condition checking if Node_A is the head and Node_B is tail.*/

    //Handle condition where there's no special cases.
}

Answer 2

Node tmp = current;
tmp.next = current.next.next;

The code above first gets the current node and makes tmp point to it. Then it changes the next of tmp . The problem is, that also will change current , since they point to the same thing.

You want something like:

Node tmp = current.next.next;
current.next.next = current;
current.next = tmp;

Answer 3

Try this code. I'm using slightly different naming conventions to you but the code is swapping the nodes at current and current.next .

Node head = current.next; // the node to become the start of the list (may be null)

if (head != null) {
  // swap current node's position
  current.next = head.next;
  head.next = current;

  // update the node current is pointing to
  current = head;
}

Visually this is what's happening:

Current -> B -> Rest of List... will become B -> Current -> Rest of List...

Answer 4

Ok I finally figured it out!

I was going at it all wrong.It was simply a problem of re-linking. The following was my solution:

                Node temp = current;
                Node prevNext = prev.next;
                Node currentNext = current.next;
                Node currentNextNext = current.next.next;


                current.next.next = temp;
                current.next = currentNextNext;
                prev.next = currentNext;

Hope it helps anyone who might be stuck like I was!