I am trying to learn linked list using c++. Here is my code:
#include<bits/stdc++.h>
using namespace std;
struct node
{
int data;
node *next;
};
void show(node *head)
{
node *n;
n=head;
while(n)
{
cout<<n->data<<' ';
n=n->next;
}
cout<<endl;
}
void insert(node *list,int x)
{
list->data=x;
node *t=new node;
list->next=t;
list=t;
}
int main()
{
node *head,*t,*list=new node;
head=list;
for(int i=0;i<10;i++)
{
insert(list,i+1);
}
show(head);
}
I have pointed head to the memory list is pointing to at beginning, but after insert the call of insert function, head points to the memory that list is pointing to, but was it suppose to happen. Isn't head suppose to remain unchanged?
insert() when called repeatedly on the same list makes list->next point to a new node.
That new node is not initialised, so dereferencing its next pointer (as occurs in show()) gives undefined behaviour. As soon as code has undefined behaviour, all bets are off - anything can happen.
The net effect is that, because of how insert() behaves, show() will exhibit undefined behaviour.
Since list is passed by value, assigning to it in insert() has no effect. That assignment is not visible to main().
The previous node pointed to by list->next is also lost (not released, no longer accessible).
main() also leaves list uninitialised, so using its members (in insert() or show()) causes undefined behaviour, even if problems above are fixed.
There are two problems with the insert() function.
1) The wrong node's data is set. Instead of setting the new node's data to the value being inserted, the code sets the existing head node's data to the new value. The new node's value remains uninitialized.
2) The list parameter is passed by value to insert(). Which means that:
list=t;
accomplishes absolutely nothing. Because list is passed by value, this sets the insert() function's list to the new list head. Unfortunately, when insert() returns, the new list head gets discarded, and the original list in main() remains unchanged.
Either list must be passed to insert() by reference, or insert() should explicitly return the new list.
Additionally:
main() allocates the initial head node, and leaves it completely uninitialized. This link-list will always have one extra node whose data is never initialized. This is probably not what was intended. The correct approach is to set the empty list's head pointer to NULL, an empty list, and the first insert() should then correctly instantiate the first node in the link list.
There's one other thing that's wrong with the existing code that creates the extra, uninitialized node, that makes it clearly a bug: the extra node's next pointer is also not initialized. Attempting to walk the resulting link list will result in undefined behavior, and a likely crash.
Related
I'm working with LinkedLists from custom node, I'm still struggling to understand some concepts. For simplicity functions are reduced
class Node {
public:
T data;
Node* next;
Node(const T& copy){
data = copy;}
class T {
string name;
int age;
T(string name, int age){
T::name = name;
T:age = age;}
class LinkedList{
private:
Node* head;
void insertAtFront(string name,int age){
Node* newNode = new Node(name,age);
head = newNode;
/*
T temp(name,age);
Node newNode(temp);
head = &newNode */
;
}
I'm coming from java background, I know variables are treated differenly in c++ and java. I know c++ copies by value unless *, & is used. My misconceptions might probably occur because of the differences though, I couldn't solve it.
1-In insertAtFront function, implementations on the internet creates the node pointer dynamically(using new keyword). Can't we do it as the way between /* */ ?
2- I actually dont get the idea of why head is a pointer in the linked list. I've created linked lists in java. As long as the next value of the head is correct (so changing it in the correct way in c++) why should I make head a pointer ?
If you use:
T temp(name,age);
Node newNode(temp);
head = &newNode;
the variable newNode is destroyed when it goes out of scope. Then head points to a destroyed variable. It might continue to hold the same node values for a very short time - probably until the next function call (you can't rely on this). Then that memory space will be reused for some other variable.
head continues pointing to the same memory address, and the data at that address has been overwritten for some other purpose, so you won't be able to read the node data there that you want to read.
Each time you use new it creates a nameless "variable" that doesn't get destroyed and reused until you use delete. Since the variable doesn't have a name, you have to use pointers to refer to it.
2- I actually dont get the idea of why head is a pointer in the linked list. I've created linked lists in java. As long as the next value of the head is correct (so changing it in the correct way in c++) why should I make head a pointer ?
In Java, every Node variable - every object variable - is actually a pointer. In C++, that's not true and you have to ask for pointers when you want them. When you write Node next; in C++ you are saying that the variable next has a real, bona-fide Node inside the variable. If you write class Node {Node next;} then you are saying every node has another node inside it - but that one has a node inside it too - but that one has a node inside it too - on to infinity - which is impossible, of course.
You could choose to use Node head;. That's a valid design choice, but it complicates things. It means the first node in every linked list is inside the list itself, and you can't change which node it is because it's not a pointer. If you wanted delete the first node, then you'd have to do it by copying the second node to the first node and then deleting the second node. And you'd have to figure out how you wanted to store an empty list.
This is kind of silly, but I can't really explain why this is happening. As an exercise, I wanted to reverse a singly-linkedlist and I did this by defining the method:
class solution {
void reverseLinkedList(Node*& head) {
Node* curr = head;
Node* prev = NULL;
while (curr != NULL) {
Node* _next = curr->next;
curr->next = prev;
prev = curr;
curr = _next;
}
head = prev;
}
In my main function, I make the call
solution s;
s.reverseLinkedList(head);
Node* iterator = head;
while (iterator != NULL) {
std::cout<<iterator->data<<std::endl;
iterator = iterator->next;
}
Where I previously defined my head pointer to some linkedlist. The while loop is for printing my linkedlist and the function does it job. This only worked after I passed the head node by reference; I initially tried to pass Node* head instead of Node*& head in the beginning, and it only printed the first element of my linkedlist (and without reversing it). For example, if I didn't pass by reference for a list 1->2->3, I would print out just 1.
I thought passing a pointer would be enough? Why did I get such weird behaviour without passing by reference>
Local variables in C++ (stored in the stack) have block scope, i.e., they run out of scope after the block in which they are defined is executed.
When you are passing in a pointer to the function, a copy of the pointer is created and that copy is what is passed. Once the function is executed, the variables in the function workspace run out of scope. Any non-static Automatic variables created within the function are destroyed.
When you pass in by reference you don't pass in a copy of the variable but you pass in the actual variable, thereby any changes made to the variable are reflected on the actual variable passed into the function(by reference).
I would like to point out that the pointer to the next node is stored in memory and has an address to the location it is stored. So if you want to not pass in by reference you can do this:
Use a pointer to the pointer, which points to the memory location at which pointer variable(address) to the next node is stored
Pass in this to the function (not by reference)
Dereference the pointer and store the new address you want to point to.
I know this is a bit confusing, but look into this small piece of code that adds a node to a linked list.
void addNode(Node** head, int newData)
{
Node* newNode = new Node;
newNode->data = newData; // Can also be done using (*newNode).data
newNode->next = *head;
*head = newNode;
}
I thought passing a pointer would be enough?
void reverseLinkedList(Node* head) // pass pointer by value
// head is a copy here
Passing a pointer by value creates a copy to be used inside the function.
Any changes made to that pointer inside the function is only reflected in the function scope. Since those changes are only reflected in the pointer's copy and not in the original pointer.
Once the pointer (copy) goes out of scope, those changes are "discarded" due to end of life.
Thus, you need a reference.
void reverseLinkedList(Node&* head) // changes made in head will be
// reflected in original head pointer
When you pass a pointer regularly (IE by value) it creates a copy of the pointer. Any changes made to this pointer do not effect the original pointer.
Passing a pointer by reference is sending a reference to that pointer (very similar to passing a pointer to a pointer) and therefor any changes made to that pointer are effecting its 'original' state.
For example:
//WRONG does not modify the original pointer, causes memory-leak.
void init(Object* ptr, int sz) {
ptr = new T[sz];
}
vs
//Correct original pointer is a set to a new block of memory
void init(Object*& ptr, int sz) {
ptr = new T[sz];
}
In
void reverseLinkedList(Node* head)
The pointer is passed by value.
This sounds silly, it's a freaking pointer, right? Kind-of the definition of pass by reference. Well, the Node that's being pointed at is passed by reference. The pointer itself, head is just another variable that happens to contain the address of some other variable, and it's not being passed by reference.
So head contains a copy of the Node pointer used to call reverseLinkedList, and as with all parameters passed by value, any modifications to the copy, pointing head somewhere else, are not represented in the calling function.
Suppose I have a doubly-linked list defined by the class
class list
{
/*...*/
private:
struct node
{
node* prev;
node* next;
int* value;
}
node* first; //NULL if none
node* last; //NULL if none
/*...*/
}
If I wanted to make a destructor for this list do I have to explicitly delete the value?
list::~list()
{
node* move = first;
while(first)
{
first = move->next;
delete move;
move = first;
}
}
Would the above work to ensure that no memory is leaked? Or do I have to do:
list::~list()
{
node* move = first;
while(first)
{
first = move->next;
delete move->value;
delete move->prev;
delete move;
move = first;
}
}
I'm confused as to how I can make sure that no memory is leaked in this case. How do I deal with the pointers in the nodes specifically? If I delete move does it automatically take care of these?
You need to pair each new with exactly one delete. That is, you probably don't want to delete prev (this node already was deleted) but you want to delete value. Well, I'd embed the value into the object and not point to it:
struct node
{
node* prev;
node* next;
int value;
};
If the value absolutely needs to be a pointer, I'd use a std::unique_ptr<int> (or, if you need to use C++ 2003, a std::auto_ptr<int>).
For each successful new expression, call delete exactly once on that object.
For each successful new[] expression, call delete[] exactly once on that object.
That means that neither of your cleanup functions are OK:
The first function forgets to delete the value, which means a memory leak.
The second function, by deleting both move and move->prev at each node in the list, risks deleting most nodes twice, which is Undefined Behavior.
To avoid the memory leak for the first function, simply store the integer directly instead of allocating it dynamically.
Whether you have to delete the memory pointer by the value member - only you can know. It is a question of memory ownership, a question of your design. If the list owns the data memory pointed by the value members, then you have to delete it in the list destructor (i.e. when the list dies, the data it owned dies with it).
If the list does not own the value memory, then you are not supposed to delete it. Again, only you can answer the question of whether your list is supposed to own the value memory. It is a matter of your intent.
Now, as for the memory occupied by node objects, it is obviously owned by the list, so it has to be carefully deallocated in the destructor. The first version of your destcructor is close to being correct (the second makes no sense at all), except that it written in a slightly obfuscated fashion. This should be sufficient
list::~list()
{
while (first)
{
node *move = first;
first = first->next;
delete move;
}
}
(Again, if you have to delete value, then delete move->value should be added to your cycle before delete move.)
P.S. Once you get this, you might want to look into various smart pointer classes, which allow you to explicitly express memory ownership relationsips, thus making them known to the compiler. When used properly, they will make memory management almost automatic.
In most of the explanations in the book the author insists of using **list passing instead of *list, however as per my understanding I feel there is nothing wrong in *list. Please someone explain me in detail if i am wrong. For example, to delete head of a linked list, the author says the below code is wrong.
void RemoveHead(node *head)
{
node *temp = head-> next; /* line 1 */
free(head);
head = temp;
}
Instead he says the below code must be used
void RemoveHead(node **head)
{
node *temp = (*head)-> next;
free(*head);
*head = temp;
}
In your first example:
head = temp;
Does nothing outside the function, it only sets the local variable head to temp inside the function. Whatever variable the caller passed in will remain unchanged. The author is correct, you need to use pointers or (better) references (if you're using C++).
Well. When you want to modify a integer variable inside a function, you pass it by reference. That is, you pass its address.
int x = 5;
void modify_value (int* x)
{
(*x) = 7; // is not 5 anymore
}
With pointers is the same. If you want to modify a pointer. You have to pass it by reference. That is, you have to pass its address. Which is a pointer to a pointer.
int* ptr_x = &x;
void modify_pointer (int** ptr_x)
{
*ptr_x = NULL; // is not &x anymore
}
Author is right. ** is effectively pass by reference (i.e. you can change 'head').
In your version (pass by value), head remains unchanged in the calling code.
When passing a node* as the argument, you can free, and modify the contents of the memory address pointed by that pointer. However, modifications performed on the pointer itself will not be seen from outside the function, since the pointer is passed by value.
On you second example, since you are passing a pointer to the head pointer, you can actually modify the actual head pointer, not just the memory pointed by it.
So in your second function, when *head = temp; is executed, you are modifying the address to which the pointer passed as argument points to.
Therefore, the author is right.
The author is correct. In your first example, you're modifying a local copy of head - the caller won't notice that anything has changed. head will still have been freed, so you're on track for a crash in pretty short order. You need to pass a pointer to modify the caller's variable.
I have a school assignment which requires me to create a binary tree in c++, complete with all the usual overloaded operators (=, ==, !=, copy, destroy, etc). I am currently struggling to program the copy constructor method. In this assignment, I am being asked NOT to use the binary tree class' insert method in either the operator= or copy constructor methods. Here's the binary tree class header file:
#ifndef BINTREE_H
#define BINTREE_H
#include <iostream>
#include "nodedata.h"
using namespace std;
class BinTree
{
public:
BinTree(); // constructor
BinTree(const BinTree &); // copy constructor, calls copyHelper
~BinTree(); // destructor, calls makeEmpty
bool insert(NodeData*); // insert method, inserts new nodes
bool isEmpty() const; // true if tree is empty, otherwise false
private:
struct Node
{
NodeData* data; // pointer to data object
Node* left; // left subtree pointer
Node* right; // right subtree pointer
};
Node* root; // root of the tree
Node& copyHelper(const Node*); // copies the tree recursively
void makeEmpty(Node*); // deletes nodes recursively
};
#endif
And here's what I've got so far for the copy constructor:
BinTree::BinTree(const BinTree &otherTree)
{
root = copyHelper(otherTree.root); // 1
}
Node& BinTree::copyHelper(const Node* other) // 2
{
if(other == NULL)
{
return NULL; // 3
}
Node newNode; // 4
if(other.data == NULL)
{
newNode.data = NULL; // 5
}
else
{
NodeData newNodeData(*other->data); // 6
newNode.data = newNodeData; // 7
}
newNode.left = copyHelper(other.left); // 8
newNode.right = copyHelper(other.right); // 9
return newNode; // 10
}
This is causing all manner of compile errors, and I don't understand any of them. Here's what I THINK should be happening:
•Overview: The entire tree will be copied from the ground up recursively. Each node should already contain data and links to all subsidiary nodes (if they exist) when it is returned to the node above it.
Since root is, by definition, a pointer to a Node object, there should be no issue with assigning it to a function which returns a Node object. However, the compiler is giving me a conversion error here.
The copyHelper function, which is called recursively, takes a pointer to one of the original nodes as an argument, and returns a copy of this node.
If there is no original node, then there's no point in building a copy of it, so a NULL value is returned.
newNode will eventually become a copy of "other".
If "other" does not have any NodeData linked to it, then newNode's data pointer will link to NULL instead.
Otherwise, a new NodeData called "newNodeData" will be created, using the NodeData copy constructor, which is called by dereferencing other's NodeData pointer.
newNode's data pointer now points to newNodeData, which now contains the same string as other's NodeData object.
newNode's left pointer will point to another node, which is created recursively by calling copyHelper on whatever Node other's left pointer is assigned to.
newNode's right pointer will point to another node, which is created recursively by calling copyHelper on whatever Node other's right pointer is assigned to.
Only once this node and all the nodes beneath it have been copied and returned to it will it be returned itself.
Here are my existing questions:
I'm assuming that we only need to use -> instead of . when we're dereferencing a pointer. Is this correct?
I know sometimes we need to use the "new" statement when creating objects (see part 4), but I've typically only seen this done when creating pointers to objects. When, specifically are we supposed to be using the "new" statement?
If I were to create newNode as a pointer (IE: Node* newNode = new Node;), wouldn't this cause a pointer to a pointer when it was returned? Wouldn't that be less efficient than simply having the first pointer point directly to the returned Node object? Is there some technical reason I can't do it this way?
When is it advisable to take a pointer by reference as a parameter, instead of simply taking the pointer, or even the object itself? Is this relevant here?
The compiler seems to think I'm declaring a Node named BinTree::copyHelper instead of defining a function that returns a Node. How can I prevent this?
In general, I think I have the concepts down, but the syntax is completely killing me. I literally spent all day yesterday on this, and I'm ready to admit defeat and ask for help. What mistakes do you guys see in my code here, and how can I fix them?
This line:
Node newNode; // 4
Allocates a Node on the stack. When the function returns, the Node is no longer valid. It has gone out of scope. It may work for a while if another function call doesn't rewrite the stack.
You need to do a New on the node.
Node& copyHelper(const Node*); // copies the tree recursively
Must that be a reference? It looks like it should be Node* instead.
In your declaration of copyHelper, the type Node is nested within BinTree but you fail to implement this. It should instead be
BinTree::Node* BinTree::copyHelper(const BinTree::Node* other)
Yes, -> dereferences a pointer. It's a shortcut for *pointer.member.
new creates object on the heap and returns a pointer - it does not create a pointer. Every time you create a object on the heap, you must use new.
Node * newNode = new Node; assigns pointer to newly created Node to newNode. Node * is pointer to object, not pointer to pointer, which would be Node **. You cannot do Node newNode = new Node;, as Node * (pointer) is not convertible to Node (object).
When you take parameter as reference, you are (generally) guaranteed that the parameter is not not. You also does not need to dereference the reference and you can just use . instead of ->.
"The compiler seems to think I'm declaring a Node named BinTree::copyHelper instead of defining a function that returns a Node. How can I prevent this?" - how did you come to such a conclusion?
After much fretting and pulling of hair, I have rewritten my copy constructor and gotten it to compile. There may well still be errors in it, but I'm feeling a lot better about it now thanks in part to the tips posted here. Thanks again! Here's the modified code:
BinTree::BinTree(const BinTree &otherTree)
{
root = copyHelper(otherTree.root); // Starts recursively copying Nodes from
// otherTree, starting with root Node.
}
BinTree::Node* BinTree::copyHelper(const Node* other) // Needed BinTree at beginning
// due to nested Node struct
// in BinTree class.
{
if(other == NULL)
{
return NULL; // If there's no Node to copy, return NULL.
}
Node* newNode = new Node; // Dynamically allocated memory will remain after
// function is no longer in scope. Previous newNode
// object here was destroyed upon function return.
if(other->data == NULL) // Other is a pointer to data, which is also a pointer.
// -> dereferences other, and provides the item at the
// memory address which other normally points to. It
// just so happens that since data is a pointer itself,
// it can still be treated as such. I had stupidly been
// attempting to use . instead of ->, because I was afraid
// the -> would dereference data as well. If I actually
// wanted to DO this, I'd have to use *other->data, which
// would dereference all of other->data, as if there were
// parenthesis around it like this: *(other->data).
// Misunderstanding this was the source of most of the
// problems with my previous implementation.
{
newNode->data = NULL; // The other Node doesn't contain data,
// so neither will this one.
}
else
{
NodeData* newNodeData = new NodeData; // This needed to be dynamically
// allocated as well.
*newNodeData = *other->data; // Copies data from other node.
newNode->data = newNodeData;
}
newNode->left = copyHelper(other->left); // Recursive call to left node.
newNode->right = copyHelper(other->right); // Recursive call to right node.
return newNode; // Returns after child nodes have been linked to newNode.
}