Frase palíndroma

---

PilaChar.h

#pragma once

class PilaChar
{
private:
int size;
int cab;//Cabecera de la pila
public:
bool llena;
bool hasElements;


struct structPila
{
wchar_t dato;
} *pila;

public:
PilaChar(int tam); //Constructor
bool push(wchar_t xdato);
wchar_t pop ();
wchar_t top ();
int length();
wchar_t *getPila();
};

---

PilaChar.cpp

#include "StdAfx.h"
#include "PilaChar.h"

PilaChar::PilaChar(int tam)
{
size = tam;
cab = -1; //Cabecera apunta a -1, entonces no hay elementos en la pila
pila = new structPila[size];

llena = false;
hasElements = false;
}

//Inserta un elemento en la pila
bool PilaChar::push(wchar_t xdato)
{
if(llena)
return false;
else
{
cab++;
pila[cab].dato = xdato;

hasElements = true;

if(cab == size-1)
llena = true;
}
}

//Extrae el elemento de la cabecera de la pila
wchar_t PilaChar::pop()
{
if(hasElements)
{
wchar_t dato_out = top();
cab--;

llena = false;

if(cab<0)
hasElements = false;

return dato_out;
}
else
return '\0';
}

//Muestra el elemento de la cabecera de la pila
wchar_t PilaChar::top()
{
if(hasElements)
return pila[cab].dato;
else
return '\0';
}

int PilaChar::length()
{
return cab+1;
}

wchar_t *PilaChar::getPila()
{
wchar_t *pilaGeted = new wchar_t[cab+1];

int j=cab;

for(int i=0;i<=cab;i++)
{
pilaGeted[j] = pila[i].dato;
j--;
}

return pilaGeted;
}

---

Descargar la solución completa de Pilas

Ruta de ida y vuelta

---

PilaString.h

#pragma once

class PilaString
{
private:
int size;
int cab;//Cabecera de la pila
public:
bool llena;
bool hasElements;

struct structPila
{
wchar_t *dato;
int tam;//Tamaño de cada elemento
} *pila;

public:
PilaString(int); //Constructor
bool push(System::String^ dato);
System::String^ pop ();
System::String^ top ();
int length();
System::String^ getPila ();
};

---

PilaString.cpp


#include "StdAfx.h"
#include "PilaString.h"

PilaString::PilaString(int tam)
{
size = tam;
cab = -1; //Cabecera apunta a -1, entonces no hay elementos en la pila
pila = new structPila[size];

llena = false;
hasElements = false;
}

//Inserta un elemento en la pila
bool PilaString::push(System::String^ dato)
{
if(llena)
return false;
else
{
cab++;
pila[cab].tam = dato->Length;
pila[cab].dato = new wchar_t[pila[cab].tam];

//Convertimos el string en un arreglo de caracteres!
for(int i=0;i<pila[cab].tam;i++)
pila[cab].dato[i] = dato[i];

hasElements = true;

if(cab == size-1)
llena = true;

return true;
}
}

//Extrae el elemento de la cabecera de la pila
System::String^ PilaString::pop()
{
if(hasElements)
{
System::String^ cadena = top();
cab--;

llena = false;

if(cab<0)
hasElements = false;

return cadena;
}
else
return "La pila está vacía";

}

//Muestra el elemento de la cabecera de la pila
System::String^ PilaString::top()
{
if(hasElements)
{
System::String^ cadena;

//Convertimos el arreglo de caracteres en un string !
for(int i=0;i<pila[cab].tam ;i++)
cadena += pila[cab].dato[i];

return cadena;
}
else
return "La pila está vacía";

}

int PilaString::length()
{
return cab+1;
}

System::String^ PilaString::getPila()
{
System::String^ pilaGeted = "";

for(int i=cab;i>=0;i--)
{
for(int j=0;j<pila[i].tam ;j++)
pilaGeted += pila[i].dato[j];

pilaGeted+="\r\n";//Salto de línea;
}

return pilaGeted;
}

---

Descargar la solución completa de Pilas

Listas simples

---

ListaChar.h

#pragma once

class ListaChar
{
private:
int cab;
int lib;
public:
int capacidad;

struct structLista
{
wchar_t dato;
int ptr;
}*lista;

public:
ListaChar(int);
bool agregar(wchar_t);
int buscar(wchar_t,int);
bool eliminar(wchar_t);
bool editar(wchar_t,wchar_t);
int length();
wchar_t *getLista();
};

---

ListaChar.cpp


#include "StdAfx.h"
#include "ListaChar.h"

ListaChar::ListaChar(int size)
{
lista = new structLista[size];
capacidad=size;

cab=999;
lib=0;
for(int k=0;k<size;k++)
{
lista[k].dato=' ';
lista[k].ptr=k+1;
}
lista[size-1].ptr=999;
}

bool ListaChar::agregar(wchar_t xdato)
{
if(length()!=capacidad)
{
lista[lib].dato=xdato;
if(cab==999)
{
cab=lib;
lib=lista[lib].ptr;
lista[cab].ptr=999;
}
else
{
int xptr=cab;

while(lista[xptr].ptr!=999)
xptr=lista[xptr].ptr;

int xlib=lib;
lista[xptr].ptr=lib;
lib=lista[xlib].ptr;
lista[xlib].ptr=999;
}
return true;
}
else
return false;
}

int ListaChar::buscar(wchar_t xdato,int xtipo)
{
int xptr=cab;
int xant=xptr;
int xExiste=0;

while(xptr!=999 && !xExiste)
{
if(lista[xptr].dato==xdato)
xExiste=1;
else
{
xant=xptr;
xptr=lista[xptr].ptr;
}
}

if(xExiste)
{
if(xtipo==0)
return xant;
else
return xptr;
}
else
return 999;
}

bool ListaChar::eliminar(wchar_t xdato)
{
int xptr=buscar(xdato,1);

if(length()>0)
{
if(xptr!=999)
{
int xant=buscar(xdato,0);
if(xant==xptr)
{
cab=lista[cab].ptr;
lista[xptr].ptr=lib;
lib=xptr;
}
else
{
lista[xant].ptr=lista[xptr].ptr;
lista[xptr].ptr=lib;
lib=xptr;
}

return true;
}
else
return false;
}
else
return false;
}

bool ListaChar::editar(wchar_t xdato,wchar_t ndato)
{
int xptr=buscar(xdato,1);

if(xptr!=999)
{
lista[xptr].dato=ndato;
return true;
}
else
return false;
}

int ListaChar::length()
{
int index=0;

int xptr=cab;

while(xptr!=999)
{
index++;
xptr=lista[xptr].ptr;
}

return index;

}

wchar_t *ListaChar::getLista()
{
wchar_t *listado = new wchar_t[length()];

int index=0;

int xptr=cab;

while(xptr!=999)
{
listado[index]=lista[xptr].dato;
index++;

xptr=lista[xptr].ptr;
}

return listado;
}

---

Descargar la solución completa de Listas