Dev - C++ - estructura con arreglo dinamico + pila en c

   
Vista:

estructura con arreglo dinamico + pila en c

Publicado por Jeremias yojere1997@gmail.com (1 intervención) el 14/06/2017 02:10:48
este es el programa que debo hacer.

ejemplo de examen: se desea crear un arreglo dinamico de enteros
el tamaño y los elementos se toman del teclado. se pide crear con ellos
una pila dinamica, recorrerlo y mostrar su contenido en pantalla.

como se hace para declarar en un struct un arreglo dinamico donde su longitud sera indicada en el main??
yo lo pense de la siguiente forma y no compilo, si se les ocurre otra forma de reolverlo por favor diganme.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#include<stdio.h> 
#include<stdlib.h> 
 
struct nodo{
int long;
int arreglo=(int*)malloc(sizeof(*p)); // supuesta struct con arreglo dinamico
struct nodo *psig;
}; //nodo
 
int mian(){
int d,seguir,i=0,j,l;
struct nodo *p,*base;
base=NULL;
 
while(seguir==0){ //crfeacion del nodo
i=i+1;
print("Ingrese 0 para cargar el nodo %d: ",i);
scanf("%d",&seguir);
 
if(seguir==0){
p=(struct nodo*)malloc(sizeof(*p));
 
printf("tamaño del vector del nodo %d: ",i);
scanf("%d",&d);
for(j=0;j<d;j++){
printf("Elemento %d del areglo: ");
scanf("%d",&p->arreglo);
}
p->long=d;
p->psig=base;
base=p;
}
 
else
print("finalizo la carga de nodos, se procede con la impresion de la pila\n\n");
}
 
p=base;
while(p!=NULL){ //imprimr la pila
l=p->long;
for(i=0;i<l;i++){
print("%d\t",p->arreglo)
}
p=p->psig;
printf("\n");
}
 
return 0;
}

desde ya gracias y saludos
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Dionicio

re: estructura con arreglo dinamico + pila en c

Publicado por Dionicio (57 intervenciones) el 14/06/2017 03:04:33
1
2
3
4
5
6
//No se permite inicializar variables en una estructura. También int arreglo no es un apuntador y estás reservando memoria para uno.
struct nodo{
     int long;// Esto está mal también porque long es una palabra reservada por el lenguaje.
     int arreglo=(int*)malloc(sizeof(*p)); // Erroneo no se puede inicializar en estructuras
     struct nodo *psig;
}; //nodo

Quisiera que para la próxima pongas el código que llevas hecho dentro de las etiqueta insertar código para que sea más fácil ayudarte, así como lo hice anteriormente. Aquí te dejo un ejemplo que tal vez te sea de ayuda.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include <stdio.h>
#include <stdlib.h>
 
struct nodo{
	int dato;//Dato contenido en la estructura
	struct nodo *psig;//Puntero nodo que apunta hacia el siguiente dato.
};
 
int main()
{
	struct nodo * pila = NULL, *primer_elemento = NULL;
	//Si la pila está vacía creamos el primer elemento
	if(pila == NULL)
		pila = (struct nodo*)malloc(sizeof(struct nodo));
 
	//Insertamos 5 en la lista y creamos un nodo psig
	pila -> dato = 5;
	pila -> psig = (struct nodo*)malloc(sizeof(struct nodo));
 
	primer_elemento = pila;//Guardamos el primer elemento
 
	//Hacemos que la pila se posicione en el nodo creado anteriormente (nodo nuevo)
	pila = pila -> psig;
 
	//Insertamos 8 en la lista y creamos un nodo psig
	pila -> dato = 8;
	pila -> psig = (struct nodo*)malloc(sizeof(struct nodo));
 
	//Hacemos que la pila se posicione en el nodo creado anteriormente (nodo nuevo)
	pila = pila -> psig;
 
	//Insertamos 3 en la lista y creamos un nodo psig
	pila -> dato = 3;
	pila -> psig = NULL;//Aquí le decimos a la pila que no habrá un siguiente elemento y por lo tanto psig será nulo.
 
 
	//Recoremos la lista desde el primer elemento el 5;
	while(primer_elemento != NULL){
		printf("%i -> ",primer_elemento -> dato);
 
		primer_elemento = primer_elemento -> psig;
	}
 
	printf("NULL\n");
 
	return 0;
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de gregory

re: estructura con arreglo dinamico + pila en c

Publicado por gregory (34 intervenciones) el 14/06/2017 04:34:55
Dionicio tiene razon. los struct dinamico que se llama list o lista enlazada en español son estructura de dato avanzado. que trata de usar un struct con un struct igual asi tendria un estructura con n tamaño. Dependiendo cuanto struct necesite, va asignandole memoria como lo lo hizo el compañero.
por lo que me dice un arreglo dinamico no tiene que ser exclusivamente un struct dinamico.
vasta usar un puntero. y liberar memoria en c.

1
2
int *p;
p=(int *) mallo(size(int));
supongamo que queremos un array dinamico de 10 de tamaño
seria
1
p=(int *) mallo(size(10));
pero no esta todo listo apenas le asignate memoria ahora falta como trabajar con esto.
pero espero que me entienda un puntero se puede ver como un array un array de puntero se puede ver como una matriz y un struct de puntero como un array de struct o como un struct normal
por ultimo un struct sin limite es una lista enlazada que es tema de algoritmo. donde ve la pila, la cola, lista circulare ...
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar