MHB Why Use a Helper Variable When Inserting an Element in an Array?

[mathmari]

We will have to allocate some space for it. (Nod)

In C that is done with [m]malloc()[/m] or [m]calloc()[/m].
For instance:

plansys_t *plansystem = calloc(1, sizeof(plansys_t));

It allocates memory for 1 element with the size of the [m]plansys_t[/m] structure.

After this, you can follow the pointer safely. (Angel)

Ahaa... (Nerd)

With [m]plansystem->solid=solid;[/m] you follow the pointer to its end and assign it a value. That's when it results in madness and chaos. (Evilgrin)

Could you explain me further why this is wrong?? (Wondering)

 

[I like Serena]

Could you explain me further why this is wrong?? (Wondering)

Basically we are talking about a RAM machine.
In a RAM machine we have certain locations of memory available.
And we have an operation to refer to memory indirectly.
However, when we refer to memory indirectly, it always has to refer to a memory location that is actually available.
Otherwise, we have a bad pointer. If we refer to a bad pointer, we will get an access violation, meaning that the pointer does not refer to any valid memory location. (Nerd)

 

[mathmari]

Basically we are talking about a RAM machine.
In a RAM machine we have certain locations of memory available.
And we have an operation to refer to memory indirectly.
However, when we refer to memory indirectly, it always has to refer to a memory location that is actually available.
Otherwise, we have a bad pointer. If we refer to a bad pointer, we will get an access violation, meaning that the pointer does not refer to any valid memory location. (Nerd)

When we call [m]plansys_t *plansystem = calloc(1, sizeof(plansys_t));[/m] has plansystem all the fields of the struct plansys?? So there are the following:
plansystem->solid
plansystem->asteroids
plansystem->next
right?? (Wondering)

 

[I like Serena]

When we call [m]plansys_t *plansystem = calloc(1, sizeof(plansys_t));[/m] has plansystem all the fields of the struct plansys?? So there are the following:
plansystem->solid
plansystem->asteroids
plansystem->next
right?? (Wondering)

Yes. (Nod)

Furthermore, they are all initialized to zero by the calloc() function.

 

[mathmari]

Yes. (Nod)

Furthermore, they are all initialized to zero by the calloc() function.

So, we don't have to add the new object "solid" at the field plansystem->solid , right?? Where do we have to add it then?? (Wondering) I got stuck right now...

 

[I like Serena]

So, we don't have to add the new object "solid" at the field plansystem->solid , right?? Where do we have to add it then?? (Wondering) I got stuck right now...

I don't understand your question.

You can assign a value to plansystem->solid, and it is initially set to 0, meaning false.

 

[mathmari]

You can assign value to plansystem->solid, and it is initially set to 0, meaning false.

But why can we not assign the value solid to plansystem->solid
(plansystem->solid=solid; ) ?? (Wondering)

After that I have to write a function for the constitution of a new object and therefore the constitution of a new planetary system (plansys_t) with identifier of the object "solid" at the star system with identifier "ss". The new planetary system contains an empty list of asteroids. The new element, that corresponds to the new planetary system, should be added to the list of the planetary systems of the star system with identifier "ss".

With the following function:

int Beginning(int solid, int ss){
	        int i, k;
                plansys_t *plansystem = calloc(1, sizeof(plansys_t));
                plansystem->asteroids=NULL;
		for(i=0; i<nrStarS; i++){
			if(StarS[i].ss=ss){
				k=i;
			}
		}
		StarS[k].plasy=plansystem;
		return k;
}

the new planetary system contains an empty list of asteroids and the new plansystem is added to the array StarS at the position where the star system has the identifier "ss", right?? (Wondering) But I haven't used the identifier of the new object "solid"...

 

[I like Serena]

But why can we not assign the value solid to plansystem->solid
(plansystem->solid=solid; ) ?? (Wondering)

I don't understand.
We can do that, can't we?

With the following function:

int Beginning(int solid, int ss){
	        int i, k;
                plansys_t *plansystem = calloc(1, sizeof(plansys_t));
                plansystem->asteroids=NULL;
		for(i=0; i<nrStarS; i++){
			if(StarS[i].ss=ss){
				k=i;
			}
		}
		StarS[k].plasy=plansystem;
		return k;
}

the new planetary system contains an empty list of asteroids and the new plansystem is added to the array StarS at the position where the star system has the identifier "ss", right?? (Wondering) But I haven't used the identifier of the new object "solid"...

So you should add [m]plansystem->solid = solid;[/m], shouldn't you? (Wondering)

Btw, what happens if $ss$ cannot be found? (Wondering)

 

[mathmari]

So you should add [m]plansystem->solid = solid;[/m], shouldn't you? (Wondering)

Btw, what happens if $ss$ cannot be found? (Wondering)

So, should it be as followed?? (Wondering)

int k=-1;

int Beginning(int solid, int ss){
		int i;
                plansys_t *plansystem = calloc(1, sizeof(plansys_t));
                plansystem->solid=solid;
                plansystem->asteroids=NULL;
		      for(i=0; i<nrStarS; i++){
			   if(StarS[i].ss=ss){
				k=i;
                                StarS[k].plasy=plansystem;
			   }
		      }
                      if(k==-1){
                         printf("The star system with identifier %d couldn't be found\n", ss);
                      }
		return k;
}

 

[I like Serena]

So, should it be as followed?? (Wondering)

int k=-1;

int Beginning(int solid, int ss){
		int i;
                plansys_t *plansystem = calloc(1, sizeof(plansys_t));
                plansystem->solid=solid;
                plansystem->asteroids=NULL;
		      for(i=0; i<nrStarS; i++){
			   if(StarS[i].ss=ss){
				k=i;
                                StarS[k].plasy=plansystem;
			   }
		      }
                      if(k==-1){
                         printf("The star system with identifier %d couldn't be found\n", ss);
                      }
		return k;
}

Well, you wrote: "The new element, that corresponds to the new planetary system, should be added to the list of the planetary systems of the star system".

I interpret that to mean that the current list is not necessarily empty.
That means that you have to add it to the linked list. (Wasntme)Btw, we could treat $ss$ as an index in the StarS array, in which case we could do: [m]starsy_t *starsystem = &StarS[ss];[/m].
Adding a new star system would then simply mean initializing the [m]StarS[ss][/m] structure, which is also an O(1) operation. (Nerd)

 

[mathmari]

The function should do the following:
Constitution of a new object and a new planetary system with identifier "solid" at the star system with identifier "ss".

>empty list of asteroids

>add a new element to the list of the planetary system of the star system with idenifier "ss".

Well, you wrote: "The new element, that corresponds to the new planetary system, should be added to the list of the planetary systems of the star system".

I interpret that to mean that the current list is not necessarily empty.
That means that you have to add it to the linked list. (Wasntme)

Which list do you mean?? (Wondering)

Btw, we could treat $ss$ as an index in the StarS array, in which case we could do: [m]starsy_t *starsystem = &StarS[ss];[/m].
Adding a new star system would then simply mean initializing the [m]StarS[ss][/m] structure, which is also an O(1) operation. (Nerd)

Could you explain me what you mean?? (Wondering)

 

[I like Serena]

The function should do the following:
Constitution of a new object and a new planetary system with identifier "solid" at the star system with identifier "ss".

>empty list of asteroids

>add a new element to the list of the planetary system of the star system with idenifier "ss".

Which list do you mean?? (Wondering)

The [m]starsy_t[/m] structure has a field [m]plasy[/m] that identifies a linked list:

[m]plansys_t *plasy; /*Pointer to the first element in the list of the planetary system */[/m]

In turn, the structure [m]plansys_t[/m] has a [m]next[/m] field, which links the structure to the next plansys_t. (Thinking)

Could you explain me what you mean?? (Wondering)

I mean that your Constitution() function could be like this.

int Constitution(int ss) {
    if ((ss >= 1) && (ss < N)) {
        // Initialize the star system
        starsy_t *starsystem = &StarS[ss];
        starsystem->ss = ss;
        return 0; // Success
    } else {
        printf("The star system could not be constituted: %d \n", ss);
        return 1; // Failure
    }
}

int main(){
    Constitution(12);
    for(ss = 1; ss < N; i++){
        if (StarS[ss].ss == ss) {
            printf("The elements are: %d \n", ss);
        }
    }
    return 0;
}

(Thinking)

 

[mathmari]

The [m]starsy_t[/m] structure has a field [m]plasy[/m] that identifies a linked list:

[m]plansys_t *plasy; /*Pointer to the first element in the list of the planetary system */[/m]

In turn, the structure [m]plansys_t[/m] has a [m]next[/m] field, which links the structure to the next plansys_t. (Thinking)

Ahaa...

- - - Updated - - -

It has to look as followed:

View attachment 3469

So could we write it as you did in the post #42?? (Wondering)

 

[I like Serena]

It has to look as followed:

View attachment 3469

Aha! (Smile)

So could we write it as you did in the post #42?? (Wondering)

Yes.
It fits either way. (Thinking)

 

[mathmari]

Aha! (Smile)
Yes.
It fits either way. (Thinking)

At the code of the post #42, we suppose that 1 $\leq $ ss $\leq $ N, right?? (Wondering)

Now I read again the exercise and I saw the following:

The function Constitution should print the identifiers of the star systems:
$<ss_1>, <ss_2>, \dots , <ss_n>$
where $n$ is the number of the existing star systems and for each $i$, $1 \leq i \leq n$, $<ss_i>$ is the identifier of the $i-$th star system.So, can it not be that the identifier of a star system is greater than $N$ ?? (Wondering)

 

[I like Serena]

At the code of the post #42, we suppose that 1 $\leq $ ss $\leq $ N, right?? (Wondering)

It's a little bit sharper.
We suppose $1 \leq ss < N$. (Mmm)

Now I read again the exercise and I saw the following:

The function Constitution should print the identifiers of the star systems:
$<ss_1>, <ss_2>, \dots , <ss_n>$
where $n$ is the number of the existing star systems and for each $i$, $1 \leq i \leq n$, $<ss_i>$ is the identifier of the $i-$th star system.So, can it not be that the identifier of a star system is greater than $N$ ?? (Wondering)

Yes.
With that description we can apparently not make assumptions about $ss$.
So then we should keep it as before, and track $n$ in [m]nrStarS[/m]. (Wasntme)

It also means that the function is supposed to print something specific.

 

[mathmari]

It's a little bit sharper.
We suppose $1 \leq ss < N$. (Mmm)

Ahaa... (Blush)

Yes.
With that description we can apparently not make assumptions about $ss$.
So then we should keep it as before, and track $n$ in [m]nrStarS[/m]. (Wasntme)

It also means that the function is supposed to print something specific.

Ok... So, is it as followed?? (Wondering)

int nrStarS = 0;

int Constitution(int ss) {
        int i;

        // Add a star system to the the array of stars
        starsy_t *starsystem = &StarS[nrStarS];
        nrStarS++;

        // Initialize the new star system
        starsystem->ss = ss;
        starsystem->plasy=starsystem->Sentinel;
	for(i=0; i<max; i++){
		starsystem->ffplan[i].fp=INT_MAX;
		starsystem->ffplan[i].ff=NULL;
	}

        // Return the index of the star system that was added
	return (nrStarS - 1);
}
	
	
int main(){
	int i, ss;
	printf("Give the identifier ss: \n");
	scanf("%d", &ss);
	Constitution(ss);
	for(i=0; i<nrStarS; i++){
		printf(" %d ", StarS[i].ss);
	}
        return 0;
}

 

[I like Serena]

Ok... So, is it as followed?? (Wondering)

int nrStarS = 0;

int Constitution(int ss) {
        int i;

        // Add a star system to the the array of stars
        starsy_t *starsystem = &StarS[nrStarS];
        nrStarS++;

        // Initialize the new star system
        starsystem->ss = ss;
        starsystem->plasy=starsystem->Sentinel;
	for(i=0; i<max; i++){
		starsystem->ffplan[i].fp=INT_MAX;
		starsystem->ffplan[i].ff=NULL;
	}

        // Return the index of the star system that was added
	return (nrStarS - 1);
}
	
	
int main(){
	int i, ss;
	printf("Give the identifier ss: \n");
	scanf("%d", &ss);
	Constitution(ss);
	for(i=0; i<nrStarS; i++){
		printf(" %d ", StarS[i].ss);
	}
        return 0;
}

I guess so. (Dull)

 

[mathmari]

The function Beginning should print the identifiers of the planetary systems:
$<solid_1>, <solid_2>, \dots , <solid_n>$
where $n$ is the number of planetary systems that exist in the star system with identifier "ss" and for each $i$, $1 \leq i \leq n$, $<solid_i>$ is the identifier of the $i-$th planetary system in the star system.

int k = -1;

int Beginning(int solid, int ss){
		int i;

        // Add a planetary system to the list of the planetary system of the star system
        plansys_t *plansystem = calloc(1, sizeof(plansys_t));
        plansystem->solid=solid;
        plansystem->asteroids=NULL;
        plansystem->next=NULL;
		for(i=0; i<nrStarS; i++){
			if(StarS[i].ss=ss){
				k=i;
				StarS[k].plasy=plansystem;
			}
		}
		if(k==-1){
			printf("The star system with identifier %d couldn't be found\n", ss);
		}
		return k;
}int main(){
    int solid, ss
    printf("Give the identifier solid and ss: \n");
    scanf("%d %d", &solid, &ss);
    Beginning(solid, ss);
    while(StarS[k].plasy != NULL){
            printf(" %d ", StarS[k].plasy->solid);
            StarS[k].plasy=StarS[k].plasy->next;
    }
    return 0;
}

Do we have to create a new node at the function Beginning, for the element that should be added?? (Wondering)

 

[I like Serena]

The function Beginning should print the identifiers of the planetary systems:
$<solid_1>, <solid_2>, \dots , <solid_n>$
where $n$ is the number of planetary systems that exist in the star system with identifier "ss" and for each $i$, $1 \leq i \leq n$, $<solid_i>$ is the identifier of the $i-$th planetary system in the star system.

int k = -1;

int Beginning(int solid, int ss){
		int i;

        // Add a planetary system to the list of the planetary system of the star system
        plansys_t *plansystem = calloc(1, sizeof(plansys_t));
        plansystem->solid=solid;
        plansystem->asteroids=NULL;
        plansystem->next=NULL;
		for(i=0; i<nrStarS; i++){
			if(StarS[i].ss=ss){
				k=i;
				StarS[k].plasy=plansystem;
			}
		}
		if(k==-1){
			printf("The star system with identifier %d couldn't be found\n", ss);
		}
		return k;
}int main(){
    int solid, ss
    printf("Give the identifier solid and ss: \n");
    scanf("%d %d", &solid, &ss);
    Beginning(solid, ss);
    while(StarS[k].plasy != NULL){
            printf(" %d ", StarS[k].plasy->solid);
            StarS[k].plasy=StarS[k].plasy->next;
    }
    return 0;
}

Do we have to create a new node at the function Beginning, for the element that should be added?? (Wondering)

Huh? Currently you are executing [m]StarS[k].plasy=plansystem;[/m].
If [m]StarS[k].plasy[/m] already contained planets, those will become inaccessible after the assignment. (Wasntme)

 

[mathmari]

Huh? Currently you are executing [m]StarS[k].plasy=plansystem;[/m].
If [m]StarS[k].plasy[/m] already contained planets, those will become inaccessible after the assignment. (Wasntme)

So is the for loop as followed?? (Wondering)

for(i=0; i<nrStarS; i++){
	if(StarS[i].ss==ss){
	      k=i;
	      while(StarS[k].plasy != NULL){
		      StarS[k].plasy=StarS[k].plasy->next;
	      }
	      StarS[k].plasy=plansystem;
         }
}

 

[I like Serena]

So is the for loop as followed?? (Wondering)

for(i=0; i<nrStarS; i++){
	if(StarS[i].ss==ss){
	      k=i;
	      while(StarS[k].plasy != NULL){
		      StarS[k].plasy=StarS[k].plasy->next;
	      }
	      StarS[k].plasy=plansystem;
         }
}

Let's see... suppose we initially have 2 planets. Something like:

$$plasy \to \boxed{solid_1} \to \boxed{solid_2}\to NULL$$
After the first execution of [m]StarS[k].plasy=StarS[k].plasy->next;[/m], we have:
\begin{array}{}
&plasy&&plansystem\\
&\downarrow &&\downarrow\\
\boxed{solid_1} \to &{\boxed{solid_2}}\to & NULL \quad & {\boxed{solid_{new}}}\to NULL
\end{array}

But... but... now ${solid}_1$ is not accessible any more.
That can't be right! (Worried)

We will finally have:
\begin{array}{}
&&&plasy\\
&&&\downarrow \\
\boxed{solid_1} \to &{\boxed{solid_2}}\to & NULL \quad & {\boxed{solid_{new}}}\to NULL
\end{array}

This is the same as previously!
The original list is not accessible anymore. (Worried)

 

[mathmari]

Let's see... suppose we initially have 2 planets. Something like:

$$plasy \to \boxed{solid_1} \to \boxed{solid_2}\to NULL$$
After the first execution of [m]StarS[k].plasy=StarS[k].plasy->next;[/m], we have:
\begin{array}{}
&plasy&&plansystem\\
&\downarrow &&\downarrow\\
\boxed{solid_1} \to &{\boxed{solid_2}}\to & NULL \quad & {\boxed{solid_{new}}}\to NULL
\end{array}

But... but... now ${solid}_1$ is not accessible any more.
That can't be right! (Worried)

We will finally have:
\begin{array}{}
&&&plasy\\
&&&\downarrow \\
\boxed{solid_1} \to &{\boxed{solid_2}}\to & NULL \quad & {\boxed{solid_{new}}}\to NULL
\end{array}

This is the same as previously!
The original list is not accessible anymore. (Worried)

We assign the value [m]plansystem[/m] to [m]StarS[k].plasy[/m] when [m]StarS[k].plasy==NULL[/m] or not?? (Wondering)

 

[I like Serena]

We assign the value [m]plansystem[/m] to [m]StarS[k].plasy[/m] when [m]StarS[k].plasy==NULL[/m] or not?? (Wondering)

If [m]StarS[k].plasy==NULL[/m], that is fine.
Otherwise we need to do something to properly insert [m]plansystem[/m] into the list. (Thinking)

 

[mathmari]

If [m]StarS[k].plasy==NULL[/m], that is fine.
Otherwise we need to do something to properly insert [m]plansystem[/m] into the list. (Thinking)

But doesn't the pointer plasy show always to NULL, after the while loop?? (Wondering)

 

[I like Serena]

But doesn't the pointer plasy show always to NULL, after the while loop?? (Wondering)

Yes it does.
However, plasy is always supposed to point the the first element in the list.
So you shouldn't change it to point to the last element. (Shake)Instead I suggest to either add the new plansystem to the beginning of the list, like this:

// Insert plansystem at the beginning of the list
plansystem->next = StarS[k].plasy;
StarS[k].plasy = plansystem;

Or add the new plansystem to the end of the list, like this:

if (StarS[k].plasy == NULL) {
    // List is empty: replace with new plansystem
    StarS[k].plasy = plansystem;
} else {
    // Find last node
    plansys_t *last = StarS[k].plasy;
    while (last->next != NULL) {
        last = last->next;
    }
    // Append new plansystem to the last node
    last->next = plansystem;
}

(Thinking)

 

[mathmari]

Yes it does.
However, plasy is always supposed to point the the first element in the list.
So you shouldn't change it to point to the last element. (Shake)Instead I suggest to either add the new plansystem to the beginning of the list, like this:

// Insert plansystem at the beginning of the list
plansystem->next = StarS[k].plasy;
StarS[k].plasy = plansystem;

Or add the new plansystem to the end of the list, like this:

if (StarS[k].plasy == NULL) {
    // List is empty: replace with new plansystem
    StarS[k].plasy = plansystem;
} else {
    // Find last node
    plansys_t *last = StarS[k].plasy;
    while (last->next != NULL) {
        last = last->next;
    }
    // Append new plansystem to the last node
    last->next = plansystem;
}

(Thinking)

I see... (Sun)

So that we print the identifiers "solid" which belong to a given star system "ss", do we return from the function Beginning the value of k ??

Then at the main do we write the following?? (Wondering)

printf("Give the identifier solid and ss: \n");
scanf("%d %d", &solid, &ss);
Beginning(solid, ss);
plansys_t *p = StarS[k].plasy;
while(p != NULL){
	printf(" %d ", p->solid);
	p=p->next;
}

 

[I like Serena]

I see... (Sun)

So that we print the identifiers "solid" which belong to a given star system "ss", do we return from the function Beginning the value of k ??

Then at the main do we write the following?? (Wondering)

printf("Give the identifier solid and ss: \n");
scanf("%d %d", &solid, &ss);
Beginning(solid, ss);
plansys_t *p = StarS[k].plasy;
while(p != NULL){
	printf(" %d ", p->solid);
	p=p->next;
}

That looks okay, although you should account for the possibility that the star system cannot be found.
Btw, didn't you forget to give $k$ a value? (Worried)

 

[mathmari]

That looks okay, although you should account for the possibility that the star system cannot be found.
Btw, didn't you forget to give $k$ a value? (Worried)

int k = -1;

int Beginning(int solid, int ss){
		int i;

        // Add a planetary system to the list of the planetary system of the star system
        plansys_t *plansystem = calloc(1, sizeof(plansys_t));
        
        plansystem->solid=solid;
        plansystem->asteroids=NULL;
        plansystem->next=NULL;
		for(i=0; i<nrStarS; i++){
			if(StarS[i].ss==ss){
				k=i;
				if (StarS[k].plasy == NULL) {
                     // List is empty: replace with new plansystem
                     StarS[k].plasy = plansystem;
                } else {
                    // Find last node
                    plansys_t *last = StarS[k].plasy;
                    while (last->next != NULL) {
                          last = last->next;
                    }
                    // Append new plansystem to the last node
                    last->next = plansystem;
               }
			}
		}
		if(k==-1){
			printf("The star system with identifier %d couldn't be found\n", ss);
		}
		return k;
}

int main(){
    int solid, ss;
    printf("Give the identifier solid and ss: \n");
    scanf("%d %d", &solid, &ss);
    Beginning(solid, ss);
    plansys_t *p = StarS[k].plasy;
    while(p != NULL){
	   printf(" %d ", p->solid);
	   p=p->next;
    }
    return 0;
}

At the function Beginning do we not account for the possibility that the star system cannot be found?? (Wondering)

By returning $k$ from the function Beginning doesn't it have the value at the main when calling the function?? (Wondering)

 

[I like Serena]

int k = -1;

int Beginning(int solid, int ss){
		int i;

        // Add a planetary system to the list of the planetary system of the star system
        plansys_t *plansystem = calloc(1, sizeof(plansys_t));
        
        plansystem->solid=solid;
        plansystem->asteroids=NULL;
        plansystem->next=NULL;
		for(i=0; i<nrStarS; i++){
			if(StarS[i].ss==ss){
				k=i;
				if (StarS[k].plasy == NULL) {
                     // List is empty: replace with new plansystem
                     StarS[k].plasy = plansystem;
                } else {
                    // Find last node
                    plansys_t *last = StarS[k].plasy;
                    while (last->next != NULL) {
                          last = last->next;
                    }
                    // Append new plansystem to the last node
                    last->next = plansystem;
               }
			}
		}
		if(k==-1){
			printf("The star system with identifier %d couldn't be found\n", ss);
		}
		return k;
}

int main(){
    int solid, ss;
    printf("Give the identifier solid and ss: \n");
    scanf("%d %d", &solid, &ss);
    Beginning(solid, ss);
    plansys_t *p = StarS[k].plasy;
    while(p != NULL){
	   printf(" %d ", p->solid);
	   p=p->next;
    }
    return 0;
}

At the function Beginning do we not account for the possibility that the star system cannot be found?? (Wondering)

By returning $k$ from the function Beginning doesn't it have the value at the main when calling the function?? (Wondering)

We account for it inside the function yes.
But when it fails, we have $k=-1$.
Then, in the main() function the StarS[] array still gets indexed with $k=-1$, which will result in a bit of madness and chaos. (Worried)Btw, it is bad programming style to keep the $k$ outside the function in the global namespace. It is better to declare it inside the function, and when you call the function keep track of the value that the function returned. (Nerd)