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

[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)

 

[mathmari]

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)

So, we could write the following if in the main() function, after calling the function, instead of writing it in the function Beginning, right?? (Wondering)

if(k==-1){
	printf("The star system with identifier %d couldn't be found\n", ss);
}

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)

Ok, I changed it! (Yes)

Now it works! (Happy)

 

[mathmari]

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;
}

Should I declare the variable [m]nrStarS [/m] also inside the function Constitution?? (Wondering)

 

[I like Serena]

So, we could write the following if in the main() function, after calling the function, instead of writing it in the function Beginning, right?? (Wondering)

if(k==-1){
	printf("The star system with identifier %d couldn't be found\n", ss);
}

Yes. (Nod)

Ok, I changed it! (Yes)

Now it works! (Happy)

Good! (Smile)

Should I declare the variable [m]nrStarS [/m] also inside the function Constitution?? (Wondering)

No.
[m]nrStarS[/m] tracks a global state, together with the StarS[] array.
It is appropriate that it is global. (Nerd)

 

[mathmari]

No.
[m]nrStarS[/m] tracks a global state, together with the StarS[] array.
It is appropriate that it is global. (Nerd)

Ahaaa... I see... (Star)Then I have to write also an other function for the constitution of an asteroid with identifier "as" at the planetary system "solid".
"gap" is the gap between the new asteroid and the object.
The new asteroid should be added in the appropriate position, in respect of the "gap", in the list of asteroids.
The field gap, that corresponds to the new asteroid, contains the gap from the previous asteroid in the list of asteroids and not the gap from the object.

I have done the following:

int asteroid_constitution(int as, int gap, int solid){
	int i, g=0;
	asteroid_t *ast = calloc(1, sizeof(asteroid_t));
	ast->as=as;
	ast->gap=gap;
	ast->prev=NULL;
	ast->next=NULL;
	plansys_t *p=StarS[0].plasy;;
	for(i=0; i<Sfreep; i++){
		p=StarS[i].plasy;
		while(p->solid != solid){
			p=p->next;
		}
	}
	if (p->asteroids==NULL){
		p->asteroids=ast;
	}
	else{
		asteroid_t *last=p->asteroids;
		asteroid_t *q=p->asteroids;
		g=g+ast->gap;
		while(g<ast->gap){
			last=last->next;
		}
		ast->next=last->next;
		ast->prev=last;
		last->next=ast;
		ast->gap=ast->gap-g;
		q=ast->next;
		q->gap=q->gap-ast->gap;		
	}
	return 0;
}

Is this correct?? (Wondering)

 

[I like Serena]

Ahaaa... I see... (Star)Then I have to write also an other function for the constitution of an asteroid with identifier "as" at the planetary system "solid".
"gap" is the gap between the new asteroid and the object.
The new asteroid should be added in the appropriate position, in respect of the "gap", in the list of asteroids.
The field gap, that corresponds to the new asteroid, contains the gap from the previous asteroid in the list of asteroids and not the gap from the object.

I have done the following:

int asteroid_constitution(int as, int gap, int solid){
	int i, g=0;
	asteroid_t *ast = calloc(1, sizeof(asteroid_t));
	ast->as=as;
	ast->gap=gap;
	ast->prev=NULL;
	ast->next=NULL;
	plansys_t *p=StarS[0].plasy;;
	for(i=0; i<Sfreep; i++){
		p=StarS[i].plasy;
		while(p->solid != solid){
			p=p->next;
		}
	}
	if (p->asteroids==NULL){
		p->asteroids=ast;
	}
	else{
		asteroid_t *last=p->asteroids;
		asteroid_t *q=p->asteroids;
		g=g+ast->gap;
		while(g<ast->gap){
			last=last->next;
		}
		ast->next=last->next;
		ast->prev=last;
		last->next=ast;
		ast->gap=ast->gap-g;
		q=ast->next;
		q->gap=q->gap-ast->gap;		
	}
	return 0;
}

Is this correct?? (Wondering)

What is [m]Sfreep[/m]? (Wondering)

What if [m]q[/m] is NULL? (Wondering)

Shouldn't the asteroid after the new one have its [m]prev[/m] updated? (Wondering)

 

[mathmari]

What is [m]Sfreep[/m]? (Wondering)

[m]Sfreep[/m] should be replaced with [m]nrStarS[/m] (Blush)

What if [m]q[/m] is NULL? (Wondering)

We have initialized [m]q[/m] as followed

[m]asteroid_t *q=p->asteroids;[/m]

right?? (Wondering)

In the else statement [m]p[/m] is not NULL. So, can [m]q[/m] be NULL ?? (Wondering)

Shouldn't the asteroid after the new one have its [m]prev[/m] updated? (Wondering)

Could I maybe do it as followed?? (Wondering)

ast->next=last->next;
last->next->prev=ast;
ast->prev=last;
last->next=ast;
ast->gap=ast->gap-g;
q=ast->next;
q->gap=q->gap-ast->gap;

 

[I like Serena]

[m]Sfreep[/m] should be replaced with [m]nrStarS[/m] (Blush)

We have initialized [m]q[/m] as followed

[m]asteroid_t *q=p->asteroids;[/m]

right?? (Wondering)

That is at first, but you never use it like that.
So you might as well not initialize it, or initialize it to NULL. (Nerd)

In the else statement [m]p[/m] is not NULL. So, can [m]q[/m] be NULL ?? (Wondering)

When you do give [m]q[/m] a value in [m]q=ast->next[/m], it can be NULL. (Shake)

Could I maybe do it as followed?? (Wondering)

ast->next=last->next;
last->next->prev=ast;

In principle, yes, but what if [m]last->next[/m] is NULL? (Wondering)

q=ast->next;
q->gap=q->gap-ast->gap;

What if [m]q[/m] becomes NULL here?
Then you are following a NULL pointer to madness and chaos! (Evilgrin)

 

[mathmari]

That is at first, but you never use it like that.
So you might as well not initialize it, or initialize it to NULL. (Nerd)When you do give [m]q[/m] a value in [m]q=ast->next[/m], it can be NULL. (Shake)

In principle, yes, but what if [m]last->next[/m] is NULL? (Wondering)
What if [m]q[/m] becomes NULL here?
Then you are following a NULL pointer to madness and chaos! (Evilgrin)

So, should we add the condition [m]last->next!=NULL[/m] in the while?? (Wondering)

asteroid_t *last=p->asteroids;
asteroid_t *q=NULL;
g=g+ast->gap;
while(g<ast->gap && last->next!=NULL){
	last=last->next;
}
ast->next=last->next;
ast->prev=last;
last->next=ast;
ast->gap=ast->gap-g;
q=ast->next;
q->gap=q->gap-ast->gap;

 

[I like Serena]

So, should we add the condition [m]last->next!=NULL[/m] in the while?? (Wondering)

asteroid_t *last=p->asteroids;
asteroid_t *q=NULL;
g=g+ast->gap;
while(g<ast->gap && last->next!=NULL){
	last=last->next;
}
ast->next=last->next;
ast->prev=last;
last->next=ast;
ast->gap=ast->gap-g;
q=ast->next;
q->gap=q->gap-ast->gap;

No. (Shake)
We should distinguish 2 cases with an [m]if[/m], or actually 4.
It can be that "ast" has to be inserted before the first element of the list, and it can also be that "ast" has to be appended after the last element of the list.
These cases require special handling. (Sweating)

 

[mathmari]

No. (Shake)
We should distinguish 2 cases with an [m]if[/m], or actually 4.
It can be that "ast" has to be inserted before the first element of the list, and it can also be that "ast" has to be appended after the last element of the list.
These cases require special handling. (Sweating)

I added the case where "ast" has to be inserted before the first element of the list and the case where "ast" has to be appended after the last element of the list.

                asteroid_t *last=p->asteroids;	
	        asteroid_t *q=NULL;
		if(ast->gap<last->gap){
			ast->prev=NULL;
			ast->next=last;
			last->prev=ast;
			last->gap=last->gap-ast->gap;
		}
		g=g+ast->gap;
		while(g<ast->gap && last != NULL){
			last=last->next;
		}
		if(last != NULL && last->next==NULL){
			ast->prev=last;
			ast->next=NULL;
			last->next=ast;
		}
		else{
			ast->next=last->next;
			ast->prev=last;
			last->next=ast;
			ast->gap=ast->gap-g;
			q=ast->next;
			q->gap=q->gap-ast->gap;	
	    }

Is it correct?? (Wondering)

 

[I like Serena]

		else{
			ast->next=last->next;
			ast->prev=last;
			last->next=ast;
			ast->gap=ast->gap-g;
			q=ast->next;
			q->gap=q->gap-ast->gap;	
	    }

Is it correct?? (Wondering)

Almost there! (Smile)

In the regular case, 4 connections need to be made (2 next, 2 prev).
I only see 3 connections. (Wasntme)

 

[mathmari]

Almost there! (Smile)

In the regular case, 4 connections need to be made (2 next, 2 prev).
I only see 3 connections. (Wasntme)

Do I have to add [m]last->next->prev=ast[/m] ?? (Wondering)

I made some more changes at the else-statement.

    else{
                asteroid_t *last=p->asteroids;
                asteroid_t *q=NULL;
                asteroid_t *previous=NULL;
                if(ast->gap<last->gap){
                        ast->prev=NULL;
                        ast->next=last;
                        last->prev=ast;
                        last->gap=last->gap-ast->gap;
                }
                else{
                while(g < ast->gap && last != NULL && last->next != NULL){
	                	g=g+last->gap;
	                	previous=last;
                                last=last->next;
                }
                if(last != NULL && last->next==NULL){
                        ast->prev=last;
                        ast->next=NULL;
                        last->next=ast;
                        ast->gap=ast->gap-g;
                }
                else if(last == NULL){
	                	previous->next=ast;
	                	ast->prev=previous;
	                	ast->next=NULL;
	                	ast->gap = ast->gap - previous->gap;
                }    
                else{
                        ast->next=last->next;
                        last->next->prev=ast;
                        ast->prev=last;
                        last->next=ast;
                        ast->gap=ast->gap-g;
                        q=ast->next;
                        q->gap=q->gap-ast->gap;
            }
        }
    }

When I add the first asteroid ( for example "as"=1, "gap"=10 ) it prints the correct gap.

When I add then a second asteroid ( for example "as"=2, "gap"=25 ) it prints as the gap 25, which is the gap between the asteroid "as"=2 and the object "solid"=101 but it should print the gap between this asteroid "as"=2 and the previous one of the list, which is "as"=1.

Have I done something wrong at the calculation of the gap?? (Wondering)

 

[mathmari]

I changed the while and now it prints 15, which is the gap between the "as"=1 ans the "as"=2 instead of 25!

while(g < ast->gap && last->next != NULL){
	                g=g+last->gap;
                        last=last->next;
                }
                g=g+last->gap;

(Happy)

 

[I like Serena]

Do I have to add [m]last->next->prev=ast[/m] ?? (Wondering)

Yes.
And I see you did! (Smile)

When I add the first asteroid ( for example "as"=1, "gap"=10 ) it prints the correct gap.

When I add then a second asteroid ( for example "as"=2, "gap"=25 ) it prints as the gap 25, which is the gap between the asteroid "as"=2 and the object "solid"=101 but it should print the gap between this asteroid "as"=2 and the previous one of the list, which is "as"=1.

Have I done something wrong at the calculation of the gap?? (Wondering)

I changed the while and now it prints 15, which is the gap between the "as"=1 ans the "as"=2 instead of 25!

while(g < ast->gap && last->next != NULL){
	                g=g+last->gap;
                        last=last->next;
                }
                g=g+last->gap;

(Happy)

So your gap calculations are okay now? (Wondering)

 

[mathmari]

So your gap calculations are okay now? (Wondering)

Yes! (Yes)(Happy)Now I have to write also an other function. (Nerd)

I have to write a function for the destruction of the planetary system "solid".
With the destruction of the planetary system, the asteroids where the gap between this one and the object, is at least "gap" will also be destructed. (so, they have to be deleted) The asteroids for which the gap is greater are converted to free-floating planets consisting a new collection of free-floating planets (ffplan_t). This new collection should be added to the array of the free-floating planets of the star system to which the planetary system, that is destructed, belonged. The identifier "fp" of the new collection is the identifier of the planetary system that is destructed. The list of the free-floating planets that corresponds to the new collection should be sorted as for the field "as" of the asteroids that are contained. The destructed planetary system should be deleted from the list of planetary systems of the star system to which it belonged.I have done the following:

int destruction(int solid, int gap){
	int sum=0;
	plansys_t *p=StarS[0].plasy;;
	for(i=0; i<nrStarS; i++){
		p=StarS[i].plasy;
		while (p != NULL && p->solid != solid){
			p=p->next;
		}
	}
	if(p == NULL){
		printf("The planetary system with identifier %d couldn't be found\n", solid);
	}
	asteroid_t *f=p->asteroids;
	while(sum<gap){
		sum=sum+f->gap;
		DELETE(f, as);
		f=f->next;
	}
	
	

	return 0;
}

where the function DELETE() is the following:

void DELETE(*pointer, int x){
	while(pointer != NULL && pointer->data != x)
		pointer=pointer->next;
	if(pointer == NULL)
		printf("Element %d is not present in the list\n", d);
	if(pointer->prev == NULL && pointer->next != NULL){
		(pointer->next).prev=NULL;
	}
	if(pointer->prev == NULL && pointer->next==NULL){
		pointer=NULL;
	}
	if(pointer->prev != NULL && pointer->next==NULL){
		(pointer->prev).next=NULL;
	}
	else{
		(pointer->prev).next=pointer.next;
		(pointer->next).prev=pointer.prev;
	}
}

Is it correct so far?? (Wondering)

The asteroids for which the gap is greater that "gap" are converted to free-floating planets consisting a new collection of free-floating planets (ffplan_t).

What am I supposed to do at this step?? (Wondering) I got stuck right now...

 

[mathmari]

The asteroids for which the gap is greater that "gap" are converted to free-floating planets consisting a new collection of free-floating planets (ffplan_t).

Does this mean that I have to insert these asteroids to the list of the free-floating planets?? (Wondering)

 

[I like Serena]

void DELETE(*pointer, int x){
	while(pointer != NULL && pointer->data != x)
		pointer=pointer->next;
	if(pointer == NULL)
		printf("Element %d is not present in the list\n", d);
	if(pointer->prev == NULL && pointer->next != NULL){
		(pointer->next).prev=NULL;
	}
	if(pointer->prev == NULL && pointer->next==NULL){
		pointer=NULL;
	}
	if(pointer->prev != NULL && pointer->next==NULL){
		(pointer->prev).next=NULL;
	}
	else{
		(pointer->prev).next=pointer.next;
		(pointer->next).prev=pointer.prev;
	}
}

Is it correct so far?? (Wondering)

That looks a bit complicated, and the memory allocated for the pointer (with calloc) is not actually freed.

How about:

void DELETE(asteroid_t *pointer, int x){
	while(pointer != NULL && pointer->data != x) {
		pointer=pointer->next;
        }
	if(pointer == NULL) {
		printf("Element %d is not present in the list\n", d);
		return;
        } 
	if(pointer->next != NULL){
		pointer->next->prev=pointer->prev;
	}
	if(pointer->prev != NULL){
		pointer->prev->next = pointer->next;
	}
        free(pointer);
}

(Wondering)

Does this mean that I have to insert these asteroids to the list of the free-floating planets?? (Wondering)

That appears to be the case. (Wink)

 

[mathmari]

That looks a bit complicated, and the memory allocated for the pointer (with calloc) is not actually freed.

How about:

void DELETE(asteroid_t *pointer, int x){
	while(pointer != NULL && pointer->data != x) {
		pointer=pointer->next;
        }
	if(pointer == NULL) {
		printf("Element %d is not present in the list\n", d);
		return;
        } 
	if(pointer->next != NULL){
		pointer->next->prev=pointer->prev;
	}
	if(pointer->prev != NULL){
		pointer->prev->next = pointer->next;
	}
        free(pointer);
}

(Wondering)

I see! (Nerd)

That appears to be the case. (Wink)

The asteroids for which the gap is greater are converted to free-floating planets consisting a new collection of free-floating planets (ffplan_t). This new collection should be added to the array of the free-floating planets of the star system to which the planetary system, that is destructed, belonged. The identifier "fp" of the new collection is the identifier of the planetary system that is destructed. The list of the free-floating planets that corresponds to the new collection should be sorted as for the field "as" of the asteroids that are contained. The field "gap" of the new list should have the value 0

I tried to insert the asteroids, for which the gap is greater than "gap", to the list of the free-floating planets as followed:

ffplan_t *fplan=NULL;
	if(f != NULL){
		fplan->fp=solid;
	}
	asteroid_t *planf = calloc(1, sizeof(asteroid_t));
	planf->as=f->as;
	planf->gap=0;
	planf->next=NULL;
	planf->prev=NULL;
	asteroids *K=fplan->ff;
	f-f->next;
	while(f != NULL){
		if (K == NULL) {
        	K = planf;
        } else {
        	asteroid_t *last = K;
        	while (last->next != NULL) {
        		last = last->next;
        	}
        	last->next = planf;
       	}              
		f=f->next;
	}

Is it correct so far?? (Wondering)

 

[mathmari]

At the following part there must be an error, since I get a segmentation fault, but when I make this part into comments, I don't get any more...

ffplan_t *fplan=NULL;
	if(f != NULL){
		fplan->fp=solid;
	}
	asteroid_t *planf = calloc(1, sizeof(asteroid_t));
	planf->as=f->as;
	planf->gap=0;
	planf->next=NULL;
	planf->prev=NULL;
	asteroid_t *K=fplan->ff;
	f-f->next;
	while(f != NULL){
		if (K == NULL) {
        	K = planf;
        } else {
        	asteroid_t *last = K;
        	while (last->next != NULL) {
        		last = last->next;
        	}
        	last->next = planf;
       	}              
		f=f->next;
	}

Could you tell me what I have done wrong?? (Wondering)

 

[I like Serena]

At the following part there must be an error, since I get a segmentation fault, but when I make this part into comments, I don't get any more...

ffplan_t *fplan=NULL;
	if(f != NULL){
		fplan->fp=solid;
	}
	asteroid_t *planf = calloc(1, sizeof(asteroid_t));
	planf->as=f->as;
	planf->gap=0;
	planf->next=NULL;
	planf->prev=NULL;
	asteroid_t *K=fplan->ff;
	f-f->next;
	while(f != NULL){
		if (K == NULL) {
        	K = planf;
        } else {
        	asteroid_t *last = K;
        	while (last->next != NULL) {
        		last = last->next;
        	}
        	last->next = planf;
       	}              
		f=f->next;
	}

Could you tell me what I have done wrong?? (Wondering)

Well...
You write

ffplan_t *fplan=NULL;
	if(f != NULL){
		fplan->fp=solid;
	}

Now I'm not sure what "fplan" and "f" are representing.
Perhaps you can clarify? (Wondering)

Either way, if [m]f != NULL[/m], then the code code assigns "solid" to [m]fplan->fp[/m]... but at this point [m]fplan[/m] is NULL.
So that would give a segmentation fault. (Crying)

 

[mathmari]

Well...
You write

ffplan_t *fplan=NULL;
	if(f != NULL){
		fplan->fp=solid;
	}

Now I'm not sure what "fplan" and "f" are representing.
Perhaps you can clarify? (Wondering)

"f" is a pointer that points to the list p->asteroids

[m]asteroid_t *f=p->asteroids;[/m]

The asteroids for which the gap is greater are converted to free-floating planets consisting a new collection of free-floating planets (ffplan_t). This new collection should be added to the array of the free-floating planets of the star system to which the planetary system, that is destructed, belonged. The identifier "fp" of the new collection is the identifier of the planetary system that is destructed.

We want to add the asteroids, where the "gap" is greater than gap, to the list of free-floating planets.
That's why I used the pointer "fplan". (Tmi)

Either way, if [m]f != NULL[/m], then the code code assigns "solid" to [m]fplan->fp[/m]... but at this point [m]fplan[/m] is NULL.
So that would give a segmentation fault. (Crying)

How can I insert these asteroids to the list of free-floating planets?? (Wondering)

 

[mathmari]

The structures have the following form:

View attachment 3540

 

[mathmari]

It should be: [m]starsystem->plasy=starsystem->Sentinel;[/m].

I am looking again at the program and I have a question... (Nerd)

int Initialization() {
	int i;
	for(i=0; i<N; i++){
		StarS[i].ss=INT_MAX;
		StarS[i].plasy=NULL;
		StarS[i].ffplan[i].fp=INT_MAX;
		StarS[i].ffplan[i].ff=NULL;
		StarS[i].Sentinel=NULL;
	}
	return 0;
}
int Constitution(int ss) {
1.        int i;
2.        starsy_t *starsystem;
        
3.        if(Sfreep<N){
4.        	starsystem = &StarS[Sfreep];
5.        	Sfreep++;
6.		}
		
7.		if(Sfreep>=N){
8.			return -1;
9.		}
        
10.        starsystem->ss = ss;
11.        starsystem->plasy=starsystem->Sentinel;
12.	for(i=0; i<max; i++){
13.		starsystem->ffplan[i].fp=INT_MAX;
14.		starsystem->ffplan[i].ff=NULL;
15.	}
16.	return (Sfreep - 1);
17.}

At the line 11 of the function Constitution() we set [m]starsystem->plasy=starsystem->Sentinel;[/m] but at the function Initialization() we set [m]StarS.Sentinel=NULL;[/m].

Should we maybe change the value of [m]starsystem->Sentinel[/m] in the function Constitution()?? (Wondering)
Because in that way we set [m]starsystem->plasy[/m] to [m]NULL[/m].

 

[I like Serena]

I am looking again at the program and I have a question... (Nerd)

int Initialization() {
		StarS[i].ffplan[i].fp=INT_MAX;
		StarS[i].ffplan[i].ff=NULL;
}

Let's start with this. (Worried)
There should be a nested loop to iterate over [m]ffplan[/m], for instance with the index [m]j[/m].
Otherwise, we're not initializing everything, and moreover, we'll likely get an access violation. (Devil)

int Constitution(int ss) {
11.        starsystem->plasy=starsystem->Sentinel;
17.}

At the line 11 of the function Constitution() we set [m]starsystem->plasy=starsystem->Sentinel;[/m] but at the function Initialization() we set [m]StarS.Sentinel=NULL;[/m].

Should we maybe change the value of [m]starsystem->Sentinel[/m] in the function Constitution()?? (Wondering)
Because in that way we set [m]starsystem->plasy[/m] to [m]NULL[/m].

Yep.
The [m]Sentinel[/m] is handled the wrong way. (Worried)
It is supposed to be a pointer to the last element in the list, which initially does not exist.

We should set both [m]plasy[/m] and [m]Sentinel[/m] to [m]NULL[/m] (or leave them as NULL). (Wasntme)

 

[mathmari]

Let's start with this. (Worried)
There should be a nested loop to iterate over [m]ffplan[/m], for instance with the index [m]j[/m].
Otherwise, we're not initializing everything, and moreover, we'll likely get an access violation. (Devil)

You're right! (Tmi)

So, is it as followed??

int Initialization() {
	int i, j;
	for(i=0; i<N; i++){
		StarS[i].ss=INT_MAX;
		StarS[i].plasy=NULL;
		for(j=0; j<max; j++){
			StarS[i].ffplan[i].fp=INT_MAX;
			StarS[i].ffplan[i].ff=NULL;
		}
		StarS[i].Sentinel=NULL;
	}
	return 0;
}

(Wondering)

Yep.
The [m]Sentinel[/m] is handled the wrong way. (Worried)
It is supposed to be a pointer to the last element in the list, which initially does not exist.

We should set both [m]plasy[/m] and [m]Sentinel[/m] to [m]NULL[/m] (or leave them as NULL). (Wasntme)

Should it be as followed?? (Wondering)

int Constitution(int ss) {
        int i;
        starsy_t *starsystem;
        
        if(Sfreep<N){
        	starsystem = &StarS[Sfreep];
        	Sfreep++;
		}
		
		if(Sfreep>=N){
			return -1;
		}
        
        starsystem->ss = ss;
        starsystem->plasy=NULL;
        starsystem->Sentinel=NULL;
	for(i=0; i<max; i++){
		starsystem->ffplan[i].fp=INT_MAX;
		starsystem->ffplan[i].ff=NULL;
	}
	return (Sfreep - 1);
}

At which point do we change its value so that it points to the last element in the list?? (Wondering)

 

[I like Serena]

You're right! (Tmi)

So, is it as followed?? (Wondering)

Yep! Much better! (Happy)

Should it be as followed?? (Wondering)

Yep! (Wink)

At which point do we change its value so that it points to the last element in the list?? (Wondering)

Whenever we add an element, or remove an element, we need to take into account that [m]plasy[/m], [m]Sentinal[/m], or both need to be updated. (Sweating)

 

[mathmari]

Whenever we add an element, or remove an element, we need to take into account that [m]plasy[/m], [m]Sentinal[/m], or both need to be updated. (Sweating)

Do you mean for example at the following function??

int Beginning(int solid, int ss){
		int i, k=-1;
        /* 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<Sfreep; 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;
                    /* last->next->next=last; */
               }
               StarS[k].Sentinel=StarS[k].plasy;
			}
		}
		return k;
}

(Wondering)

 

[I like Serena]

int Beginning(int solid, int ss){
    ...
			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;
                    /* last->next->next=last; */
               }
               StarS[k].Sentinel=StarS[k].plasy;
			}

Almost... (Thinking)

Now you are always setting the Sentinal to the first node, but it should be the last node. (Wasntme)

Hmm, it would help if there were some consistency to the indentation... (Wink)

 

[mathmari]

Almost... (Thinking)

Now you are always setting the Sentinal to the first node, but it should be the last node. (Wasntme)

Is it maybe as followed??

int Beginning(int solid, int ss){
		int i, k=-1;
        /* 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<Sfreep; i++){
			if(StarS[i].ss==ss){
				k=i;
				if (StarS[k].plasy == NULL) {
                     /* List is empty: replace with new plansystem */
                     StarS[k].plasy = plansystem;
                     StarS[k].Sentinel=StarS[k].plasy;
                } 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;
                    last->next->Sentinel=last;
               }
			}
		}
		return k;
}

(Wondering)

Hmm, it would help if there were some consistency to the indentation... (Wink)

What do you mean?? (Wondering)

 

[I like Serena]

Is it maybe as followed?? (Wondering)

The first is correct! (Smile)

But the second is not. (Worried)
Sentinal is a data member of StarS[k], and not of last->next.
You should set StarS[k].Sentinal to last->next, which is by now the same as plansystem.Alternatively, you could do at the end: [m]StarS[k].Sentinal = plansystem[/m].
That works because [m]plansystem[/m] is always added to the end, wherever that is. So afterwards it is the last node in the list, which is where [m]Sentinal[/m] should point. (Nerd)

What do you mean?? (Wondering)

The way the code is indented, it is hard to follow the flow of the program, and understand if and where something is wrong and should be changed. (Sweating)

Better is:

int Beginning(int solid, int ss){
    int i, k = -1;
    /* 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<Sfreep; i++){
        if(StarS[i].ss == ss){
            k=i;
            if (StarS[k].plasy == NULL) {
                /* List is empty: replace with new plansystem */
                StarS[k].plasy = plansystem;
                StarS[k].Sentinel = StarS[k].plasy;
            } 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;
                last->next->Sentinel = last;
            }
        }
    }
    return k;
}

Like this it becomes clear where the for-loop starts and ends, where the first if-statement is, and where the nested if-else statement is (and that there is one). (Whew)

 

[mathmari]

The first is correct! (Smile)

But the second is not. (Worried)
Sentinal is a data member of StarS[k], and not of last->next.
You should set StarS[k].Sentinal to last->next, which is by now the same as plansystem.Alternatively, you could do at the end: [m]StarS[k].Sentinal = plansystem[/m].
That works because [m]plansystem[/m] is always added to the end, wherever that is. So afterwards it is the last node in the list, which is where [m]Sentinal[/m] should point. (Nerd)

Do you mean that we could write it as followed??

int Beginning(int solid, int ss){
        int i, k=-1;
        /* 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<Sfreep; 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;
                        }
                        StarS[k].Sentinal = plansystem;
                }
        }
	return k;
}

(Wondering)

The way the code is indented, it is hard to follow the flow of the program, and understand if and where something is wrong and should be changed. (Sweating)

Better is:

int Beginning(int solid, int ss){
    int i, k = -1;
    /* 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<Sfreep; i++){
        if(StarS[i].ss == ss){
            k=i;
            if (StarS[k].plasy == NULL) {
                /* List is empty: replace with new plansystem */
                StarS[k].plasy = plansystem;
                StarS[k].Sentinel = StarS[k].plasy;
            } 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;
                last->next->Sentinel = last;
            }
        }
    }
    return k;
}

Like this it becomes clear where the for-loop starts and ends, where the first if-statement is, and where the nested if-else statement is (and that there is one). (Whew)

Ok! (Blush)

 

[I like Serena]

Do you mean that we could write it as followed?? (Wondering)

Yep! (Nod)

 

[mathmari]

The structures have the following form:

View attachment 3540

I am looking again at the program and I got stuck...

asteroid_t *p=StarS[k].plasy->asteroids;
while(p != NULL && p->as != as){
		p=p->next;
}
if(p != NULL && p->as == as){
		k=i;				
}

After [m]p=p->next;[/m] where does [m]p[/m] point?? At the next node of the planetary system, plasy, or the next asteroid?? (Wondering)

 

[I like Serena]

Hey!

After [m]p=p->next;[/m] where does [m]p[/m] point?? At the next node of the planetary system, plasy, or the next asteroid?? (Wondering)

asteroid_t *p=StarS[k].plasy->asteroids;

After the initial assignment, [m]p[/m] points to the first asteroid of the first planetary system of star system [m]k[/m].

while(p != NULL && p->as != as){
		p=p->next;
}

After p=p->next, p points to the next asteroid of the first planetary system. (Nerd)

 

[mathmari]

Ok! (Malthe)

To find the asteroid with identifier "as" in the star system I had written the following part:

	int i, k=-1;
	asteroid_t *p=NULL;
	asteroid_t *ast=NULL;
	for(i=0; i<Sfreep; i++){
			ast=StarS[i].plasy->asteroids;
			while(ast != NULL && ast->as != as){
				ast=ast->next;
			}
			if(ast != NULL && ast->as == as){
				k=i;				
			}
	}

	if(k == -1){
		return -1;
	}
		
	p=StarS[k].plasy->asteroids;
	
	if(p == NULL){
		return -1;
	}

But in this way do we not look only the asteroids of the first planetary system?? (Wondering)

Should it be as followed??

	for(i=0; i<Sfreep; i++){
                        Plan_Syst=StarS[i].plasy;
                        while(Plan_Syst != NULL){ 
                                ast=Plan_Syst->asteroids;
			        while(ast != NULL && ast->as != as){
				        ast=ast->next;
			        }
			        if(ast != NULL && ast->as == as){
				        k=i;	
                                        A=ast;			
			       }
                               Plan_Syst=Plan_Syst->next; 
	                }
        }
	if(k == -1){
		return -1;
	}
		
	p=A;
	
	if(p == NULL){
		return -1;
	}

(Wondering)

 

[I like Serena]

Ok! (Malthe)

But in this way do we not look only the asteroids of the first planetary system?? (Wondering)

Should it be as followed??

(Wondering)

Yep. To search all asteroids it should be like that. (Wasntme)

 

[mathmari]

Yep. To search all asteroids it should be like that. (Wasntme)

Ok! (Malthe) I have also an other question...

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=StarS[i].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(){
	Constitution(12);
	for(i=0; i<nrStarS; i++){
		printf("The elements are: %d \n", StarS[i].ss);
	}
	return 0;
}

Could you explain to me why we write [m]starsystem = &StarS[nrStarS];[/m] and not [m]&StarS[nrStarS]=starsystem[/m] ?? (Wondering)

 

[I like Serena]

Could you explain to me why we write [m]starsystem = &StarS[nrStarS];[/m] and not [m]&StarS[nrStarS]=starsystem[/m] ?? (Wondering)

The structure [m]StarS[nrStarS][/m] is an entry in a global array. Its address is fixed and cannot change. That means it makes no sense to try and assign anything to [m]&StarS[nrStarS][/m].

The pointer [m]starsystem[/m] is a helper variable. We let it point to the location of [m]StarS[nrStarS][/m], so that we can manipulate it more easily, and so that the code reads better. That's why we assign the address [m]&StarS[nrStarS][/m] to it. (Nerd)

 

[mathmari]

The structure [m]StarS[nrStarS][/m] is an entry in a global array. Its address is fixed and cannot change. That means it makes no sense to try and assign anything to [m]&StarS[nrStarS][/m].

The pointer [m]starsystem[/m] is a helper variable. We let it point to the location of [m]StarS[nrStarS][/m], so that we can manipulate it more easily, and so that the code reads better. That's why we assign the address [m]&StarS[nrStarS][/m] to it. (Nerd)

How can the array [m]StarS[/m] have the value of the new starsystem at the position nrStarS, when we assign the [m]&StarS[nrStarS][/m] to [m]starsystem[/m] ?? (Wondering)

[m]nrStarS[/m] is the first free position of the array, so if we assign [m]&StarS[nrStarS][/m] to the new [m]starsystem[/m] doesn't it get the value [m]NULL[/m] ?? (Wondering)