Algoritmo somma vettori sparsi

[cionci]

Giusto...qualsiasi algoritmo di ordinamento sulle coordinate va bene...

A questo punto anche la stampa è più semplice (non stampare gli elementi nulli)...

[xber-gigi]

ECCO FINITO!!!
Però mi da un mare di errori!!!
Non capisco di cosa si tratta! Potresti vedere tu ?!?!
Dice che cè un errore nelle variabili che ho usato per le procedure
ma non capisco cosa?!??!?
Il programma dovrebbe essere finito, dovrei solo aggiustare questi errori che non capisco cosa siano.
Cmq grazie mille per l'aiuto che mi stai dando!

SIAMO BROTHERS OF METAL!!!



#include <stdio.h>
#include <stdlib.h>
void sommavett (int *vett1[], int *vett2[], int *coordinate1[], int *coordinate2[], int *nonulli, int *n_risul);
void insertion_sort (int *a[],int *b);

/*-------------------------------------------------------------------------------------------------------------------*/
/*PROGRAMMA PRINCIPALE - la variabile n è la grandezza del vettore*/

void main ()
{
int vett1[1000], vett2[1000], coordinate1[1000], coordinate2[1000],risultato[1000], coordinater[1000];
int n,i,x,y,a,b,nonulli,n_risul, numero_cas;
printf ("Indicare la grandezza dei vettori: ");
scanf ("%d",&n);

/* CALCOLO DEL 5% DELLA GRANDEZZA DEL VETTORE*/

nonulli = (n * 5) /100;

/*GENERAZIONE DEI VALORI DEL VETTORE*/

for (i=0;i<nonulli;i++)
{
vett1[i]=1+rand()%10;
}

/*GENERAZIONE DELLE COORDINATE PRIMO VETTORE*/

for (i=0;i<nonulli;i++)
{
do
{
numero_cas = rand()%n;
y=-1;
x=0;

do
{
y=y+1;
}
while (coordinate1[y]!=numero_cas || y==nonulli);

if (coordinate1[y] == numero_cas)
{
x=1;
}
}
while (x==1);
coordinate1[i] = numero_cas;
}

/*GENERAZIONE DELLE COORDINATE SECONDO VETTORE*/


for (i=0;i<nonulli;i++)
{
do
{
numero_cas = rand()%n;
y=-1;
x=0;

do
{
y=y+1 ;
}
while (coordinate2[y]!=numero_cas || y==nonulli);

if (coordinate2[y] == numero_cas)
{
x=1;
}
}
while (x==1);
coordinate2[i] = numero_cas;
}



insertion_sort (&coordinate1, &nonulli);
coordinate1 = a;
insertion_sort (&coordinate2, &nonulli);
coordinate2 = a;
insertion_sort (&coordinater, &n_risul);
coordinater = a;

sommavett (&vett1, &vett2, &coordinate1, &coordinate2, &nonulli, &risultato, &coordinater, &n_risul);

/*STAMPA VETTORE 1*/
for (i=0;i<n;i++)
{
vett1[i];
}

/*STAMPA VETTORE 2*/
for (i=0;i<n;i++)
{
vett2[i];
}

/*STAMPA RISULTATO*/
for (i=0;i<n_risul;i++)
{
risultato[i];
}



}





/*-------------------------------------------------------------------------------------------------------------------*/
/*PROCEDURA CALCOLO SOMMA VETTORI*/

void sommavett (int *vett1[], int *vett2[], int *coordinate1[], int *coordinate2[], int *nonulli, int *n_risul)
{

int i,k,y;
for (i=0;i<nonulli;i++)
{
risultato[i]=vett1[i];
coordinate1[i]=coordinater[i];
}
k=-1;
y=1;
for (i=0;i<nonulli;i++)
{
do
{
k=k+1;
}
while (coordinate2[k]==coordinater[k] || k==nonulli);
if (coordinate2[k]==coordinater[k])
{
risultato[k]=risultato[k]+vett2[k];
}
else
{
coordinater[nonulli+y]=coordinate2[k];
risultato[nonulli+y]=vett2[k];
y=y+1;
}
}
n_risul=nonulli+y;
}


/*-------------------------------------------------------------------------------------------------------------------*/
/*PROCEDURA ORDINAMENTO ARRAY COORDINATE*/

void insertion_sort (int *a[],int *b)
{
int i,j;
int el_da_ins;
for (i=1;i<b;i++)
{
el_da_ins=a[i];
j=i-1;
while (j>=0 && el_da_ins<a[j])
{
a[j+1]=a[j];
j=j-1;
}
a[j+1]=el_da_ins;
}
}

[cionci]

E' sbagliato il modo in cui generi le coordinate...
Il fatto che i vettori siano ordinati ti può permettere di usare un metodo molto più semplice per sommarli...

L'estrazione delle coordinate te la faccio io vai...però cerca di capirla...

Erano sbagliate tutte le dichiarazioni delle funzioni... Non devi passare i vettori per indirizzo... L'unico parametro che devi passare per indirizzo è n_risult...

Inoltre hai capito male come devi realizzare il vettore delle coordinate... Il vetore delle coordinate è un vettore compatto...

Quindi se ci sono 4 valori non nulli il vettore delle coordinate deve contenere solo 4 valori in sequenza...

[cionci]

Prova questo:

	popola_vettori(vett1, coordinate1, nonulli, n);
	popola_vettori(vett2, coordinate2, nonulli, n);

	/*STAMPA VETTORE 1*/
	for (i=0;i<nonulli;i++)
	{
		printf("vett[%d] = %d\n", coordinate1[i], vett1[i]);
	}
	
	for (i=0;i<nonulli;i++)
	{
		printf("vett[%d] = %d\n", coordinate2[i], vett2[i]);
	}

void popola_vettori(int vett[], int coord[], int nonnulli, int n)
{
	int i, x, j, k, tmp1, tmp2, tmp3, tmp4;
	/*INIZIALIZZO LE COORDINATE*/
	for(i=0; i<nonnulli; ++i)
		coord[i] = -1;
	
	/*GENERAZIONE DELLE COORDINATE E DEI VALORI DEL VETTORE*/

	for(i=0; i<nonnulli; ++i)
	{
		x = rand() % (n-i); /*la popolazione da cui estrarre diminuisce sempre*/
		/*equivale ad una estrazione senza reinbussolamento*/
		j=0;
		while(coord[j] <= x && coord[j] > -1)
		{
			x++; /*incremento x per evitare coord già estratte*/
			++j;
		}

		/*controllo se la posizione è già occupata*/
		/*in tal caso devo spostare a destra gli elementi restanti*/
		if(coord[j] != -1)
		{
			tmp1 = coord[j];
			tmp2 = vett[j];
			for(k=j+1; k<=i; ++k)
			{
				tmp3 = coord[k];
				tmp4 = vett[k];
				coord[k] = tmp1;
				vett[k] = tmp2;
				tmp1 = tmp3;
				tmp2 = tmp4;
			}
		}
		/*ora posso inserire il mio elemento*/
		coord[j] = x;
		vett[j] = 1 + rand() % 10; /*metto anche il dato nella posizione corrispondente*/
	}
}