Dev - C++ - Pilas (usando funciones y procedimientos )

 
Vista:
Imágen de perfil de Gaston
Val: 114
Ha aumentado 1 puesto en Dev - C++ (en relación al último mes)
Gráfica de Dev - C++

Pilas (usando funciones y procedimientos )

Publicado por Gaston (40 intervenciones) el 14/11/2020 00:17:37
Hola gente,

Estoy intentando resolver el siguiente ejercicio de Pilas en lenguaje.

Estos puntos son los que me falta. Quién pueda darme una ayuda !!!

c) Luego intentar eliminar el tope de la pila, mostrar su contenido. ?

d) Luego intentar eliminar la base de la pila, mostrar su contenido. ?

e) Finalmente mostrar cuantos elementos quedaron en la pila. Esto último hacerlo con una función. ?

/********************************************************************************************************************
Ejercicio 7 Pilas.

Armar un programa usando los procedimientos y funciones definidas, que lea varios numeros
(con cualquier criterio). intente insertarlos en una pila que comenzará vacía.

a) Se deben descartar los que hagan desbordar la pila.

b) Luego mostrar su contenido. Usar un procedimiento.

c) Luego intentar eliminar el tope de la pila, mostrar su contenido.

d) Luego intentar eliminar la base de la pila, mostrar su contenido.

e) Finalmente mostrar cuantos elementos quedaron en la pila. Esto último hacerlo con una función.

*********************************************************************************************************************/

Este es codigo en lenguaje C


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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
 
//-------------------------------------------
 
struct pila
{
  int num;
  struct pila *sig;
 
};
 
//--------------------------------------------
  int MAXPILA;
 
 
void sacar_pila(struct pila *&pil, int &n)
{
  struct pila *p;
 
  n=pil->num;
  p=pil;
  pil=pil->sig;
 
  delete(p);
}
void insertar_pila(struct pila *&pil, int n)
{
  struct pila *nuevo;
 
  nuevo=new struct pila;
 
  nuevo->num= n;
  nuevo->sig= pil;
  pil =nuevo;
}
 
bool pila_llena(struct pila *pil)
{
  int cont;
 
  struct pila *p; p=pil;
  cont=0;
 
  while(p!=NULL)
  {
    cont++;
    p=p->sig;
  }
  if(cont==MAXPILA)
     return true;
  else
     return false;
}
 
bool pila_vacia(struct pila *pil)
{
  if(pil==NULL)
    return true;
  else
    return false;
}
 
void crear_pila(struct pila *&pil)
{
  pil=NULL;
}
 
void mostrar_base(struct pila *pil)
{
 
}
 
void mostrar_tope(struct pila *pil)
{
 
}
 
 
void pausar()
{
  printf("\n");
  system("PAUSE");
};
 
//------------------------------------------------
 
int main()
{
//declaro las dos variable de tipo puntero;
  struct pila *a;
  struct pila *b;
  int n;
 
  printf("\n Ingrese el maximo contenido de la pila: ");
  scanf("%d", &MAXPILA);
 
  crear_pila(a);
 
  printf("\n Ingrese un numero para la pila: ");
 
  scanf("%d", &n);
 
  while(n!=0)
  {
    if (pila_llena(a) ==false)
       insertar_pila(a,n);
    else
       printf("\n Generaria Desborde. ");
 
       printf("\n Ingrese un numero para la pila: ");
       scanf("%d", &n);
}
 
  crear_pila(b);
 
  while(pila_vacia(a)==false)
  {
    sacar_pila(a,n);
    printf("\n %d ", n);
    insertar_pila(b,n);
  }
 
  while(pila_vacia(b)==false)
  {
     sacar_pila(b,n);
     insertar_pila(a,n);
  }
 
  pausar();
 
  return 0;
}
 
//--------------------------------------------------------------------------------


la compilación:

Ingrese el maximo contenido de la pila: 5

Ingrese un numero para la pila: 2

Ingrese un numero para la pila: 4

Ingrese un numero para la pila: 6

Ingrese un numero para la pila: 2

Ingrese un numero para la pila: 3

Ingrese un numero para la pila: 8

Generaria Desborde.
Ingrese un numero para la pila: 2

Generaria Desborde.
Ingrese un numero para la pila: 6

Generaria Desborde.
Ingrese un numero para la pila: 3

Generaria Desborde.
Ingrese un numero para la pila: 0

3
2
6
4
2
Presione una tecla para continuar . . .
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 Alfil
Val: 4.344
Oro
Ha mantenido su posición en Dev - C++ (en relación al último mes)
Gráfica de Dev - C++

Pilas (usando funciones y procedimientos )

Publicado por Alfil (1444 intervenciones) el 14/11/2020 16:46:07
Tienes que hacer un menú que permita elegir entre las diferentes opciones a realizar

1.- Agregar a la Pila
2.- Eliminar de la Pila
3.- Eliminar Base Pila
4.- Imprimir Pila
5.- Salir

Para poder eliminar la base de la Pila (entiendo que se trata de eliminar sólo el elemento de la base, no toda la Pila) debe ser una pila doblemente enlazada (como una cola), con esto lo único que necesitas es eliminar un elemento de la cola.
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 Gaston
Val: 114
Ha aumentado 1 puesto en Dev - C++ (en relación al último mes)
Gráfica de Dev - C++

Pilas (usando funciones y procedimientos )

Publicado por Gaston (40 intervenciones) el 14/11/2020 18:37:10
Hola Alfil,

Si lo del menú se podría hacer en un procedimientos y luego se lo llama desde el main(). Pero eso no es lo más importante para mí.

Lo más importante, lo que más me interesa es poder resolver los puntos c), d) y e) usando procedimientos y funciones, así es como lo pide la profesora. Resolviendo esos puntos, después armo un procedimiento con un menú y lo llamo desde el main()

Otra cosa, la profesora dio el tema, "pila simplemente enlazada". no una pila doblemente enlazada (como una cola). Explicó los conceptos básicos y sobre el mismo código que yo aporte.

Saludos y gracias por tu aporte.
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 Alfil
Val: 4.344
Oro
Ha mantenido su posición en Dev - C++ (en relación al último mes)
Gráfica de Dev - C++

Pilas (usando funciones y procedimientos )

Publicado por Alfil (1444 intervenciones) el 14/11/2020 19:56:37
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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
#include <stdio.h>
 
struct pila
{
    int num;
    struct pila *sig;
};
 
void insertar(struct pila *&pil, int n);
int sacar(struct pila *&pil);
bool estaVacia(struct pila *pil);
void imprimir(struct pila *pil);
void vaciarPila(struct pila *&pil);
 
int main()
{
    struct pila *a = NULL;
    int n;
 
    do {
        printf("\n Ingrese un numero para la pila: ");
        scanf("%d", &n);
 
        if (n != 0)
            insertar(a, n);
 
    } while (n != 0);
 
    imprimir(a);
 
    if (!estaVacia(a))
    {
        printf("\n Se saco el elemento %d", sacar(a));
        imprimir(a);
    }
    else
        printf("\n La pila esta vacia");
 
    printf("\n Despues de vaciar la pila: ");
    vaciarPila(a);
    imprimir(a);
 
    printf("\n\n");
 
    return 0;
}
 
void insertar(struct pila *&pil, int n)
{
    struct pila *nuevo;
 
    nuevo = new struct pila;
    nuevo->num = n;
    nuevo->sig = pil;
    pil = nuevo;
}
 
int sacar(struct pila *&pil)
{
    struct pila *temp;
    int valor;
 
    temp = pil;
    valor = pil->num;
    pil = pil->sig;
 
    delete(temp);
 
    return valor;
}
 
bool estaVacia(struct pila *pil)
{
    return pil == NULL;
}
 
void imprimir(struct pila *pil)
{
    if (pil == NULL)
        printf("\n La pila esta vacia");
    else
    {
        printf("\n La pila es: ");
 
        while(pil != NULL)
        {
            printf( " %d-> ", pil->num);
            pil = pil->sig;
        }
 
        printf ("NULL\n\n");
    }
}
 
void vaciarPila(struct pila *&pil)
{
    struct pila *temp;
 
    while (pil != NULL)
    {
        temp = pil;
        pil = pil->sig;
 
        delete(temp);
    }
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar
Imágen de perfil de Gaston
Val: 114
Ha aumentado 1 puesto en Dev - C++ (en relación al último mes)
Gráfica de Dev - C++

Pilas (usando funciones y procedimientos )

Publicado por Gaston (40 intervenciones) el 14/11/2020 23:29:33
Alfil,

Ahí estoy probando el código.

Lo que haces el código que me pasaste es lo siguiente:

--------------------------------------------------------------------------------

compilación:


Ingrese un numero para la pila: 2

Ingrese un numero para la pila: 4

Ingrese un numero para la pila: 6

Ingrese un numero para la pila: 3

Ingrese un numero para la pila: 0

La pila es: 3-> 6-> 4-> 2-> NULL


Se saco el elemento 3
La pila es: 6-> 4-> 2-> NULL


Despues de vaciar la pila:
La pila esta vacia

Presione una tecla para continuar . . .

----------------------------------------------------------------------------------------------------------------------

1) ingreso valores en la pila OK

2) elimino el tope en este caso es el valor 3 OK

3) muestra la pila OK (Acá la profesora quiere que se llame a un procedimiento o una función, se los aclaro a todos los alumnos ).

4) muestra la pila vacia. "Acá tengo dudas !!! Porque no se si dedo dejar la pila vacía. !!!!

Conclusión,

- El mostrar la pila, la profesora quiere que lo hagamos con procedimientos o una funciones.

- Me queda eliminar la base de la pila, que seguro es el mismo procedimiento.

El ejercicio se puede mejorar !!!

Como siempre mil gracias por la ayuda !!!!
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 Alfil
Val: 4.344
Oro
Ha mantenido su posición en Dev - C++ (en relación al último mes)
Gráfica de Dev - C++

Pilas (usando funciones y procedimientos )

Publicado por Alfil (1444 intervenciones) el 14/11/2020 23:43:34
La única manera de acceder a la base de la pila sin ser una pila doblemente enlazada, es vaciarla.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar
Imágen de perfil de Gaston
Val: 114
Ha aumentado 1 puesto en Dev - C++ (en relación al último mes)
Gráfica de Dev - C++

Pilas (usando funciones y procedimientos )

Publicado por Gaston (40 intervenciones) el 15/11/2020 00:32:46
Ah OK !! Me quedo claro.

Gracias !!
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 Gaston
Val: 114
Ha aumentado 1 puesto en Dev - C++ (en relación al último mes)
Gráfica de Dev - C++

Pilas (usando funciones y procedimientos )

Publicado por Gaston (40 intervenciones) el 14/11/2020 23:50:33
Hola Gente,

Voy a intentar terminar el ejercicio de Pila, y si logro resolver lo que me falta, usando solo procedimientos y funciones. Lo publico.

Para aquellos que necesiten del ejercicio.

Saludos !!

Gastón.
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 Gaston
Val: 114
Ha aumentado 1 puesto en Dev - C++ (en relación al último mes)
Gráfica de Dev - C++

Pilas (usando funciones y procedimientos )

Publicado por Gaston (40 intervenciones) el 15/11/2020 05:53:26
Hola gente

Acá les dejo el enunciado completo de pila y el código quién lo necesite y lo quiera probar !!!

/**************************************************************************************************************************
Ejercicio 7 Pilas.

Armar un programa usando los procedimientos y funciones definidas que lea varios numeros
(con cualquier criterio), intente insertarlos en una pila que comenzará vacía. ok

a) Se deben descartar los que hagan desbordar la pila. ok
b) Luego mostrar su contenido. Usar un procedimiento. ok
c) Luego intentar eliminar el tope de la pila, mostrar su contenido.
d) Luego intentar eliminar la base de la pila, mostrar su contenido.
e) Finalmente mostrar cuantos elementos quedaron en la pila. Esto último hacerlo con una función.

*****************************************************************************************************************************/

Acá les dejo todo el código. el programa compila. Pero con la salvedad cuando me pide ingresar el elemento de la lista !!!

pero me tira un cartel que dice: ejerPila.cpp dejo de funcionar. Windows buscara una mejor solución.... !!


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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
//------------------------------------------------------------------
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
 
//-------------------------------------------
 
struct pila
{
  int num;
  struct pila *sig;
 
};
 
 
//--------------------------------------------
  int MAXPILA; //variable global
 
//---------------------------------------------
 
void procValMaxpila(int &n);
void leer_numero(char cad[30], int &num);
void crear_pila(struct pila *&pil);
bool pila_vacia(struct pila *pil);
bool pila_llena(struct pila *pil);
void insertar_pila(struct pila *&pil, int n);
void sacar_pila(struct pila *&pil, int &n);
void cargar_pila1(struct pila *&pil);
void mostrar_pila(struct pila *pil);
void dar_vuelta(struct pila *&orig, struct pila *&aux);
void mostrar_base(struct pila *pil);
void mostrar_tope(struct pila *pil);
void eliminar_tope(struct pila *&pil);
void eliminar_base(struct pila *&pil);
int cuantos(struct pila *pil);
void pausar();
 
//---------------------------------------------------------------------------------
 
 
int main()
{
 
   int n;
   struct pila *ez;
 
   procValMaxpila(n);
   cargar_pila1(ez);
   printf("\n");
   printf("\n los elementos de la pila son: ");
   mostrar_pila(ez);
   eliminar_tope(ez);
   printf("\n");
   printf("\n los elementos sin el tope son: ");
   mostrar_pila(ez);
   eliminar_base(ez);
   printf("\n");
   printf("\n los elementos sin la base son: ");
   mostrar_pila(ez);
   printf("\nQuedaron elementos en la pila. ",cuantos(ez));
 
 
   pausar();
 
   return 0;
}
 
//------------------------------------------------------------------------------------------------
 
void crear_pila(struct pila *&pil)
{
  pil=NULL;
}
 
void insertar_pila(struct pila *&pil, int n)
{
  struct pila *nuevo;
 
  nuevo=new struct pila;
 
  nuevo->num= n;
  nuevo->sig= pil;
  pil =nuevo;
}
 
//cargamos la pila con un procedimiento
void cargar_pila1(struct pila *&pil)
{
  int cant;
  int i;
  int n;
 
  //llamo a crear pila
  crear_pila(pil);
  leer_numero("\nIngrese la cantidad de elementos de la pila: ",cant);
 
  //iteramos la veces que ingresamos los elementos a la pila
  for(i=1; i<=cant; i++)
  {
     leer_numero("\n ingrese numero para la pila: ",n);
        if(pila_llena(pil)==false)
            insertar_pila(pil,n); //llamo a insertar en la pila
        else
            printf("\nNo ingreso. La pila se desbordo");
 
  }
 
}
 
 
void sacar_pila(struct pila *&pil, int &n)
{
  struct pila *p;
 
  n=pil->num;
  p=pil;
  pil=pil->sig;
 
  delete p;
}
 
 
void mostrar_pila(struct pila *pil)
{
 
   struct pila *auxiliar;
   int n;
 
   while(pila_vacia(pil)==false)
   {
       sacar_pila(pil,n);
       printf("\n ");
       scanf("%d",&n);
       fflush(stdin);
 
       insertar_pila(auxiliar,n);
 
   }
 
   while(pila_vacia(auxiliar)==false)
   {
      sacar_pila(auxiliar,n);
      insertar_pila(pil,n);
   }
 
}
 
//mostrar tope de la pila
void mostrar_tope(struct pila *pil)
{
   int n;
 
   if(pila_vacia(pil)==true)
        printf("\n No tiene tope, Pila vacia");
   else
       {
         sacar_pila(pil,n);
         printf("\n el tope es: %d",n);
         insertar_pila(pil,n);
 
       }
 
}
 
void mostrar_base(struct pila *pil)
{
   int n;
 
   struct pila *auxiliar;
 
   if(pila_vacia(pil)==true)
      printf("\n No tiene base, Pila vacia");
   else
       {
          dar_vuelta(pil,auxiliar);
          sacar_pila(auxiliar,n);
          printf("\n la base es: %d",n);
 
          insertar_pila(auxiliar,n);
          dar_vuelta(auxiliar,pil);
 
 
       }
 
}
//procedimiento que sirve para dar vuelta la pila con dos pilas: una pila original y una pila aux
void dar_vuelta(struct pila *&orig, struct pila *&auxiliar)
{
   int n;
   //llamo a crear_pila()
   crear_pila(auxiliar);
   /*condicion si la pila no esta vacia saco de la pila original y lo coloco en la pila auxiliar
     la pila original  me queda vacia y la pila auxiliar con todos los elementos*/
   while(pila_vacia(orig)==false)
   {
      sacar_pila(orig,n);
      insertar_pila(auxiliar,n);
 
   }
 
}
 
 
bool pila_llena(struct pila *pil)
{
  int cont;
 
  struct pila *p;
  p=pil;
 
  cont=0;
 
  while(p!=NULL)
  {
    cont++;
    p=p->sig;
  }
  if(cont==MAXPILA)
     return true;
  else
     return false;
}
 
bool pila_vacia(struct pila *pil)
{
  if(pil==NULL)
    return true;
  else
    return false;
}
 
//eliminar el tope de la pila
void eliminar_tope(struct pila *&pil)
{
 
    int n;
 
    if(pila_vacia(pil)==true)
       printf("\n No tiene tope, Pila vacia");
    else
        {
          sacar_pila(pil,n);
        }
 
}
//eliminar base de la pila
void eliminar_base(struct pila *&pil)
{
    int n;
    struct pila *aux;
 
    if(pila_vacia(pil)==true)
       printf("\n No tiene base, Pila vacia");
    else
        {
           dar_vuelta(pil,aux);
           sacar_pila(aux,n);
           dar_vuelta(aux,pil);
 
        }
 
 
}
 
int cuantos(struct pila *pil)
{
   int n;
   int res;
 
   res=0;
   struct pila *auxiliar;
 
   crear_pila(auxiliar);
 
   while(pila_vacia(pil)==false)
   {
      sacar_pila(pil,n);
      insertar_pila(auxiliar,n);
      res++;
 
 
   }
   dar_vuelta(auxiliar,pil);
 
 
   return res;
 
}
 
void procValMaxpila(int &n)
{
   printf("\nIngrese el valor maximo de la pila: ");
   scanf("%d",&n);
   MAXPILA =n;
 
}
 
void leer_numero(char cad[30], int &num)
{
   printf("\n");
   printf("%s",cad);
   fflush(stdin);
   scanf("%d",&num);
 
}
 
void pausar()
{
  printf("\n");
  system("PAUSE");
};
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