Can 2 singly-linked list nodes point to each other in C++?

Question

0.00/5 (No votes)

See more:

Consider a singly linked list.

First Node : value=v1,address of this node=x,next=y ;

Second Node : value=v2,address of this node=y,next=NULL

Linked list pointer *ptr=x;
Linked list pointer *ptr1=y;
ptr1->next=ptr; // This is wrong

This will show the error of "heap-use-after-free"
WHY I can't store the address of 2 nodes in each other?

ptr->next=NULL // or any other node address
ptr1->next=ptr; // This is right

I can use this but why I can not use the above one?

(I don't need to traverse to the end and you can assume there are a lot of nodes)

What I have tried:

CODE FOR BETTER UNDERSTANDABILITY OF QUESTION
This is showing error why?

C++

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
     ListNode* reverseList(ListNode* head) {
        ListNode *a,*b,*c;
        a=head;
        if(!a)
            return a;
        a=head->next;
        b=head->next->next;
        while(b!=NULL)
        {
            c=b->next;
            b->next=a;
            a=b;
            b=c;
        }
        head->next=NULL;
        return a;
    }

now below one is correct

C++

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode *a,*b,*c;
        a=head;
        if(!a)
            return a;
        b=head->next;
        head->next=NULL;
        while(b!=NULL)
        {
            c=b->next;
            b->next=a;
            a=b;
            b=c;
        }
        return a;
    }
};

Posted 25-Jan-21 17:14pm

Member 15056063

Updated 26-Jan-21 4:13am

v4

Add a Solution

2 solutions

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Dave Kreskowiak · Answer 1 · 2021-01-25T18:39:00

Think about it. Say you need to enumerate the list and display all of the objects or do some calculation on each object in the list. Start at the beginning of the list and enumerate the list, do your work on each object and follow the Next pointer to the next object in the list. Keep going until you get to the end of the list, there's no more Next pointers to follow. Your work is done!

Oh wait, that never happens! Since you now have two nodes where the Next pointers point at each other, you will never get to the end of the list and terminate the enumeration. The enumeration will go on forever because you never find a Next pointer that is null.

Creating a ring in your list defeats the purpose of it being a "list".

OriginalGriff · Answer 2 · 2021-01-25T19:52:00

To add to what Dave Kreskowiak has said: yes, technically you can do that. The systems does not in any way prevent you from pointing pointers anywhere you like. You can even make a node self referential:

C++

ListNode* ReallyMessItUp(ListNode* head) 
   {
   head->next = head;
   }

But just because you can do something, doesn't mean you should.
Most developers go to great lengths to prevent loops happening - regardless of how long or short they are - because they can trap code in a never-ending loop.
The only exception to this is when when a linked list is being used as a Queue, when you need the ability to add at one point and remove from teh other, and teh two may not be synchronous (I might add a node every second, and remove at a rate that varies between 0.5 seconds to 3 seconds per node, for example).

Can 2 singly-linked list nodes point to each other in C++?

2 solutions

Solution 1

Solution 2

Add your solution here

Preview 0