Actividad 1: Arreglos

/*programa que determina el total de trabajadores con salario

menor a 5000 */
#include<stdio.h>
#include<conio.h>

int N, Smen5000;
void Datos_tr (int X, int N[], float S[]);
int Men5000 (int X, float S[]);
void Lista_tr (int X, int N[], float S[]);

main ()
{
do
{
printf("Cuantos trabajadores? [>1]: ");
scanf("%d", &N);
}while(N<1);
int NT [N];
float ST[N];
Datos_tr (N,NT,ST);
Smen5000=Men5000(N,ST);
printf("\nLista de trabajadores");
Lista_tr(N,NT,ST);
printf("\nTotal: %d",Smen5000);
printf("\nOprima cualquier tecla");
getch();
return(0);
} //Main

void Datos_tr(int X, int N[],float S [])

{
int i;
for(i=0; i<X; i++)
{
do
{
printf("\nDa el numero que corresponde al trabajador %d: ",
i+1);
scanf("%d", &N[i]);
}while(N[i]<1);
do
{
printf("\nDa su salario: ");
scanf("%f", &S[i]);
}while (S[i]<0);
}
} //Datos_tr

int Men5000(int X, float S[])

{
int c, i;
c=0;
for(i=0;i<X;i++)
if(S[i]<5000)
c++;
return (c);
} //Men5000

void Lista_tr(int X, int N[], float S[])

{
int i;
for(i=0;i<X;i++)
printf("\nNumero: %d \t salario: %.2f",N[i],S[i]);
} //Lista_tr

Actividad 2: Punteros
#include <stdio.h>
#include <conio.h>

int x, y, z, suma, *ap;

main(){
ap=&x;
printf("Da valor para x: ");
scanf("%d", ap);
printf("\nDa valor para y: ");
scanf("%d", ap+1);
printf("\nDa valor para z: ");
scanf("%d", ap+2);
*(ap+3)=*ap+(*(ap+1))+(*(ap+2));
printf("\nx = %d\
\ny = %d\
\nz = %d\
\nsuma = %d\
", *ap, *(ap+1), *(ap+2), *(ap+3));
getch();
return 0;
}
Actividad 3: Pilas
#include <stdio.h>
#include <stdlib.h>
#define MAXTAM 5

struct pila{
int elem[MAXTAM];
int top;
}s;

void insertar();
void sacar();
void mostrar();
int conf();

main(){
int op, cont=1;
s.top=-1;
printf("\n\t\t\tPROGRAMA DE EJEMPLO DE IMPLEMENTACION DE PILAS\n");
while(cont){
printf ("\t\t\t------------------------------------------\n\
1. Insertar \n\
2. Sacar \n\
 3. Mostrar/Imprimir \n\
4. Salir \n\
------------------------------------------\n\
Opcion elegida: ");
scanf("%d", &op);
switch(op){
case 1: insertar(); break;
case 2: sacar(); break;
case 3: mostrar(); break;
case 4: cont=0; break;
default: cont=0; break;
}
system("cls");
}
}

int conf(){
int a;
printf("\n\t\tConfirmar accion: (1. Si || 2. No)"); scanf("%d", &a);
return (a==1)? 1: 0;
}

void insertar(){
system("cls");
int num;
if(s.top==(MAXTAM-1))
printf("\n\tTamaño maximo alcanzado\n");
else{
printf("\n\tInserte el elemento a insertar: "); scanf("%d",&num);
if(conf())
s.top++; s.elem[s.top]=num;
}
system("pause");
}

void sacar(){
system("cls");
int num;
if(s.top==-1)
printf("\n\tPila esta vacia");
else{
num=s.elem[s.top];
printf("\n\tElemento que se va a sacar: %d", s.elem[s.top]);
if(conf()){
s.top--;
}
}
system("pause");
}

void mostrar(){
system("cls");
int i;
if(s.top==-1)
printf("\n\n\t\tPila esta vacia\n\n\t\t");
else{
printf("\n\n\t\t Elementos en la lista: ");
for(i=s.top;i>=0;i--){
 printf("\n\n\t\t\t%d", s.elem[i]);
}
s.top=-1;
}
printf("\n\n\t\t");
system("pause");
}
Actividad 4: Colas
#include <stdio.h>
#include <stdlib.h>
#define MAXTAM 5

struct cola{
int elem[MAXTAM];
int top;
int back;
}s;

void insertar();
void sacar();
void mostrar();
int conf();

main(){
int op, cont=1;
s.top=-1;
s.back=-1;
printf("\n\t\t\tPROGRAMA DE EJEMPLO DE IMPLEMENTACION DE COLAS\n");
while(cont){
printf ("\t\t\t------------------------------------------\n\
1. Insertar \n\
2. Sacar \n\
3. Mostrar/Imprimir \n\
4. Salir \n\
------------------------------------------\n\
Opcion elegida: ");
scanf("%d", &op);
switch(op){
case 1: insertar(); break;
case 2: sacar(); break;
case 3: mostrar(); break;
case 4: cont=0; break;
default: cont=0; break;
}
system("cls");
}
}

int conf(){
int a;
printf("\n\t\tConfirmar accion: (1. Si || 2. No)"); scanf("%d", &a);
return (a==1)? 1: 0;
}

void insertar(){
system("cls");
int num;
 if(s.back==(MAXTAM-1))
printf("\n\tTamaño máximo alcanzado\n");
else{
if(s.top==-1)
s.top=0;
printf("\n\tInserte el elemento a insertar: "); scanf("%d",&num);
if(conf()){
s.back++;
s.elem[s.back]=num;
}
}
system("pause");
}

void sacar(){
system("cls");
int num;
if(s.top==-1||s.top>s.back)
printf("\n\tCola esta vacia");
else{
printf("\n\tElemento que se va a sacar: %d", s.elem[s.top]);
if(conf())
s.top++;
}
system("pause");
}

void mostrar(){
system("cls");
int i;
if(s.top==-1)
printf("\n\n\t\tCola esta vacia\n\n\t\t");
else{
printf("\n\n\t\t Elementos en la lista: ");
for(i=s.top;i<=s.back;i++)
printf("\n\n\t\t\t%d", s.elem[i]);
}
printf("\n\n\t\t");
system("pause");
}
Actividad 5: Listas
#include <cstdlib>
#include <iostream>
#include <iomanip>
#include <list>

using namespace std;

int main(int argc, char *argv[])

{
list<double> lalista;
double num, suma=0;

cout << "Sumadora sencilla" << endl;

do
{
 cout << "Ingrese un numero, 0 para salir: ";
cin >> num;
if (num != 0) lalista.push_back(num);
}
while (num != 0);

cout << "----------" << endl;

while( !lalista.empty() )
{
num = lalista.front();
cout << setw(10) << num << endl;
suma += num;
lalista.pop_front();
}
cout << "----------" << endl;

cout << setw(10) << suma << endl;

system("PAUSE");
return EXIT_SUCCESS;
}
Actividad 6: Ordenamiento
#include <cstdlib>
#include <iostream>
#include <iomanip>
#include <list>

using namespace std;

// ejemplo método sort

void ordenar()
{
list <int> lalista;

for (int i=0; i < 10; i++)

{
int x=0;
cout<<"Ingrese un numero: ";
cin>>x;
lalista.push_back(x);
}

list<int>::iterator it = lalista.begin();
cout << "Orden original" << endl;
while( it != lalista.end() )
{
cout << setw(10) << *it++ << endl;
}

lalista.sort();
it = lalista.begin();
cout << "Orden ascendente" << endl;
while( it != lalista.end() )
{
cout << setw(10) << *it++ << endl;
}
}

int main(int argc, char *argv[])

{
ordenar();
system("PAUSE");
return EXIT_SUCCESS;
}
Actividad 7: Búsqueda
#include <cstdlib>
#include <iostream>
#include <list>

using namespace std;

// Ejemplo: buscar e insertar

void insertar()
{
list <string> nombres;

nombres.push_back("Juan");
nombres.push_back("Jose");
nombres.push_back("Pedro");
nombres.push_back("Pablo");

// Se obtiene un iterador al inicio de la lista

list<string>::iterator it = nombres.begin();

// Buscamos el elemento "Pedro"

while (*it != "Pedro" && it != nombres.end() ) it++;

// Insertamos un elemento "Maria" en la posición indicada

// por el iterador it.
nombres.insert(it, 1, "Maria");

it = nombres.begin();
while( it != nombres.end() )
{
cout << *it++ << endl;
}
}

int main(int argc, char *argv[])

{
insertar();
system("PAUSE");
return EXIT_SUCCESS;
}
Actividad 8: Arboles
Un árbol es una estructura no lineal en la que
cada nodo puede apuntar a uno o varios nodos.

También se suele dar una definición recursiva:

un árbol es una estructura en compuesta por
un dato y varios árboles.

Definiremos varios conceptos. En relación con

otros nodos:

 Nodo hijo: cualquiera de los nodos apuntados por uno de los nodos del árbol. En el
ejemplo, 'L' y 'M' son hijos de 'G'.

 Nodo padre: nodo que contiene un puntero al nodo actual. En el ejemplo, el nodo 'A' es
padre de 'B', 'C' y 'D'.

Los árboles con los que trabajaremos tienen otra característica importante: cada nodo sólo puede
ser apuntado por otro nodo, es decir, cada nodo sólo tendrá un padre. Esto hace que estos árboles
estén fuertemente jerarquizados, y es lo que en realidad les da la apariencia de árboles.

En cuanto a la posición dentro del árbol:

 Nodo raíz: nodo que no tiene padre. Este es el nodo que usaremos para referirnos al
árbol. En el ejemplo, ese nodo es el 'A'.

 Nodo hoja: nodo que no tiene hijos. En el ejemplo hay varios: 'F', 'H', 'I', 'K', 'L', 'M', 'N' y
'O'.

 Nodo rama: aunque esta definición apenas la usaremos, estos son los nodos que no
pertenecen a ninguna de las dos categorías anteriores. En el ejemplo: 'B', 'C', 'D', 'E', 'G' y
'J'.

Otra característica que normalmente tendrán nuestros árboles es que todos los nodos contengan
el mismo número de punteros, es decir, usaremos la misma estructura para todos los nodos del
árbol. Esto hace que la estructura sea más sencilla, y por lo tanto también los programas para
trabajar con ellos.

Tampoco es necesario que todos los nodos hijos de un nodo concreto existan. Es decir, que
pueden usarse todos, algunos o ninguno de los punteros de cada nodo.

Un árbol en el que en cada nodo o bien todos o ninguno de los hijos existe, se llama árbol
completo.

En una cosa, los árboles se parecen al resto de las estructuras que hemos visto: dado un nodo
cualquiera de la estructura, podemos considerarlo como una estructura independiente. Es decir,
un nodo cualquiera puede ser considerado como la raíz de un árbol completo.

Existen otros conceptos que definen las características del árbol, en relación a su tamaño:
  Orden: es el número potencial de hijos que puede tener cada elemento de árbol. De este
modo, diremos que un árbol en el que cada nodo puede apuntar a otros dos es de orden
dos, si puede apuntar a tres será de orden tres, etc.

 Grado: el número de hijos que tiene el elemento con más hijos dentro del árbol. En el
árbol del ejemplo, el grado es tres, ya que tanto 'A' como 'D' tienen tres hijos, y no existen
elementos con más de tres hijos.

 Nivel: se define para cada elemento del árbol como la distancia a la raíz, medida en nodos.
El nivel de la raíz es cero y el de sus hijos uno. Así sucesivamente. En el ejemplo, el nodo
'D' tiene nivel 1, el nodo 'G' tiene nivel 2, y el nodo 'N', nivel 3.

 Altura: la altura de un árbol se define como el nivel del nodo de mayor nivel. Como cada
nodo de un árbol puede considerarse a su vez como la raíz de un árbol, también podemos
hablar de altura de ramas. El árbol del ejemplo tiene altura 3, la rama 'B' tiene altura 2, la
rama 'G' tiene altura 1, la 'H' cero, etc.

Los árboles de orden dos son bastante especiales, de hecho, les dedicaremos varios capítulos.
Estos árboles se conocen también como árboles binarios.

Frecuentemente, aunque tampoco es estrictamente necesario, para hacer más fácil moverse a
través del árbol, añadiremos un puntero a cada nodo que apunte al nodo padre. De este modo
podremos avanzar en dirección a la raíz, y no sólo hacia las hojas.

Actividad 9: Tablas Hash

Una tabla hash, matriz asociativa,
mapa hash, tabla de dispersión o
tabla fragmentada es una
estructura de datos que asocia
llaves o claves con valores. La
operación principal que soporta
de manera eficiente es la
búsqueda: permite el acceso a los
elementos (teléfono y dirección,
por ejemplo) almacenados a partir
de una clave generada (usando el
nombre o número de cuenta, por ejemplo). Funciona transformando la clave con una función hash
en un hash, un número que identifica la posición (casilla o cubeta) donde la tabla hash localiza el
valor deseado.

Las tablas hash se suelen implementar sobre vectores de una dimensión, aunque se pueden hacer
implementaciones multidimensionales basadas en varias claves. Como en el caso de los arreglos,
las tablas hash proveen tiempo constante de búsqueda promedio O(1),1 sin importar el número
de elementos en la tabla. Sin embargo, en casos particularmente malos el tiempo de búsqueda
puede llegar a O(n), es decir, en función del número de elementos.
Las operaciones básicas implementadas en las tablas hash son: inserción(llave, valor);
búsqueda(llave) que devuelve valor

La mayoría de las implementaciones también incluyen borrar(llave). También se pueden ofrecer

funciones como iteración en la tabla, crecimiento y vaciado. Algunas tablas hash permiten
almacenar múltiples valores bajo la misma clave.

Para usar una tabla hash se necesita:

 Una estructura de acceso directo (normalmente un array).

 Una estructura de datos con una clave

 Una función resumen (hash) cuyo dominio sea el espacio de claves y su imagen (o rango)
los números naturales.

Actividad 10: Grafos

Un grafo es un conjunto de objetos llamados vértices o
nodos unidos por enlaces llamados aristas o arcos, que
permiten representar relaciones binarias entre
elementos de un conjunto. Son objeto de estudio de la
teoría de grafos. Típicamente, un grafo se representa
gráficamente como un conjunto de puntos (vértices o
nodos) unidos por líneas (aristas).

La teoría de grafos tiene sus fundamentos en las

matemáticas discretas y de las matemáticas aplicadas. Es una teoría que requiere de diferentes
conceptos de diversas áreas como combinatoria, álgebra, probabilidad, geometría de polígonos,
aritmética y topología. Actualmente ha tenido mayor preponderancia en el campo de la
informática, las ciencias de la computación y telecomunicaciones. Debido a la gran cantidad de
aplicaciones en la optimización de recorridos, procesos, flujos, algoritmos de búsquedas, entre
otros, se generó toda una nueva teoría que se conoce como análisis de redes.

 Grafo simple. Es aquel que acepta una sola arista uniendo dos vértices cualesquiera. Esto
es equivalente a decir que una arista cualquiera es la única que une dos vértices
específicos. Es la definición estándar de un grafo.
 Multigrafo. Es el que acepta más de una arista entre dos vértices. Estas aristas se llaman
múltiples o lazos (loops en inglés).
 Pseudografo. Si incluye algún lazo.
 Grafo orientado, dirigido o dígrafo. Son grafos en los cuales se ha añadido una orientación
a las aristas, representada gráficamente por una flecha.
 Grafo etiquetado. Grafos en los cuales se ha añadido un peso a las aristas (número entero
generalmente) o un etiquetado a los vértices.
 Grafo aleatorio. Grafo cuyas aristas están asociadas a una probabilidad.
 Hipergrafo. Grafos en los cuales las aristas tienen más de dos extremos, es decir, las aristas
son incidentes a 3 o más vértices.
 Grafo infinito. Grafos con conjunto de vértices y aristas de cardinal infinito.