Un Primer Programa usando Listas Enlazadas

#include < iostream.h >
#include < stdio.h >
#include < conio.h >
struct nodo
{int dato;
nodo *sig;}
*inicio, * final;

void crear_lista (int num)
{nodo *nuevo;
nuevo = new(nodo);
nuevo->dato = num;
inicio = final = nuevo;
final->sig = NULL;}

void insertar_inicio (int num)
{nodo *nuevo;
nuevo = new(nodo);
nuevo->sig = inicio;
nuevo->dato = num;
inicio = nuevo;}

void insertar_final (int num)
{nodo *nuevo;
nuevo = new(nodo);
final->sig = nuevo;
nuevo->sig = NULL;
nuevo->dato = num;
final = nuevo;}

void insertar_n (int num)
{nodo *temp, *nuevo;
temp=inicio;
while (temp->sig->dato{temp=temp->sig;}
nuevo=new(nodo);
nuevo->sig=temp->sig;
temp->sig=nuevo;
nuevo->dato=num;}

void imprimir_lista()
{nodo *temp;
temp = inicio;
while (temp!=NULL)
{cout<dato<temp = temp->sig;}
getch();}

void main ()
{clrscr();
int numero,cuantos;
cout<<"Cuantos numeros va a ingresar: ";
cin>>cuantos;
crear_lista(1);
for (int x=0; x < cuantos;x++)
{cout<<"ingrese numero: ";
cin>>numero;
if (numero<=inicio->dato)
insertar_inicio(numero);
else
if (numero>=final->dato)
insertar_final(numero);
else
insertar_n(numero);}
imprimir_lista();}

Operaciones con Listas Enlazadas

A cotinuación se muestran los algoritmos para realizar operaciones básicas con listas enlazadas.

Crear la lista:

1. Crear nuevo nodo.
2. Meter un dato al nuevo.
3. El Final es igual al Inicio.
4. El Final es igual al nuevo.
5. El Inicio es igual al nuevo.
6. El siguiente del finales NULL.

Insertar nuevo dato al final:

1. Crear nuevo nodo.
2. Meterle el dato al nuevo.
3. El Final le apunta al nuevo.
4. El nuevo le apunta a NULL.
5. El Fina es el nuevo.

Insertar nuevo dato al inicio:

1. Crear nuevo nodo.
2. Meterle dato al nodo.
3. El nuevo apunta a Inicio.
4. El Inicio es el nuevo.

Borrar el Inicio

1. Colocar un temporal en el inicio.
2. Mover el Inicio al siguiente.
3. Borrar temporal.

Borrar el Final.

1. Colocar temporal al inicio.
2. Mover temporal hasta que llegue una posición antes del final. Si el siguiente no es final mover temporal al siguiente.
3. Borrar Final.
4. Mover Final al temporal.
5. Final le apunta a NULL.

Listas Enlazadas (Memoria Dinámica)

Al utilizar listas enlazadas, la cantidad de datos se ajusta a la cantidad de memoria.

Ejemplo de una Estructura:

struct a
{
int num
char letra
}

Ejemplo de un programa usando Pilas y Colas

Encabezado:

Librerias Predefinidas

//Prototipos
int sacarpila();
void meterpila(int);
int pilavacia();
int pilallena();
int sacarcola();
void metercola(int);
int colavacia();
int colallena();

//Variables globales
int tope=0;
int pila[10];
int tope2=0;
int cola[10];

//Programa principal
void main()
{
clrscr();
meterpila(10);
meterpila(8);
meterpila(7);
cout << sacarpila()<< endl;
cout<< sacarpila()<< endl;
cout<< sacarpila()<< endl;
metercola(7);
metercola(8);
metercola(10);
cout<< sacarcola()<< endl;
cout<< sacarcola()<< endl;
cout<< sacarcola()<< endl;
getch();
}

//Pilas
//Meter un dato
void meterpila(int numero)
{
if (!pilallena())
{
pila[tope]=numero;
tope++;
}
else
{
cout<< "Error, pila llena";
}
}

//Verificar que no este llena la pila para poder meter los datos
int pilallena()
{
if (tope==10)
{
return (1);
}
else
{
return (0);
}
}

//Sacar un dato
int sacarpila()
{
if (!pilavacia())
{
tope--;
int dato=pila[tope];
return(dato);
}
else
{
return(-1);
}
}

//Verificar que la pila tenga datos
int pilavacia()
{
if (tope<0)
{
return (1);
}
else
{
return (0);
}
}

Estructuras de Datos: Pilas y Colas

Pila: (LIFO) Last In First Out
Ultimo dato en entrar, primero en salir.

Cola: (FIFO) First In First Out
Primer dato en entrar, primero en salir.

Operaciones:

Push: Meter un dato.
Pop: Sacar un dato.
Vacia: Ya no hay datos a sacar.
Llena: Ya no hay espacio para otro dato.

Tipos de datos en C

Los tipos de datos básicos definidos por C son caracteres, números enteros y números en coma flotante. Los caracteres son representados por char, los enteros por short, int, long y los números en coma flotante por float y double. Los tipos básicos disponibles y su tamaño son:

char: Carácter – un solo byte.
int: Números enteros generalmente entre el -32768 al 32768.
float: Números con punto flotante generalmente de 10-38 a 1038.
short: Entero corto.
long: Entero largo.
double: Punto flotante de doble precisión.

Sintaxis Básica General de un programa en C

#include < librerías_predefinidas.h >
#include “librerías propias”
Declaración_de_prototipos
funciones ()
void main()
{
}