[SOLUCIONADO] PILAS Y COLAS-ayuda por favor

[swator]

hola,soy estudiante de sistemas c++ y acabo de tener un final pero me fue mal y quisiera ver como es el ejercicio completo.si alguien puede ayudarme se lo agradeceria.les dejo el enunciado
mi mail es [email protected] cualquier cosa avises muchas gracias.




A partir del siguiente código, escribir obligatoriamente en donde se indica CON EL TEXTO "<---- COMPLETAR" las rutinas faltantes o incompletas.

También completar la función main() haciendo que cumpla con el objetivo que se indica más adelante en la función main.

El código entregado se puede alterar si se lo considera necesario y que encuentren un error en el mismo.

Las estructuras a completar son:

t_pila
t_cola

Las funciones a completar son:

void encolar(...., t_dato dato)
void desapilar(...., t_dato dato)
void pilaLlena(...)
void vaciarPila(...)
void vaciarCola(...)
void colaVacia(...)
void main()


#include <iostream>
using namespace std;

typedef int t_dato

struct t_nodo{
t_dato dato;
t_nodo * sig;
};

struct t_pila {
...
}

struct t_cola {
...
}
//----- Rutinas a completar

void encolar(...., t_dato dato) <---- COMPLETAR Y DESARROLLAR

void desapilar(...., t_dato dato) <---- COMPLETAR Y DESARROLLAR

void pilaLlena(...) <---- COMPLETAR Y DESARROLLAR

void vaciarPila(...) <---- COMPLETAR Y DESARROLLAR

void vaciarCola(...) <---- COMPLETAR Y DESARROLLAR

void colaVacia(...) <---- COMPLETAR Y DESARROLLAR

//-----
bool pilaVacia (t_pila pila){
return (pila.cab == NULL);
}
//-----
bool colaLlena (t_cola cola){
t_nodo * aux = new t_nodo;
if (aux) {
delete aux;
return false;
} else
return true;
}

t_dato VerPrimero(t_cola cola) {
if (ColaVacia(cola)) {
return -1;
} else {
return cola.frente->dato;
}
}
//----------------------------
t_dato ExtraerPrimero(t_cola cola) {
t_dato valor;
t_nodo * nodo;
if (ColaVacia(cola)) {
cout << "NO HAY DATOS!";
esperar()
return -1;
} else {
nodo = cola.frente;
cola.frente = cola.frente->sig;
if (!cola.frente)
cola.fondo = NULL;
valor = nodo->dato;
delete nodo;
return valor;
}
}
}
//----------------------------
void limpiarPantalla(){
system("cls");
cout<<"***"<<endl<<"TC2 - Tercer examen de avance"<<endl<<"***"<<endl;
}
//----------------------------
void esperar(){
cout<<endl<<"Pulse una tecla para continuar..."<<endl;
getchar();
}

bool EsValido(t_cola cola, t_dato num) {
return (num < VerPrimero(cola));
}
//-----------------------------
void main (){
/*
Definir y e inicializar las estructuras necesarias
Apilar 100 números al azar.
Extraerlos de la pila y, si cumplen con la condición EsValido(cola, numero), encolarlos.
Mostrar por pantalla los números encolados y el valor promedio de los mismos.
Vaciar las estructuras que se necesiten vaciar antes de terminar el programa.
*/
}

[Lobito14]

Pero entonces no has hecho nada¿¿

Ni siquiera lo has empezado a intentar???

Saludos.

[swator]

si,hice todo lo que pude !!!...te lo dejo aca.si podes decirme que es lo que esta mal y guiarme un poco te lo agradeceria.

#include <iostream>
#include <ramdom>

using namespace std;

typedef int t_dato;

typedef struct t_nodo{
t_dato dato;
t_nodo * sig;
};

typedef struct t_pila {
t_nodo *pila;
};

typedef struct t_cola {
t_nodo *frente;
t_nodo *fondo;
};
//----- Rutinas a completar


void encolar(t_cola *&cola, t_dato &dato) <---- COMPLETAR

void desapilar(t_pila *&pila, t_dato &dato) <---- COMPLETAR

bool pilaLlena(t_pila *pila) <---- COMPLETAR

void vaciarPila(t_pila *&pila,t_dato &dato) <---- COMPLETAR

void vaciarCola(t_cola *&cola,t_dato &dato) <---- COMPLETAR

bool colaVacia(t_cola *cola) <---- COMPLETAR

//-----
bool pilaVacia (t_pila pila){
return (pila.cab == NULL);
}
//-----
bool colaLlena (t_cola *cola){
t_nodo * aux = new t_nodo;
if (aux) {
delete aux;
return false;
} else
return true;
}

t_dato VerPrimero(t_cola *cola) {
if (ColaVacia(cola)) {
return -1;
} else {
return cola.frente->dato;
}
}
//----------------------------
t_dato ExtraerPrimero(t_cola *cola) {
t_dato valor;
t_nodo * nodo;
if (ColaVacia(cola)) {
cout << "NO HAY DATOS!";
esperar()
return -1;
} else {
nodo = cola.frente;
cola.frente = cola.frente->sig;
if (!cola.frente)
cola.fondo = NULL;
valor = nodo->dato;
delete nodo;
return valor;
}
}
}
//----------------------------
void limpiarPantalla(){
system("cls");
cout<<"***"<<endl<<"TC2 - Tercer examen de avance"<<endl<<"***"<<endl;
}
//----------------------------
void esperar(){
cout<<endl<<"Pulse una tecla para continuar..."<<endl;
getchar();
}

bool EsValido(t_cola cola, t_dato num) {
return (num < VerPrimero(cola));
}
//-----------------------------
void main (){
/*


t_pila * pilaRamdom;
t_dato dato;
t_dato num;
t_cola * cola;
cola=new t_nodo;
float Acum;
Acum=0;
int Cant;
Cant=0;

if (!(pilaVacia(pilaRamdom))){
apilar (pilaRamdom,dato)
}else{
cout<<"la pila esta vacia"<<endl;
}
if (!(pilaLlena(pilaRamdom))){
desapilar(pilaRamdom,dato)
}else{
cout<<"la pila esta vacia"<<endl;
}
desapilar(pilaRamdom,dato)
if(!(colaLlena (cola))){
encolar(cola,dato);
}
while(!(pilaVacia(pilaRamdom))){
desapilar(pilaRamdom,dato);
if(EsValido(t_cola cola, t_dato num)){
if(!(colaLlena (cola))){
encolar(cola,dato);
desapilar(pilaRamdom,dato);

}
}else{
desapilar(pilaRamdom,dato)

}
} while (!(colaVacia (cola))){
desencolar(cola,dato);
Acum=Acum+cola->frente.dato; //guardo la suma total de los numero de la cola.
Cant++ //guardo la cantidad de numeros.
cout<<cola->frente.dato<<end;//muestro el dato mientras no sea null.
cola=cola->frente *sig //avanzo.
}esperar()
limpiarPantalla();
cout<<"el promedio es :"Acum/Cant<<end;
vaciarCola(cola,dato);
}

Definir y e inicializar las estructuras necesarias
Apilar 100 números al azar.
Extraerlos de la pila y, si cumplen con la condición EsValido(cola, numero), encolarlos.
Mostrar por pantalla los números encolados y el valor promedio de los mismos.
Vaciar las estructuras que se necesiten vaciar antes de terminar el programa.
*/
}
aclaracion:se me mezclaron las llaves

[Lobito14]

Acostúmbrate a poner el código entre las etiquetas de resaltado de sintaxis, no es tan difícil y ayudarás a la lectura del mismo.

El código que has puesto ahí es el mismo que en el primer post, y no veo que hayas comenzado a intentar completar ninguno de los que pone "<---- COMPLETAR" no?

Saludos.

[swator]

hice el main,mas tarde subo esos modulos y me decis como estan.como es lo de la etiqueta?

[Lobito14]

Cuando subas lo que tienes podremos ayudarte a mejorar tu código.

Cuando estás escribiendo tu respuesta, tienes arriba en las opciones un campo de selección con la palabra "Highlight", elijes ahí C++ en este caso, y dentro de las etiquetas pones tu código, para que salga con su resaltado, tabulaciones, etc:

Código C++:

int main(){
    cout << "Hi world\n";
    return 0;
}
 

Un saludo.

[cesar_casla]

como es lo de la etiqueta?

es para poner el codigo, clickea donde dice Highlight, elegi C++ y en el medio escribi todo el codigo

Código C++:

int main() {
 int a=0;
 
return 0;
}
 

Saludos

EDIT: justo respondieron

[swator]

Código C++:

void vaciarPila(t_pila *&pila,t_dato &dato) 
 
    t_nodo* pEli;               //creo un nodo auxiliar.
    if (!pilaVacia(pila)){          //me fijo si esta vacia.
        valor = pila->cabeza->valor;    //al dato le asigno el valor del que desapilo.
        pEli = pila->cabeza;        //al *aux le asigno  el que saco.
        pila->cabeza = pila ->cabeza ->sig;         //al que queda como tope le asigno el sig.
        delete pEli;            //elimino el *aux.
        
    }else 
        cout << "La pila estaba vacia";     //si la pila está vacía.
 
bool colaVacia(t_cola *cola)
 
if (!cola) {                        //pregunto si no hay cola.
        return true;        
    } else {
        return ((cola->frente == NULL)&&(cola->fondo==NULL))//sino pregunto si es NULL.
    }
}
void apilar(t_pila * &pila, const char valor) 
 
    t_nodo *pNuevo;             //creo el nuevo nodo.
    if (!pilaLlena(pila)){              //me fijo si está llena.
    pNuevo = new t_nodo;            
    pNuevo ->valor = valor;             //le asigno el dato al nuevo nodo.
 
    pNuevo -> sig = pila -> cabeza;         //apunto el nuevo al que estaba primero.
    pila -> cabeza = pNuevo;            //apunto el que estaba primero al nuevo 
    }else 
        cout << "No hay espacio para agregar un elemento a la pila";    //si está llena.
 
Void pilavacia(t_pila *&pila,t_dato &dato)
    if (!pila) {                        //pregunto si no hay pila.
        return true;        
    } else {
        return pila->cabeza == NULL;            //sino pregunto si es NULL.
    }
}
 

void vaciarCola(t_cola *&cola,t_dato &dato) <---- COMPLETAR
void encolar(t_cola *&cola, t_dato &dato) <---- COMPLETAR
en estos 2 anteriores la sistematica sería igual que pilas ?

bool pilaLlena(t_pila *pila) en este modulo no encuentro como fijar un el tope o que está llena. Alguna ayudita??

[ElPatoGarrido]

Edito: Para ver si la pila o cola estan llenas, por ejemplo no pueden tener mas de 10 elementos, puedes poner un campo en la struct pila o cola que se valla modificando, por ejemplo un campo que se llame espacios_vacios = 10, cada ves que encolas o apilas un nodo le quitas 1, es decir, apilas cualquier numero y espacios_vacios lo cambias a 9, etc... para ver si esta llena preguntas si es igual a 0 y si es 0 pues pones un mensaje que no se pueden apilar mas nodos, etc...

Por otro lado:

Código C++:

Void pilavacia(t_pila *&pila,t_dato &dato)
    if (!pila) {                        //pregunto si no hay pila.
        return true;       
    } else {
        return pila->cabeza == NULL;            //sino pregunto si es NULL.
    }
}
 

Encuentro que queda mejor:

Código C++:

void pilavacia(t_pila *pila,)
    if (pila)
        return false;       
    else
        return true;
}
 

Ya que si el puntero apunta a NULL devolvera true y si no apunta a NULL quiere decir que apunta a una direccion de memoria 'x' que hace automaticamente que no este vacia.

[swator]

gracias por la info!..pero me faltaria ayuda con los modulos de encolar y desencolar que no encuentro la sistematica.

[swator]

Gracias a todos por la ayuda pude aprobar los 2 examenes!!