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()
{
}

Estructura Básica de un programa en C

La mejor y más conveniente forma de aprender un lenguaje de programación es simplemente programando con él. El programa más sencillo que se puede escribir en C es el siguiente:

main( )
{
}

Este programa no hace nada, simplemente contiene la parte más importante de cualquier programa C, además también es el más pequeño que se puede escribir y que se compile correctamente. En este programa se define la función main, que es la que ejecuta el SistemaOoperativo al llamar a un programa C. El nombre de una función C siempre va seguida de paréntesis, tanto como si tiene argumentos como si no. La definición de la función está formada por un bloque de sentencias, dicho bloque está encerrado entre llaves {}.

Historia

C es un lenguaje de programación creado en 1969 por Ken Thompson y Dennis M. Ritchie en los Laboratorios Bell como evolución del anterior lenguaje llamado B, aapareció en 1972, a su vez basado en BCPL Basic Combined Programming Language (Lenguaje de Programación Básico Combinado). Al igual que B, C es un lenguaje orientado a la implemetación de Sistemas Operativos, concretamente Unix. C es un lenguaje preciado por la eficiencia del código que produce y es el lenguaje de programación más popular para crear software de sistemas, aunque también se utiliza para crear aplicaciones.

Se trata de un lenguaje débilmente tipado de medio nivel pero con muchas características de bajo nivel. Dispone de las estructuras típicas de los lenguajes de alto nivel pero, a su vez, dispone de construcciones del lenguaje que permiten un control a muy bajo nivel. Los compiladores suelen ofrecer extensiones al lenguaje que posibilitan mezclar código en ensamblador con código C o acceder directamente a memoria o dispositivos perféricos.

Introducción

C es un lenguaje de programación de propósito general que ofrece economía sintáctica, control de flujo, estructuras sencillas y un buen conjunto de operadores. No es un lenguaje de muy alto nivel y más bien un lenguaje pequeño, sencillo y no está especializado en ningún tipo de aplicación. Esto lo hace un lenguaje potente, con un campo de aplicación ilimitado y sobre todo, se aprende rápidamente. En poco tiempo, un programador puede utilizar la totalidad del lenguaje.