PILAS

// Pilas
#include <iostream>
#include <windows.h>
#include <string.h>
using namespace std;

struct Nodo{
int dato;
Nodo *siguiente;

};
void cargarPila(Nodo*&, int );
void quitarPila(Nodo*&, int & );
main( ){
int dato;
Nodo *pila = NULL;
char op;
do{
system("pause");
system("cls");
cout<<"Ingrese un numero \n -> ";
cin>>dato;
cargarPila ( pila, dato );
cout<<"\n\tDesea ingresar otro dato S/si N/no \n -> ";
cin>>op;
}while((op=='S')||(op=='s'));
cout<<"LA PILA CARGADA ES : "<<endl;
while(pila!=NULL){
quitarPila(pila, dato );
if(pila!=NULL){
cout<<dato<<endl;

}else{
cout<<dato<<endl;
cout<<"Fin de la Pila..."<<endl;
}
}

system("pause");
}
void cargarPila(Nodo*& pila, int dato ){
Nodo *n_nodo = new Nodo();
n_nodo -> dato = dato;
n_nodo -> siguiente = pila;
pila = n_nodo;
cout<<"Elemento "<<dato<<" cargado correctamente "<<endl;

void quitarPila(Nodo*& pila, int & dato ){

Nodo *aux = pila;
dato = pila -> dato;
pila = aux -> siguiente;
delete aux;
}

COLAS

void cargarCola(Nodo*& frente,Nodo*& fin,string nombre ){

Nodo *n_nodo = new Nodo();
n_nodo -> dato = nombre;
n_nodo -> siguiente = NULL;
if(colaVacia(frente)){
frente = n_nodo;
}else{
fin -> siguiente = n_nodo;
}
fin = n_nodo;
cout<<"Elemento cargado correctamente "<<endl;
}
bool colaVacia (Nodo*& frente){
if(frente == NULL){
return true;
}else{
return false;
}
}
void quitarCola(Nodo*& frente,Nodo*& fin,string& nombre){
nombre = frente -> dato;
Nodo *aux = frente;

if(frente == fin){
frente = NULL;
}else{
frente = frente -> siguiente;
}
delete aux;
}
Bibliotecas

#include<iostream>
#include <windows.h>
#include <string.h>
// bibliotecas para generar numeros randoms
#include <time.h>
#include <cstdlib>
using namespace std ;
int main(){
// srand((unsigned)time(NULL));
// n=int(rand()%(10-100))+10;
srand ((unsigned)time(NULL));
n=int(rand()%(10-100))+10;
n=int(rand()%(ls-li))+li;
}

INVERTIR VECTORES USANDO PILAS

#include <iostream>
#include <windows.h>
#include <stdio.h>

using namespace std;

struct Nodo{
int nro;
Nodo *siguiente;
};
int elementos();
void CargarVector(int*,int);
void MostrarVector(int*,int);
void AgregarPila(Nodo *&,int);

main(){
int *vector;
Nodo *pila = NULL;
int li = elementos();
vector = new int [li];
system("cls");
CargarVector(vector,li);
system("cls");
cout<<"\n Vector original:\n";
MostrarVector(vector,li);
for(int i=0; i<li; i++){
AgregarPila(pila,vector[i]);
}
for(int i=0; pila != NULL; i++){
vector[i] = pila->nro;
pila = pila->siguiente;
}
cout<<"\n Vector inverdito:\n";
MostrarVector(vector,li);
system("pause");
}
void AgregarPila(Nodo *& pila,int n){
Nodo *nuevoNodo = new Nodo();
nuevoNodo->nro = n;
nuevoNodo->siguiente = pila;
pila = nuevoNodo;
}
int elementos(){
int li;
cout<<" Definir vector:\n";
cout<<"========================================\n";
do{
cout<<"Cantidad de elementos del vector -> ";
cin>>li;
fflush(stdin);
if(li<1){
cout<<"ERROR: Valor no puede ser menor 0\n";
}
}while(li<1);
cout<<"========================================\n";
system("pause");
return li;
}
void CargarVector(int *vector,int li){
cout<<" Cargar vector:\n";
cout<<"========================================\n";
for(int i = 0; i < li; i++){
cout<<"Elemento "<<i+1<<" -> ";
cin>>vector[i];
 fflush(stdin);
}
cout<<"========================================\n";
system("pause");
}
void MostrarVector(int *vector,int li){
cout<<"========================================\n";
for(int i = 0; i < li; i++){
printf("[ %d ] ",vector[i]);
}
cout<<"\n========================================\n";
}

MATRICES CON PILAS

#include <iostream>
#include <windows.h>
#include <stdio.h>

using namespace std;

struct Nodo{
int nro;
Nodo *siguiente;
};
void CargarPila(Nodo *&,int);
void ApagarPila(Nodo *&);
void CargarMatriz(int **,int,int,Nodo *);
void MostrarMatriz(int **,int,int);

main(){
char op;
int **matriz;
matriz = new int *[6];
for(int i=0;i<6;i++){
matriz[i] = new int [5];
}
Nodo *pila = NULL;
do{
system("cls");
cout<<" Cargar matriz 6x5:\n";
CargarMatriz(matriz,6,5,pila);
system("cls");
cout<<" Matriz 6x5:\n";
MostrarMatriz(matriz,6,5);

cout<<"\nRepetir(S/N)? ";
cin>>op;
fflush(stdin);
}while((op =='s') || (op == 'S'));
for(int f=0; f<6; f++){
delete [] matriz[f];
}
delete [] matriz;
system("pause");
}
void CargarMatriz(int **matriz, int liF, int liC, Nodo *pila){

for(int f = 0; f < liF; f++){

 printf("Fila %d:\n",f+1);
for(int c = 0; c < liC; c++){
if(f%2==0){
printf("Elemento [%d] [%d] -> ",f+1,c+1);
cin>>matriz[f][c];
fflush(stdin);
CargarPila(pila,matriz[f][c]);
}else{
matriz[f][c] = pila->nro;
printf("Elemento [%d] [%d] -> %d\n",f+1,c+1,matriz[f][c]);
ApagarPila(pila);
}
}
}

system("pause");
}
void CargarPila(Nodo *&pila,int n){
Nodo *nuevoElemento = new Nodo();
nuevoElemento->nro = n;
nuevoElemento->siguiente = pila;
pila = nuevoElemento;
}
void ApagarPila(Nodo *&pila){
int *naux;
Nodo *aux = pila;
naux = &aux->nro;
pila = aux->siguiente;
delete naux;
delete aux;
}
void MostrarMatriz(int **matriz,int liF,int liC){

for(int f = 0; f < liF; f++){

for(int c = 0; c < liC; c++){
printf(" [%d]\t",matriz[f][c]);
}
cout<<endl;
}

system("pause");
}

PERIMETRO DE UNA MATRIZ

/*Ejercicio 8)
) Crear y cargar una matriz M.
Imprimir la matriz y el perímetro del mismo
como se muestra en la figura.*/
#include <iostream>
# include <windows.h>

using namespace std ;

int main ( ){
int lf,lc,suma=0;
cout<<"Ingrese la cantidad de filas: "<<endl;
cin>>lf;
cout<<"Ingrese la cantidad de columnas: "<<endl;
cin>>lc;
 while((lf<=0)||(lc<=0)){
cout<<"ERROR: Intente de nuevo: "<<endl;
cout<<" Ingrese limite de Filas -> ";
cout<<" Ingrese limite de Columnas -> ";cin>>lc;
}
int M[5][4];

for(int f=0;f<lf;f++){
for(int c=0;c<lc;c++){
cout<<"Ingrese un numero para la posicion
("<<f+1<<","<<c+1<<") ";
cin>>M[f][c];

}
}
system("pause");
system("cls");
cout<<"La Matriz Cargada es "<<endl;
for(int f=0;f<lf;f++){
for(int c=0;c<lc;c++){
cout<<M[f][c]<<"\t";
}
cout<<endl;
}
//PERIMETRO DE LA MATRIZ
for(int f=0;f<lf;f++){
for(int c=0;c<lc;c++){
if (f==f){ // no se toca
suma=suma+M[f][c];
}
if (c==c+1){
suma=suma+M[f][c];
}
}
cout<<endl;
}
cout<<"La Suma del perimetro de la Matriz es:
"<<suma<<endl;

system("pause");
return 0;
}