void eliminarNodo(ListaPiso &listaP, PtrNodoPiso ptrNodoP){
PtrNodoPiso ptrPrevio;
/* verifica que la lista no esté vacia y que nodo no sea fin*/
if ((! listaVacia(listaP)) && (ptrNodoP != finP())) {
if (ptrNodoP == primero(listaP))
listaP.primeroPiso = siguiente(listaP,primero(listaP));
else {
ptrPrevio = anterior( listaP , ptrNodoP );
ptrPrevio->sgteP = ptrNodoP->sgteP;
}
// Si el dato es un TDA, acá habría que llamar al destructor.
destruir(ptrNodoP->pilUb);
delete ptrNodoP;
}
}
//*******************
void eliminarNodo(ListaArtDeposito &listaArtDep,PtrNodoListaDeposito ptrNodoListaDep){
PtrNodoListaDeposito ptrPrevio;
/* verifica que la lista no esté vacia y que nodo no sea fin*/
if ((! listaVacia(listaArtDep)) && (ptrNodoListaDep != finAD())) {
if (ptrNodoListaDep == primero(listaArtDep))
listaArtDep.primerArtDeposito = siguiente(listaArtDep,primero(listaArtDep));
else {
ptrPrevio = anterior( listaArtDep , ptrNodoListaDep );
ptrPrevio->sgteAD= ptrNodoListaDep->sgteAD;
}
// Si el dato es un TDA, acá habría que llamar al destructor.
delete ptrNodoListaDep;
}
}
//********************
PtrNodoListaDeposito anterior(ListaArtDeposito &listaArtDep,PtrNodoListaDeposito ptrNodoListaDep){
PtrNodoListaDeposito ptrPrevio = finAD();
PtrNodoListaDeposito ptrCursor = primero(listaArtDep);
while (( ptrCursor != finAD()) && (ptrCursor != ptrNodoListaDep)) {
ptrPrevio = ptrCursor;
ptrCursor = siguiente(listaArtDep,ptrCursor);
}
return ptrPrevio;
}
void InsertarHash (char *cad,TablaHash t)
{
int pos;
if (MiembroHash(cad,t))
return;
pos=Hash(cad);
insertar(cad,primero(t[pos]),t[pos]);
}
PtrNodoPiso anterior(ListaPiso &listaP, PtrNodoPiso ptrNodoP){
PtrNodoPiso ptrPrevio = finP();
PtrNodoPiso ptrCursor = primero(listaP);
while (( ptrCursor != finP()) && (ptrCursor != ptrNodoP)) {
ptrPrevio = ptrCursor;
ptrCursor = siguiente(listaP,ptrCursor);
}
return ptrPrevio;
}
PtrNodoPiso adicionarAntes(ListaPiso &listaP, PilUb pilUb, PtrNodoPiso ptrNodoP){
PtrNodoPiso ptrNuevoNodo = finP();
if (! listaVacia(listaP)) {
if (ptrNodoP != primero(listaP))
ptrNuevoNodo = adicionarDespues(listaP,pilUb,anterior(listaP,ptrNodoP));
else
ptrNuevoNodo = adicionarPrincipio(listaP,pilUb);
}
return ptrNuevoNodo;
}
void BorrarHash (char *cad,TablaHash t)
{
tPosicion p;
int pos=Hash(cad);
p=primero(t[pos]);
while (p!=fin(t[pos]) && !strcmp(cad,elemento(p,t[pos])))
p=siguiente(p,t[pos]));
if (p!=fin(t[pos]))
borrar(p,t[pos]);
}
/*
* Programa principal
*/
int main(void)
{
char *nombre[] = { "Rosa", "María", "Pepe", "Carlos", "Juan", "Antonio", NULL };
int i;
TipoCola colaPeluqueria;
TipoElemento *cliente;
/* Dar valor a los miembros de la cola */
crearVacia(&colaPeluqueria);
/* Insertar clientes */
printf("\n");
for (i=0; NULL!=nombre[i]; i++) {
cliente=malloc(sizeof(struct Cliente));
if (NULL!=cliente) {
strcpy(cliente->nombre,nombre[i]);
insertar(&colaPeluqueria,*cliente);
printf("ha llegado un cliente de nombre %s...\n",
nombre[i]);
}
}
/* Extraer clientes */
printf("\n");
cliente=primero(colaPeluqueria);
while (NULL!=cliente) {
printf("se sirve al cliente de nombre %s...\n",
cliente->nombre);
quitar(&colaPeluqueria);
cliente=primero(colaPeluqueria);
}
return (0);
}
void guardarEnArchivos(Lista &Candidatos, Lista &Partidos, Lista &Mesa)
{
FILE *fileCandi, *filePart, *fileMesa;
PtrNodoLista nodo;
//Guardo Mesas
if((fileMesa=fopen("mesas.txt", "w"))!=NULL)
{
nodo = primero(Mesa);
while (nodo != fin())
{
fprintf(fileMesa,"%d;%d\n", getIdMesa(*(Mesas*)nodo->ptrDato),getProvinciaMesa(*(Mesas*)nodo->ptrDato) );
nodo = siguiente(Mesa, nodo);
}
} else{puts("El archivo mesas.txt no pudo ser creado");}
//Guardo Candidatos
if((fileCandi=fopen("candidatos.txt", "w"))!=NULL)
{
nodo = primero(Candidatos);
while (nodo != fin())
{
fprintf(fileCandi,"%d;%s;%d\n", getIdCandidato(*(Candidato*)nodo->ptrDato),getNombreCandidato(*(Candidato*)nodo->ptrDato),getPartidoPolitico(*(Candidato*)nodo->ptrDato) );
nodo = siguiente(Candidatos, nodo);
}
} else{puts("El archivo candidatos.txt no pudo ser creado");}
//Guardo Partidos
if((filePart=fopen("partidos.txt", "w"))!=NULL)
{
nodo = primero(Partidos);
while (nodo != fin())
{
fprintf(filePart,"%d;%s\n", getIdPartido(*(Partido*)nodo->ptrDato),getNombrePartido(*(Partido*)nodo->ptrDato) );
nodo = siguiente(Partidos, nodo);
}
} else{puts("El archivo partidos.txt no pudo ser creado");}
}
tPosicion posicion (tElemento x, tLista l)
{
tPosicion p;
int encontrado;
p = primero(l);
encontrado = 0;
while ((p->siguiente != NULL) && (!encontrado)) {
if (p->siguiente->elemento == x)
encontrado=1;
else p = p->siguiente;
}
return p;
}
int MiembroHash (char *cad,TablaHash t)
{
tPosicion p;
int enc;
int pos=Hash(cad);
p=primero(t[pos]);
enc=0;
while (p!=fin(t[pos]) && !enc) {
if (strcmp(cad,elemento(p,t[pos]))==O)
enc=1;
else
p=siguiente(p,t[pos]);
}
return enc;
}
int main(int argc, char* argv[]) {
if (argc != 3)
return 1;
std::string primero(argv[1]);
std::string segundo(argv[2]);
size_t pos = std::string::npos;
int i = 0;
do {
pos = primero.find(segundo, pos+1);
++i;
} while (pos != std::string::npos && i < OCURRENCIA);
if (pos != std::string::npos)
primero.erase(pos, segundo.size());
std::cout << primero << std::endl;
return 0;
}
//********************
void eliminarNodoPrimero(ListaArtDeposito &listaArtDep){
if (! listaVacia(listaArtDep))
eliminarNodo(listaArtDep,primero(listaArtDep));
}
elemento cola :: frente(){
elemento e=primero();
return(e);
}
bool listaVacia(ListaPiso &listaP){
return (primero(listaP) == finP());
}
//********************
void eliminarLista(ListaArtDeposito &listaArtDep){
while (! listaVacia(listaArtDep))
eliminarNodo(listaArtDep,primero(listaArtDep));
}
void eliminarLista(ListaPiso &listaP){
while (! listaVacia(listaP))
eliminarNodo(listaP,primero(listaP));
}
void eliminarNodoPrimero(ListaPiso &listaP){
if (! listaVacia(listaP))
eliminarNodo(listaP,primero(listaP));
}
//********************
bool listaVacia(ListaArtDeposito &listaArtDep){
return (primero(listaArtDep)==finAD());
}
