# Printing nodes

All

### Intro

Solving some problems with C++ is quite interesting:

This one, as simply as follows: You have a sequence of nodes, and you need to print the sequence of values within the nodes.

##### Node(int data, Node* next = null) { this->data = data; this->next = next; } };

So then the test is to create a function that returns, as string,”0 -> 1 -> 4 -> 9 -> 16 -> nullptr”, when this goes in new Node(0, new Node(1, new Node(4, new Node(9, new Node(16)))))

All my solutions are here  and are details below.

### Solution 0 (used in all the solutions)

All my solutions use while(list) to iterate over the nodes, it’s quite simple and direct utilization.  The vector used was from std  – as suggested. This article here  talks about the performance of STL vectors and specifically the push_back function.

My main solutions was (pseudo-algorithm)

2. Accumulate the values

3. Read the accumulate values and create the string

4. Return the string

### Solution 1

The solution one the one with everything combined. I run for each node, convert it to string, adding with the ” – > ” in the final string.

This solution is then an implementation of my pseudo-code in only one passage over the nodes. So:

Read node, create string, accumulate > Read node, create string, accumulate> Read node, create string, accumulate (…)

### Solution 2

The solution one was the simple iterate on the nodes, create a vector of strings (vector library) and accumulate the strings. Later use a for loop to go on each and accumulate on the string the values. Adding the null at the end, since it has a comparison.

This solution is then a break on my pseudo-algorithm, in a way to break it in two:

2. read string, change, acc new string > read string, change, acc new string

### Solution 3

This solution was basically the previous, but with the function += instead of append. This is nothing in C++ concatenation and append is different in Python for example.

Then the solution is the same as Solution 2

### Solution 4

This solution I basically read the nodes, put all the info in a vector and then send this vector to another function, which aims to congregate all the string creation. This seems redundant but breaks the solution in two:

1. Reads the content of the nodes

list->data access.

2.  Create the string

The function that will iterate over the temp vector and concatenate the string forming the ” -> ” value.

So then:

2. read string, change, acc new string > read string, change, acc new string (Scope function 2)

### Notes

While doing some tests with Repl.it, my favourite online compilation framework, I came with a bizarre error related to the non declaration of add_list, I think is a memory problem on the previous runs, because the error wouldn’t go away. I deleted the solution, restarted and it worked – all good.

for(int i = 0; i < temp.size(); i++){
}

### Conclusion

My conclusion is to use the function or a separate solution, instead of putting everything together in the same place.

One must be careful because not all the issues that occur on the pointers access are segmentation fault, which can also occur. The solution with if(pointer) and while(pointer) are valid and are prefered over the pointer!=null actually, to simplify the reading of the code .

I would like to compare the solutions with other compilers and I found that nullptr only works if we have C11 and use std=c++0x, for Gcc 4.6 btw!!