1

INSTITUTO TECNOLOGICO SUPERIOR DE FELIPE

CARRILLO PUERTO

MATERIA:

ESTRUCTURA DE DATOS

DOCENTE:

MIL. NIELS HENRYK ARANDA CUEVAS

UNIDAD 3:

ESTRUCTURAS LINEALES

ALUMNO:

ELIU OSSEAS PUC PUC

CARRERA:

INGENIERIA EN SISTEMAS COMPUTACIONALES

GRUPO:

B

2

INDRODUCCION:

En esta unidad se entra en la manera de manejo de datos pero no por medio de las maneras vistas anteriormente, sino en una forma de definir la posiciones de los datos por medio de la jerarquía de los datos que se tienen, existen varios métodos para realizarlo de diferentes manera una de las principales es el método burbuja y otros métodos como el quicksort y el método radix, que siempre tienen el mismo propósito de ordenamiento de los datos.

Primer programa de ordenamiento. Método burbuja

#include <iostream>

using namespace std;

void intercambio();

void imprimir();

int Aux;

int i, d;

int A[5];

int main(int argc, char** argv) {

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

cout<<"Ingrese numero: ";

cin>>A[i];

}

3

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

for(d=i+1; d<5; d++){

if(A[d]>A[i]){

intercambio( );

}

}

}

imprimir();

return 0;

}

void intercambio(){

Aux= A[i];

A[i]= A[d];

A[d]= Aux;

}

void imprimir(){

cout<<"\n La secuencia de Mayor a Menor es: ";

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

cout<< A[i];

}

}

4

Descripción del programa:

El programa anterior es un método de ordenamiento de datos con varias funciones que son llamados, como ya sabemos tenemos los códigos principales que ya sabemos utilizar, como lo son los condicionales y los datos abstractos, lo que realizamos es la lectura de los datos que son los números y en base a esos números realizamos el ordenamiento por medio de los apuntadores que se tienen, también podemos interpretarlo si queremos de una manera de árboles.

MÉTODO QUICKSHORT.

#include <iostream>

using namespace std;

void leerarreglo();

void imprimrarre();

void ordenarQuick();

void inter(int x, int y);

int i,j,A[7];

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

leerarreglo();

imprimrarre();

ordenarQuick();

imprimrarre();

return 0;

5

}

void leerarreglo(){

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

cout<<"ingrese dato ";

cin>>A[i];

}

}

void imprimrarre(){

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

cout<<A[i]<<" ";

}

cout<<"n";

}

void ordenarQuick(){

int p=6;

i=0;

j=5;

do{

if ((A[i]>A[p])&&(A[j]<A[p])){

inter (i,j);

i++; j--;

}

else {

if (A[i]<A[p])

6

i++;

if (A[j]>A[p])

j--;

}

}while (j>i);

if (A[p]<A[i])

inter (i,p);

}

void inter(int x, int y){

int Aux=A[y];

A[y]=A[x];

A[x]=Aux;

}

Este método realiza el ordenamiento de dato de una manera mas compleja.

METODO RADIX.

#include<iostream>

using namespace std;

#include <math.h>

#define NUMELTS 20

void radixsort(int x[], int n)

{

int front[10], rear[10];

struct {

7

int info;

int next;

} node[NUMELTS];

int exp, first, i, j, k, p, q, y;

/* Inicializar una lista vinculada */

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

{

node[i].info = x[i];

node[i].next = i+1;

} /* fin del for */

node[n-1].info = x[n-1];

node[n-1].next = -1;

first = 0; /* first es la cabeza de la lista vinculada */

for (k = 1; k < 5; k++)

{

/* Suponer que tenemos números de cuatro dígitos */

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

{

/*Inicializar colas */

rear[i] = -1;

front[i] = -1;

} /*fin del for */

8

/* Procesar cada elemento en la lista */

while (first != -1)

{

p = first;

first = node[first].next;

y = node[p].info;

/* Extraer el kâsimo dÁgito */

exp = pow(10, k-1); /* elevar 10 a la (k-1)ésima potencia */

j = (y/exp) % 10;

/* Insertar y en queue[j] */

q = rear[j];

if (q == -1)

front[j] = p;

else

node[q].next = p;

rear[j] = p;

} /*fin del while */

/* En este punto, cada registro está en su cola basándose en el dígito k

Ahora formar una lista única de todos los elementos de la cola.

Encontrar el primer elemento. */

for (j = 0; j < 10 && front[j] == -1; j++);

;

first = front[j];

/* Vincular las colas restantes */

9

while (j <= 9)

{ /* Verificar si se ha terminado */

/*Encontrar el elemento siguiente */

for (i = j+1; i < 10 && front[i] == -1; i++);

;

if (i <= 9)

{

p = i;

node[rear[j]].next = front[i];

} /* fin del if */

j = i;

} /* fin del while */

node[rear[p]].next = -1;

} /* fin del for */

/* Copiar de regreso al archivo original */

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

{

x[i] = node[first].info;

first = node[first].next;

} /*fin del for */

} /* fin de radixsort*/

int main(void)

{

int x[50] = {NULL}, i;

10

static int n;

cout<<"Cadena de números enteros:\n";

for (n = 0;n<5; n++)

{

cin>>x[n];

if(x[n]==-1)

break;

}

if (n)

radixsort (x, n);

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

cout<<x[i]<<endl;;

return 0;

}

Este método radix es aún más compleja.

CONCLUSION:

Como conclusión tenemos que el uso de estos métodos es importante para manejar los datos ya que se pueden presentar situaciones donde podemos requerir del uso de cualquiera de los métodos de ordenamiento que mencionamos con anterioridad dependiendo de la capacidad de datos que se ingresan en nuestro programa y podemos decir que lo más importante a conocer es el método burbuja. Como hemos dicho anteriormente va ser de gran ayuda para nosotros cuando tengamos que realizar programas que requieran el ordenamiento de datos cabe mencionar que como mencionamos anteriormente existen varios métodos que podemos utilizar pero nosotros como programadores siempre buscamos la eficacia del código y que funcione correctamente y que lleve menos código.