Algoritmos y estructuras de datos

1. Arreglos
2. Algoritmo de ordenamiento Burbuja
3. Busqueda secuencial
4. Busqueda binaria
5. Estructuras de datos

Arreglos

Un arreglo es un conjunto de celdas de memoria relacionadas entre si ya que todos tienen el

mismo nombre y almacenan el mismo tipo de datos para referirse a una celda en particular
algún elemento dentro del arreglo y entre corchetes [] el numero de posición del elemento
dentro del arreglo.

El primer elemento se almacena en la posición 0 del arreglo, es decir el primer elemento del
arreglo se conoce como a[0], el segundo como a[1], el séptimo como a[6] y en general el
elemento de orden i del arreglo a se conoce como a[i-1].

El número de posición que aparece dentro de los corchetes se conoce como índice y debe
ser un número entero o una expresión entera, por ejemplo:

printf ("%i", a[0]+a[5]+a[10]);

x=a[7]/2;

x=a[4]=12;

Para declarar un arreglo se emplea la siguiente sintaxis:

tipo_de_dato nombre_del_arreglo [número de elementos];

int a[12];

float f[10];

char nom_emp [30];

Ejemplo:

#include <stdio.h>
#include <conio.h>

#define MAX 12

void main(){

int a[MAX], b[MAX], c[MAX], i, j=0, k=0;

 clrscr();

printf ("Programa que almacena 12 numeros en un arreglo ");

printf ("y luego los separa en dos de acuerdo a su valor.\n");

for (i=0; i < MAX; i++){

printf ("Introduce el valor %i: ", i+1);
scanf ("%i", &a[i]);
}

for (i=0; i < MAX; i++)

if (a[i] < MAX){

b[j] = a[i];
j++;
}

else {

c[k] = a[i];
k++;
}

printf ("\nLos numeros quedan asi:\n\n");

for (i=0; i < j; i++)

printf ("%i\n", b[i]);

for (i=0; i < k; i++)

printf ("\t%i\n", c[i]);

getch();
}

Arriba

Algoritmo de ordenamiento Burbuja

Este algoritmo compara elementos consecutivos del arreglo uno con respecto del otro, si es
mayor o menor según el tipo de ordenamiento y los cambia de posición. Este proceso se
repite recorriendo todo el arreglo para posicionar un solo dato, por lo que es necesario
repetirlo para los demás datos del arreglo. Su implementación es la siguiente:

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>

#define TAM 10

void main(){
int a[TAM], temp, i, j;
 clrscr();

randomize(); //Inicializa el generador de numeros aleatorios

printf ("Llenando arreglo con números aleatorios\n");

for (i=0; i< TAM; i++)

a[i]=random(100);

//Implementacion de Ordenamiento por burbuja de mayor a menor

for (j=1; j <= TAM; j++)

for (i=0; i< TAM-1; i++)

if (a[i] < a[i+1]){

temp = a[i];
a[i] = a[i+1];
a[i+1] = temp;
}

printf ("\nArreglo ordenado\n");

for (i=0; i< TAM; i++)

printf ("a[%d] = %d\n", i, a[i]);

getch();
}

Arriba

Busqueda Secuencial

Este algoritmo compara uno a uno los elementos del arreglo hasta recorrerlo por completo
indicando si el número buscado existe. Su implementación es la siguiente:

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>

#define TAM 10

void main(){
int a[TAM], temp, i, j, num;

clrscr();

randomize(); //Inicializa el generador de numeros aleatorios

printf ("Llenando arreglo con números aleatorios\n");

for (i=0; i< TAM; i++)

a[i]=random(100);
 printf ("Numero a buscar? ");
scanf ("%d", &num);

for (i=0; i< TAM; i++)

if (a[i] == num){

printf ("\nValor encontrado");

printf ("\nPosicion: %d", i);
}

else
printf ("\nNo existe");

printf ("El arreglo era:\n");

for (i=0; i< TAM; i++)

printf ("%d ", a[i]);

getch();
}

Arriba

Busqueda Binaria

Este algoritmo permite buscar de una manera más eficiente un dato dentro de un arreglo,
para hacer esto se determina el elemento central del arreglo y se compara con el valor que
se esta buscando, si coincide termina la busqueda y en caso de no ser asi se determina si el
dato es mayor o menor que el elemento central, de esta forma se elimina una mitad del
arreglo junto con el elemento central para repetir el proceso hasta encontrarlo o tener solo
un elemento en el arreglo. Para poder aplicar este algorimo se requiere que el arreglo este
ordenado. Su implementación es la siguiente:

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>

#define TAM 15

void main(){

int a[TAM], busca, temp, bajo, alto, central;

printf("Llenando el arreglo con números aleatorios\n");

randomize(); //Inicializa el generador de aleatorios

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

a[i]=random(100);

//Implementacion de Ordenamiento por burbuja de menor a mayor

printf ("Ordenando arreglo...\n");
 for (int j=1; j <= TAM; j++)
for (i=0; i< TAM-1; i++)

if (a[i] > a[i+1]){

temp = a[i];
a[i] = a[i+1];
a[i+1] = temp;
}

//Implementacion de busqueda binaria

printf ("\nIntroduce un numero a buscar: ");

scanf ("%d", &busca);

bajo = 0;
alto = TAM-1;
central = (bajo+alto)/2;

while (bajo < alto && busca != a[central]){

if(busca > a[central])

bajo = central+1;

else
alto = central-1;

central=(bajo+alto)/2;
}

if (busca == a[central])
printf("\n%d encontrado en posicion %d", busca, central);

else
printf("\n%d no existe", busca);

printf ("\n\nEl arreglo ordenado era\n\n");

for (i=0; i< TAM; i++)

printf ("%d ", a[i]);

getch();
}

Arriba

Estructuras de datos

Las estructuras se definen como conjuntos de datos de diferente tipo. Se pueden declarar de
las siguentes maneras:

struct nomina
{
char nom[80];
char puesto[40];
 float sueldo;
int id;
}

struct nomina empleado_1, empleado_2, empleado[50];

struct
{
char nom[80];
char puesto[40];
float sueldo;
int id;
}

empleado_1, empleado_2, empleado[50];

typedef struct
{
char nom[80];
char puesto[40];
float sueldo:
int id;
} nomina;

nomina empleado_1; empleado_2; empleado[50];

Las estructuras, como cualquier otro tipo de dato, se pueden representar en arreglos.

#include
struct
{
char nom[60];
char mat[40];
float cb, pc, cf;
flat prom;
} alumno[50];

float aux;

void main()
{
int i, n;
printf ("Cuantos alumnos? ");
scanf ("%d", &n);
flushall();
printf ("\nLectura de datos");
}