Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- #include <stdio.h>
- #include <stdlib.h>
- #include "pila.h"
- #include <conio.h>
- #include <time.h>
- #include <windows.h>
- /*
- 1)1. Cargar desde el teclado una pila DADA con 5 elementos.
- Pasar los tres primeros elementos a la pila AUX1 y los dos
- restantes a la pila AUX2, ambas pilas inicializadas en vacío.
- Pila DADA, AUX1, AUX2;
- inicpila(&DADA);
- inicpila(&AUX1);
- inicpila(&AUX2);
- leer(&DADA);
- leer(&DADA);
- leer(&DADA);
- leer(&DADA);
- leer(&DADA);
- printf("Pila DADA\n");
- mostrar(&DADA);
- apilar(&AUX1, desapilar(&DADA));
- apilar(&AUX1, desapilar(&DADA));
- apilar(&AUX1, desapilar(&DADA));
- printf("Pila AUX1\n");
- mostrar(&AUX1);
- while(!pilavacia(&DADA)){
- apilar(&AUX2, desapilar(&DADA));
- }
- printf("Pila AUX2\n");
- mostrar(&AUX2);
- -------------------------------------------------------------
- -------------------------------------------------------------
- 2)2. Cargar desde el teclado la pila ORIGEN e inicializar en
- vacío la pila DESTINO. Pasar todos los elementos de la pila
- ORIGEN a la pila DESTINO.
- Pila ORIGEN, DESTINO;
- inicpila(&ORIGEN);
- inicpila(&DESTINO);
- char stop='s';
- do{
- leer(&ORIGEN);
- printf("Si desea continuar presione s \n");
- fflush(stdin);
- scanf("%c", &stop);
- }while (stop== 's');
- printf("Pila ORIGEN\n");
- mostrar(&ORIGEN);
- while(!pilavacia(&ORIGEN)){
- apilar(&DESTINO, desapilar(&ORIGEN));
- }
- printf("Pila ORIGEN despues de desapilarla\n");
- mostrar(&ORIGEN);
- printf("Pila DESTINO\n");
- mostrar(&DESTINO);
- -------------------------------------------------------------
- -------------------------------------------------------------
- 3. Cargar desde teclado una pila DADA y pasar a la pila
- DISTINTOS todos aquellos elementos distintos al valor 8.
- Pila DADA, DISTINTOS, AUX;
- inicpila(&DADA);
- inicpila(&DISTINTOS);
- inicpila(&AUX);
- char stop='s';
- do{
- leer(&DADA);
- printf("Si desea continuar presione s \n");
- fflush(stdin);
- scanf("%c", &stop);
- }while (stop== 's');
- printf("Pila ORIGEN\n");
- mostrar(&DADA);
- while(!pilavacia(&DADA)){
- if(tope(&DADA)!= 8){
- apilar(&DISTINTOS, desapilar(&DADA));
- }else {
- apilar(&AUX, desapilar(&DADA));
- }
- }
- while(!pilavacia(&AUX)){
- apilar(&DADA, desapilar(&AUX));
- }
- printf("Pila ORIGEN despues de desapilarla\n");
- mostrar(&DADA);
- printf("Pila DISTINTOS A 8\n");
- mostrar(&DISTINTOS);
- -------------------------------------------------------------
- -------------------------------------------------------------
- 4. Cargar desde el teclado la pila ORIGEN e inicializar
- en vacío la pila DESTINO. Pasar los elementos de la pila
- ORIGEN a la pila DESTINO, pero dejándolos en el mismo orden.
- Pila ORIGEN, DESTINO, AUX;
- inicpila(&ORIGEN);
- inicpila(&DESTINO);
- inicpila(&AUX);
- char stop='s';
- do{
- leer(&ORIGEN);
- printf("Si desea continuar presione s \n");
- fflush(stdin);
- scanf("%c", &stop);
- }while (stop== 's');
- printf("Pila ORIGEN\n");
- mostrar(&ORIGEN);
- /////////////////////////////////////////////////////////
- TENGO QUE DESAPILAR ORIGEN Y APILAR EN AUXILIAR: 1 2 3 4
- CUANDO APILO EN AUXILIAR SE APILA: 4 3 2 1
- DESAPILO AUXILIAR Y APILO EN DESTINO: 1 2 3 4
- /////////////////////////////////////////////////////////
- while(!pilavacia(&ORIGEN)){
- apilar(&AUX, desapilar(&ORIGEN));
- }
- while(!pilavacia(&AUX)){
- apilar(&DESTINO, desapilar(&AUX));
- }
- printf("Pila DESTINO: \n");
- mostrar(&DESTINO);
- -------------------------------------------------------------
- -------------------------------------------------------------
- 5. Cargar desde el teclado la pila DADA. Invertir la pila
- de manera que DADA contenga los elementos cargados
- originalmente en ella, pero en orden inverso
- Pila DADA, DESTINO, AUX;
- inicpila(&DADA);
- inicpila(&DESTINO);
- inicpila(&AUX);
- char stop='s';
- do{
- leer(&DADA);
- printf("Si desea continuar presione s \n");
- fflush(stdin);
- scanf("%c", &stop);
- }while (stop== 's');
- printf("Pila DADA\n");
- mostrar(&DADA);
- ////////////////////////////////////////////////////////
- TENGO QUE DESAPILAR DADA Y APILAR EN AUXILIAR: 1 2 3 4
- CUANDO APILO EN AUXILIAR SE APILA: 4 3 2 1
- DESAPILO AUXILIAR Y APILO EN DESTINO: 1 2 3 4
- DESAPILO DESTINO Y APILO EN DADA: 4 3 2 1
- ///////////////////////////////////////////////////////
- while(!pilavacia(&DADA)){
- apilar(&AUX, desapilar(&DADA));
- }
- while(!pilavacia(&AUX)){
- apilar(&DESTINO, desapilar(&AUX));
- }
- while(!pilavacia(&DESTINO)){
- apilar(&DADA, desapilar(&DESTINO));
- }
- printf("Pila DADA: \n");
- mostrar(&DADA);
- -------------------------------------------------------------
- -------------------------------------------------------------
- 6. Pasar el primer elemento (tope) de la pila DADA a su última
- posición (base), dejando los restantes elementos en el mismo orden.
- Pila DADA, DESTINO, AUX;
- inicpila(&DADA);
- inicpila(&DESTINO);
- inicpila(&AUX);
- char stop='s';
- do{
- leer(&DADA);
- printf("Si desea continuar presione s \n");
- fflush(stdin);
- scanf("%c", &stop);
- }while (stop== 's');
- printf("Pila DADA\n");
- mostrar(&DADA);
- /////////////////////////////////////////////////////
- CARGO DADA: 1 2 3 4
- TENGO QUE DESAPILAR DADA Y APILAR EN AUXILIAR: 4
- CUANDO APILO EN AUXILIAR SE APILA: 4
- DESAPILO DADA Y APILO EN DESTINO: 3 2 1
- DESAPILO AUXILIAR EN DADA: 4
- DESAPILO DESTINO Y APILO EN DADA: 4 3 2 1
- /////////////////////////////////////////////////////
- apilar(&AUX, desapilar(&DADA));
- while(!pilavacia(&DADA)){
- apilar(&DESTINO, desapilar(&DADA));
- }
- while(!pilavacia(&AUX)){
- apilar(&DADA, desapilar(&AUX));
- }
- while(!pilavacia(&DESTINO)){
- apilar(&DADA, desapilar(&DESTINO));
- }
- printf("Pila DADA: \n");
- mostrar(&DADA);
- OPCION2
- Pila DADA, DESTINO, AUX;
- inicpila(&DADA);
- inicpila(&DESTINO);
- inicpila(&AUX);
- char stop='s';
- do{
- leer(&DADA);
- printf("Si desea continuar presione s \n");
- fflush(stdin);
- scanf("%c", &stop);
- }while (stop== 's');
- printf("Pila DADA\n");
- mostrar(&DADA);
- if(!pilavacia(&DADA)){
- apilar(&AUX, desapilar(&DADA));
- while(!pilavacia(&DADA)){
- apilar(&DESTINO, desapilar(&DADA));
- }
- apilar(&DADA, desapilar(&AUX));
- while(!pilavacia(&DESTINO)){
- apilar(&DADA, desapilar(&DESTINO));
- }
- }
- mostrar(&DADA);
- -------------------------------------------------------------
- -------------------------------------------------------------
- 7. Pasar el último elemento (base) de la pila DADA a su primera
- posición (tope), dejando los restantes elementos en el mismo orden.
- Pila DADA, DESTINO, AUX;
- inicpila(&DADA);
- inicpila(&DESTINO);
- inicpila(&AUX);
- char stop='s';
- do{
- leer(&DADA);
- printf("Si desea continuar presione s \n");
- fflush(stdin);
- scanf("%c", &stop);
- }while (stop== 's');
- printf("Pila DADA\n");
- mostrar(&DADA);
- //////////////////////////////////////////////////
- DESAPILO LOS ELEMENTOS EN AUXILIAR
- EN AUXILIAR QUEDA LA BASE COMO TOPE: 4 3 2 1
- EN DESTINO APILO EL TOPE DE AUXILIAR: 1
- APILO EN DADA LOS ELEMENTOS DE AUXILIAR: 2 3 4
- DESDE DESTINO APILO EN DADA 2 3 4 1
- //////////////////////////////////////////////////
- while(!pilavacia(&DADA)){
- apilar(&AUX, desapilar(&DADA));
- }
- apilar(&DESTINO,desapilar(&AUX));
- while(!pilavacia(&AUX)){
- apilar(&DADA, desapilar(&AUX));
- }
- while(!pilavacia(&DESTINO)){
- apilar(&DADA, desapilar(&DESTINO));
- }
- printf("Pila DADA: \n");
- mostrar(&DADA);
- -------------------------------------------------------------
- OPCION2
- Pila DADA, DESTINO, AUX;
- inicpila(&DADA);
- inicpila(&DESTINO);
- inicpila(&AUX);
- char stop='s';
- do{
- leer(&DADA);
- printf("Si desea continuar presione s \n");
- fflush(stdin);
- scanf("%c", &stop);
- }while (stop== 's');
- printf("Pila DADA\n");
- mostrar(&DADA);
- if(!pilavacia(&DADA)){
- while(!pilavacia(&DADA)){
- apilar(&AUX, desapilar(&DADA));
- }
- apilar(&DESTINO,desapilar(&AUX));
- while(!pilavacia(&AUX)){
- apilar(&DADA, desapilar(&AUX))
- }
- apilar(&DADA,desapilar(&DESTINO));
- }
- printf("Pila DADA: \n");
- mostrar(&DADA);
- -------------------------------------------------------------
- -------------------------------------------------------------
- 8. Repartir los elementos de la pila MAZO en las pilas
- JUGADOR1 y JUGADOR2 en forma alternativa.
- #define s 83 ////la letra s corresponde a la tecla 83
- int main()
- {
- Pila MAZO, J1, J2;
- inicpila(&MAZO);
- inicpila(&J1);
- inicpila(&J2);
- int i;
- srand(time(NULL));
- int limite= 20; //CANTIDAD DE ELEMENTOS QUE VA A TENER LA PILA
- printf("Cargando mazo: \n");
- Sleep(1500);
- printf(".....................\n");
- Sleep(1500);
- printf(".....................\n");
- Sleep(1500);
- ///////LLENO LA PILA DE NUMEROS ALEATORIOS
- for(i=0; i< limite ; i++){
- apilar(&MAZO, rand()%15);
- }
- printf("\nMAZO\n");
- mostrar(&MAZO);
- //////////////////////////////////////////////
- DESAPILO EN J1 Y EN J2 LA PILA MAZO
- MIENTRAS MAZO NO ESTE VACIA DESAPILO EL TOPE AL J1
- SI SIGUE CON ELEMENTOS DESAPILO EL TOPE EN J2
- Y ASI SUCESIVAMENTE HASTA QUE NO TENGA MAS ELEMENTOS
- //////////////////////////////////////////////
- while (!pilavacia(&MAZO)){
- apilar(&J1, desapilar(&MAZO));
- if(!pilavacia(&MAZO)){
- apilar(&J2, desapilar(&MAZO));
- }
- }
- printf("Cartas J1\n");
- mostrar(&J1);
- printf("Cartas J2\n");
- mostrar(&J2);
- -------------------------------------------------------------
- -------------------------------------------------------------
- 9. Comparar la cantidad de elementos de las pilas A y B.
- Mostrar por pantalla el resultado.
- OPCION1:
- Pila aux, A1, B1;
- inicpila(&aux);
- inicpila(&A1);
- inicpila(&B1);
- char stop='s';
- do{
- leer(&A1);
- printf("Si desea continuar cargando la pila A presione s\n");
- fflush(stdin);
- scanf("%c",&stop);
- }while(stop=='s');
- mostrar(&A1);
- do{
- leer(&B1);
- printf("Si desea continuar cargando la pila B presione s\n");
- fflush(stdin);
- scanf("%c",&stop);
- }while(stop=='s');
- mostrar(&B1);
- while(!pilavacia(&A1)&& !pilavacia(&B1)){
- apilar(&aux, desapilar(&A1));
- apilar(&aux, desapilar(&B1));
- }
- if(pilavacia(&A1) && pilavacia(&B1)){
- printf("Las Pilas A y B tienen la misma cantidad de elementos\n");
- }else{
- printf("Las Pilas A y B tienen diferente cantidad de elementos\n");
- }
- --------------------------------------------------------------------------------------------------------------------------
- OPCION2:
- int main()
- {
- Pila aux, A1, B1;
- inicpila(&aux);
- inicpila(&A1);
- inicpila(&B1);
- srand(time(NULL));
- int limite;
- int i;
- printf("Ingrese la cantidad de elementos que quiera en la pila A\n");
- fflush(stdin);
- scanf("%i",&limite);
- for(i=0; i< limite ; i++){
- apilar(&A1, rand()%15);
- }
- mostrar(&A1);
- system("cls");
- printf("Ingrese la cantidad de elementos que quiera en la pila B\n");
- fflush(stdin);
- scanf("%i",&limite);
- for(i=0; i< limite ; i++){
- apilar(&B1, rand()%15);
- }
- mostrar(&B1);
- while(!pilavacia(&A1)&& !pilavacia(&B1)){
- apilar(&aux, desapilar(&A1));
- apilar(&aux, desapilar(&B1));
- }
- if(pilavacia(&A1) && pilavacia(&B1)){
- printf("Las Pilas A y B tienen la misma cantidad de elementos\n");
- }else{
- printf("Las Pilas A y B tienen diferente cantidad de elementos\n");
- }
- -------------------------------------------------------------
- -------------------------------------------------------------
- 10. Comparar las pilas A y B, evaluando si son completamente iguales
- (en cantidad de elementos, valores que contienen y posición de los
- mismos). Mostrar por pantalla el resultado.
- OPCION1:
- Pila aux, A1, B1;
- inicpila(&aux);
- inicpila(&A1);
- inicpila(&B1);
- srand(time(NULL));
- int limite;
- int i;
- printf("Ingrese la cantidad de elementos que quiera en la pila A\n");
- fflush(stdin);
- scanf("%i",&limite);
- for(i=0; i< limite ; i++){
- apilar(&A1, rand()%15);
- }
- mostrar(&A1);
- printf("Ingrese la cantidad de elementos que quiera en la pila B\n");
- fflush(stdin);
- scanf("%i",&limite);
- for(i=0; i< limite ; i++){
- apilar(&B1, rand()%15);
- }
- mostrar(&B1);
- while(!pilavacia(&A1)&& !pilavacia(&B1) && (tope(&A1)==tope(&B1))){
- apilar(&aux, desapilar(&A1));
- apilar(&aux, desapilar(&B1));
- }
- if(pilavacia(&A1) && pilavacia(&B1)){
- printf("Las Pilas A y B son IGUALES \n");
- }else{
- printf("Las Pilas A y B son DIFERENTES \n");
- }
- -------------------------------------------------------------
- OPCION2
- Pila aux, A1, B1;
- inicpila(&aux);
- inicpila(&A1);
- inicpila(&B1);
- char stop='s';
- do{
- leer(&A1);
- printf("Si desea continuar cargando la pila A presione s\n");
- fflush(stdin);
- scanf("%c",&stop);
- }while(stop=='s');
- mostrar(&A1);
- do{
- leer(&B1);
- printf("Si desea continuar cargando la pila B presione s\n");
- fflush(stdin);
- scanf("%c",&stop);
- }while(stop=='s');
- mostrar(&B1);
- while(!pilavacia(&A1)&& !pilavacia(&B1) && (tope(&A1)==tope(&B1))){
- apilar(&aux, desapilar(&A1));
- apilar(&aux, desapilar(&B1));
- }
- if(pilavacia(&A1) && pilavacia(&B1)){
- printf("Las Pilas A y B son IGUALES \n");
- }else{
- printf("Las Pilas A y B son DIFERENTES \n");
- }
- -------------------------------------------------------------
- -------------------------------------------------------------
- 11. Suponiendo la existencia de una pila MODELO que no esté vacía,
- eliminar de la pila DADA todos los elementos que sean iguales al
- tope de la pila MODELO.
- Pila aux, MODELO, DADA, reserva;
- inicpila(&aux);
- inicpila(&MODELO);
- inicpila(&DADA);
- inicpila(&reserva);
- srand(time(NULL));
- int limite;
- int i;
- char stop= 's';
- printf("Ingrese la cantidad de elementos que quiera en la pila DADA\n");
- fflush(stdin);
- scanf("%i",&limite);
- for(i=0; i< limite ; i++){
- apilar(&DADA, rand()%15);
- }
- mostrar(&DADA);
- do{
- leer(&MODELO);
- printf("Si desea continuar cargando la pila MODELO presione s\n");
- fflush(stdin);
- scanf("%c",&stop);
- }while(stop=='s');
- mostrar(&MODELO);
- while(!pilavacia(&DADA)){
- if(tope(&DADA) == tope(&MODELO)){
- apilar(&aux, desapilar(&DADA));
- }else{
- apilar(&reserva, desapilar(&DADA));
- }
- }
- while(!pilavacia(&reserva)){
- apilar(&DADA, desapilar(&reserva));
- }
- printf("Pila DADA\n");
- mostrar(&DADA);
- printf("Elemento eliminado repetido \n");
- mostrar(&aux);
- return 0;
- }
- -------------------------------------------------------------
- -------------------------------------------------------------
- 12. Suponiendo la existencia de una pila MODELO (vacía o no),
- eliminar de la pila DADA todos los elementos que existan en MODELO.
- Pila aux, MODELO, DADA, reserva, DESCARTE;
- inicpila(&aux);
- inicpila(&MODELO);
- inicpila(&DADA);
- inicpila(&reserva);
- inicpila(&DESCARTE);
- srand(time(NULL));
- int limite;
- int i=0;
- printf("Ingrese la cantidad de elementos que quiera en la pila DADA\n");
- fflush(stdin);
- scanf("%i",&limite);
- for(i=0; i< limite ; i++){
- apilar(&DADA, rand()%15);
- }
- mostrar(&DADA);
- printf("Ingrese la cantidad de elementos que quiera en la pila DADA\n");
- fflush(stdin);
- scanf("%i",&limite);
- for(i=0; i< limite ; i++){
- apilar(&MODELO, rand()%15);
- }
- mostrar(&MODELO);
- while(!pilavacia(&MODELO)) {
- while(!pilavacia(&DADA)){
- if(tope(&DADA) == tope(&MODELO)){
- apilar(&aux, desapilar(&DADA));
- } else{
- apilar(&reserva, desapilar(&DADA));
- }
- }
- while(!pilavacia(&reserva)){
- apilar(&DADA, desapilar(&reserva));
- }
- apilar(&DESCARTE, desapilar(&MODELO));
- }
- printf("Pila DADA\n");
- mostrar(&DADA);
- printf("Elementos eliminados repetidos en ambas pilas\n");
- mostrar(&aux);
- -------------------------------------------------------------
- -------------------------------------------------------------
- 13. Suponiendo la existencia de una pila LÍMITE, pasar los
- elementos de la pila DADA que sean mayores o iguales que el
- tope de LIMITE a la pila MAYORES, y los elementos que sean
- menores a la pila MENORES
- Pila DADA, DESCARTE, LIMITE, MAYORES,MENORES;
- inicpila(&DADA);
- inicpila(&DESCARTE);
- inicpila(&LIMITE);
- inicpila(&MAYORES);
- inicpila(&MENORES);
- srand(time(NULL));
- int limite;
- int i=0;
- printf("Ingrese la cantidad de elementos que quiera en la pila DADA\n");
- fflush(stdin);
- scanf("%i",&limite);
- for(i=0; i< limite ; i++){
- apilar(&DADA, rand()%15);
- }
- mostrar(&DADA);
- printf("Ingrese la cantidad de elementos que quiera en la pila DADA\n");
- fflush(stdin);
- scanf("%i",&limite);
- for(i=0; i< limite ; i++){
- apilar(&LIMITE, rand()%15);
- }
- mostrar(&LIMITE);
- while(!pilavacia(&LIMITE)&& !pilavacia(&DADA)){
- if(tope(&DADA)>= tope(&LIMITE)){
- apilar(&MAYORES, desapilar(&DADA));
- } else{
- apilar(&MENORES, desapilar(&DADA));
- }
- apilar(&DESCARTE, desapilar(&LIMITE));
- }
- printf("Pila MAYORES\n");
- mostrar(&MAYORES);
- printf("Pila MENORES\n");
- mostrar(&MENORES);
- -------------------------------------------------------------
- -------------------------------------------------------------
- 14. Determinar si la cantidad de elementos de la pila DADA es par.
- Si es par, pasar el elemento del tope de la pila AUX a la pila PAR
- y si es impar pasar el tope a la pila IMPAR (EN EL MAIN)
- -------------------------------------------------------------
- -------------------------------------------------------------
- 15. La condición es que mientras la pila PILA1 no esté vacía, se desapilen
- los elementos de la pila DESCARTE y se apilen en PILA2. El ciclo finaliza
- al vaciar P1.
- -------------------------------------------------------------
- -------------------------------------------------------------
- 16. Mientras que PILA1 no se vacíe, si el tope de Pila1 es igual a 5, se desapila y se apila en la pila
- aux, luego se desapila su tope y se apila en la pila result.
- -------------------------------------------------------------
- -------------------------------------------------------------
- 17. ERRORES:
- Solo se leerá un elemento a la hora de cargar la pila.
- Solo si carga el valor 5 funcionará el resto del programa.
- Falta incluir librerías
- //librerias
- #include <stdio.h>
- #include <stdlib.h>
- #include"pila.h"
- //main
- int main()
- {
- //Declaración de las Pilas a utilizar
- Pila origen, distinto;
- //Inicialización de las Pilas
- inicpila(&origen);
- inicpila(&distinto);
- //Declaración de variable de tipo char
- char stop='s';
- //Algoritmo de carga de elementos a Pila
- do{
- leer(&origen);
- printf("Si desea continuar cargando elementos presionar s y enter\n");
- fflush(stdin);
- scanf("%c",&stop);
- }while(stop=='s');
- //Algoritmo de manejo de Pila utilizando condicional (if) y bucle while
- //Utilización de funciones de Pilas: tope, pilavacia, desapilar, apilar
- if(!pilavacia(&origen)){
- while(tope(&origen)!= 5){
- apilar(&distinto, desapilar(&origen));
- }
- }
- //muestra por pantalla de las pilas
- mostrar(&origen);
- mostrar(&distinto);
- }
- -------------------------------------------------------------
- -------------------------------------------------------------
- 18. La condición es que la Pila1 y la Pila2 no estén vacías, en caso de que una
- esté vacía y la otra no,el programa dejará de ejecutar el ciclo while ya que es
- una condición excluyente que AMBAS no estén vacías.
- Puede que ambas queden vacías o que una de ellas quede con elementos y la otra vacía.
- */
- int main()
- {
- Pila DADA, AUX, PAR,IMPAR;
- inicpila(&DADA);
- inicpila(&AUX);
- inicpila(&PAR);
- inicpila(&IMPAR);
- char stop ='s';
- do{
- leer(&DADA);
- printf("Si desea continuar cargando la PILA DADA presione s\n");
- fflush(stdin);
- scanf("%c", &stop);
- }while(stop=='s');
- mostrar(&DADA);
- //////////////////////////////////////////////
- /*PASOS:
- MIENTRAS QUE LA PILA DADA NO ESTE VACIA ,DESAPILO SU TOPE
- Y LO PASO A LA PILA AUX
- SI SIGUE CON ELEMENTOS LA PILA DADA (1° IF) DESAPILO EL TOPE Y LO PASO
- A AUX DE NUEVO
- PREGUNTO SI LA PILA SE VACIÓ, SI ES AFIRMATIVO
- APILO EN PAR EL TOPE DE AUX (si no tiene mas elementos es porque tenia cantidad par
- : esto lo verificamos al hacer 2 pasadas )
- EN CASO DE QUE SE VACIE ANTES DE HACER LA 2DA REVISION
- PASAMOS EL TOPE DE AUX A LA PILA IMPAR
- */
- /////////////////////////////////////////////
- while (!pilavacia(&DADA)){
- apilar(&AUX, desapilar(&DADA));
- if(!pilavacia(&DADA))
- {
- apilar(&AUX, desapilar(&DADA));
- if(pilavacia(&DADA))
- {
- apilar(&PAR, desapilar(&AUX));
- }
- }
- else
- {
- apilar(&IMPAR,desapilar(&AUX));
- }
- }
- if(!pilavacia(&IMPAR)){
- printf("DADA tenia cantidad de elementos impares\n");
- }
- else if (!pilavacia(&PAR)) {
- printf("DADA tenia cantidad de elementos pares\n");
- }
- else{
- printf("La pila DADA no tenia elementos en su pila\n");
- }
- }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement