CENTRO DE ENSEANZA TECNICA Y SUPERIOR

Colegio de Ingeniera

Estructura de datos

Practica No. 2

Presenta: Ricardo Quiroz Prez Matricula: 7271

Ensenada, B. C., 04 de marzo del 2012

OBJETIVO
El objetivo de la prctica es implementar un tipo abstracto de datos (TAD) que represente a un arreglo, pero adems este debe de implementar uno de los mtodos de ordenamiento vistos. En este programa se utilizo el mtodo Radix Sort. Complementariamente se realizo un programa en el cual se implemento el TAD con el respectivo mtodo para ordenar, el cual consiste en preguntar al usuario los datos para crear el arreglo (capacidad, cantidad de elementos que desea agregar y cada elemento a agregar), luego se procede a ordenarlo y finalmente se pregunta al usuario se quiere eliminar un elemento y se reordena el arreglo.

FUNCIONAMIENTO DEL MTODO DE ORDENAMIENTO

Este ordenamiento se basa en los valores de los dgitos reales en las representaciones de posiciones de los nmeros que se ordenan.

Existen dos clasificaciones de RADIX-SORT Digito menos significativo (LSD) Digito ms significativo (MSD)

Supongamos que queremos ordenar n nmeros, cada uno de ellos compuesto de k dgitos. El siguiente es un ejemplo con n=10 y k=5 (numero de dgitos por numero)
73895 93754 82149 99046 04853 94171 54963 70471 80564 66496

Imaginando que estos dgitos forman parte de una matriz, podemos decir que a [i, j] es el j-esimo del I-esimo elemento del conjunto. Es fcil, en una pasada, ordenar el conjunto se la llave de ordenacin es un solo digito, por ejemplo el tercero de izquierda a derecha:
99046 82149 94171 70471 66496 80564 93754 73895

04853 54963

Para ordenar un conjunto de llaves completas, repetimos el proceso digito por digito, en cada pasada separando los elementos segn el valor del digito respectivo, luego recolectndolos para formar una sola cola, y realimentando el proceso con esos mismos datos.

Como hay que realizar k pasadas y cada una de ellas toma tiempo O(N), el tiempo total es O(k N), que es el tamao del archivo de entrada (en bytes). Por lo tanto, la ordenacin tomo un tiempo lineal en el tamao de los datos.

Examina los nmeros de derecha a izquierda for k:=0 to b-1 Ordena el arreglo en una forma estable.
Primera Segunda Tercera

Ordenar en forma estable significa que el orden inicial relativo de nmeros iguales no se cambia. Por ejemplo, observe el primer paso de el ordenamiento

Observe que el orden relativo de estos nmeros que terminan en cero no se cambia y lo mismo es con los nmeros que terminan en 1.

DESCRIPCIN DEL TAD

ATRIBUTOS:
Nmero de elementos o Guarda la cantidad de elementos que existen en el arreglo. Elementos o Son los elementos que contiene el arreglo Capacidad o Es la capacidad mxima del arreglo

FUNCIONES:
void orden_ascendente() o Ordena el arreglo ascendentemente. o Precondiciones: Que contenga elementos o Postcondiciones: Arreglo ordenado ascendentemente void orden_descendente() o Ordena el arreglo descendentemente. o Precondiciones: Que contenga elementos o Postcondiciones: Arreglo ordenado descendentemente bool agregar(int e) o Agrega un elemento al arreglo. o Precondiciones: Que exista el arreglo o Postcondiciones: Un elemento agregado al arreglo bool eliminar(int e) o Elimina un elemento del arreglo. o Precondiciones: Que el arreglo no est vacio Que exista el elemento a borrar en el arreglo o Postcondiciones: Arreglo sin elemento que se borro void mostrar() o Muestra el contenido del arreglo. o Precondiciones: Que el arreglo no est vacio. o Postcondiciones: Muestra contenido del arreglo bool vacio() o Mtodo utilizado para determinar si un arreglo esta vacio. o Precondiciones: Que el arreglo exista o Postcondiciones: Booleano que dice si el arreglo esta vacio o no.

CDIGO FUENTE
prueba_arreglo.cpp
1 2 3 4 5 6 7 8 9 10 #include "TadArreglo.h" #include <iostream> #include <vector> #include <math.h> using namespace std;

11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

int main(){ //Variables para el funcionamiento del programa int numEle, cap, i, x, y;//numEle: numero de elementos en el arreglo. cap: capacidad del arreglo. i: contador. x:variable temporal, y:variable temporal bool bandera, bandera2;//booleanos temporales Arreglo *arreglo; //Solicitud de valores y formacion de arreglo cout<<"\nDame la capacidad del arreglo: "; cin>>cap; cout<<"\nDime que tantos elementos quieres agregar: "; cin>>numEle; buckets.resize(10); arreglo= new Arreglo(cap);//formacion arreglo for(i=0;i<numEle;i++){//llenado de arreglo cout << "\n"<< i+1 <<": "; cin >>x; bandera=arreglo->agregar(x);//bandera para comprobar que se puedo agregar el elemento correctamente if(bandera=false){ cout <<"\nArreglo lleno"; i=numEle; } } //Imprimir resultado de ordenamiento cout<<"\nArreglo reacomodado asendentemente"; arreglo->orden_ascendente(); arreglo->mostrar(); //Preguntar si se desea eliminar algun elmento cout<<"\nDesea eliminar un elemento (si: 1, no: 0): "; cin>>bandera2; if(bandera2=true){ cout<<"\nDame elemento a eliminar: "; cin>>y; arreglo->eliminar(y); arreglo->orden_ascendente(); arreglo->mostrar(); } return 0; }

Arreglo.h
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 #ifndef TADARREGLO_H_ #define TADARREGLO_H_ #include <iostream> using std::cout; #define cap_defecto 10 #include <vector> #include <math.h> using namespace std; vector < vector <int> > buckets;

class Arreglo { //----------Atributos------------------public: int numElementos; int capacidad; int *elementos; //----------Mtodos Constructores------Arreglo()//constructor con valores por defecto { numElementos=0; capacidad=cap_defecto; elementos=new int [capacidad]; } Arreglo(int cap)//constructor recibiendo capacidad { numElementos=0; capacidad=cap; elementos=new int [capacidad]; } //-----------Funciones-----------------void orden_ascendente();//Ordena el arreglo ascendentemente. void orden_descendente();//Ordena el arreglo descendentemente. bool agregar(int e);//Agrega un elemento al arreglo. bool eliminar(int e);//Elimina un elemento del arreglo. void mostrar();//Muestra el contenido del arreglo. bool vacio(){return (numElementos == 0 ? true : false);};//Metodos utilizado para determinar si un arreglo esta vacio. }; void Arreglo::orden_ascendente(){ int temp; int m=0; //Inicia Radix Sort for(int i=0;i<7;i++){ //Determine which bucket each element should enter for(int j=0;j<capacidad;j++){ temp=(int)((elementos[j])/pow(10,i))%10; buckets[temp].push_back((elementos[j])); } //Transfer results of buckets back into main array

53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103

for(int k=0;k<10;k++){ for(int l=0;l<buckets[k].size();l++){ elementos[m]=buckets[k][l]; m++; } //Clear previous bucket buckets[k].clear(); } m=0; } buckets.clear(); } bool Arreglo::agregar(int e) { if(numElementos != capacidad){ elementos[numElementos++] = e; return true; } return false; } bool Arreglo::eliminar(int e) { if(vacio()) return false; else for (int i = 0;i<numElementos;i++){ if(elementos[i]==e){ for(int j=i;j<(numElementos-1);j++) elementos[j] = elementos[j+1]; numElementos--; return true; } } return false; } void Arreglo::mostrar() { if(vacio()){ cout << "\nEl arreglo no contiene elementos\n"; } else{ for (int i = 0 ; i < numElementos ; i++){ cout << i+1 << ": " << elementos[i]<< "\n"; } } } #endif /* TADARREGLO_H_ */

Referencias http://dis.unal.edu.co/~fgonza/courses/2003/poo/c++.htm http://usuario.cicese.mx/~orodrigu/AEDAI/RadixSort/radix_final/in dex.htm http://ict.udlap.mx/people/ingrid/Clases/IS211/Radix.html http://www.youtube.com/watch?v=IIagzQY2IYc