Universidad Autónoma de Nicaragua.

(UNAN – LEÓN).

Facultad: Ciencia y Tecnología.

Carrera: Ing. Telemática.
Componente: Circuitos lógicos
Nombre: Luis Alejandro Ramos Reyes

Fecha:16/10/20

¡A la libertad por la universidad!

 1. Dado un arreglo de 10000 elementos generados de forma aleatoria, ordene dicho
arreglo utilizando los algoritmos: Burbuja, Inserción y Selección. Presente en
pantalla el tiempo que utilizo cada algoritmo para ordenar el arreglo.

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
char cad[198][30];

int getposmenor(int pos_inf,int pos_sup);

int main() {
FILE *f,*fo;
int i,pos_menor;
char aux[40];

f=fopen("palabras.txt","r");
fo=fopen("palabras ordenadas Burbujas.txt","w");

if(f==NULL||fo==NULL){
printf("Error al abrir el fichero");
exit(-1);
}

printf ("Fichero sin ordenar.\n");

for (i=0;i<198;i++){
fgets(cad[i],40,f);
printf ("%s",cad[i]);
}
for(i=0;i<198;i++)
{
pos_menor=getposmenor(i,198);

if(pos_menor != i){
strcpy(aux,cad[i]);
 strcpy(cad[i],cad[pos_menor]);
strcpy(cad[pos_menor],aux);
}
}
for(i=0;i<198;i++)
{
fprintf(fo,"%s",cad[i]);
}
fclose(fo);
fclose(f);
return 0;

int getposmenor(int pos_inf,int pos_sup){

int i=pos_inf;
int pos_menor;
char menor[40];
strcpy(menor, cad[i]);

for(;i<pos_sup;i++)
{
if(strcmp(cad[i],menor)<0)
{
strcpy(menor, cad[i]);
pos_menor=i;
}
}
return pos_menor;
}

2. Dado un fichero de texto (donde no aparece la letra ñ) ordena sus líneas

alfabéticamente mediante el método de la burbuja, selección y quicksort, generando en
los tres casos un archivo nuevo que contenga el texto ordenado.
3. Dado un vector de N elementos (que se deberán inicializar aleatoriamente) eliminar todos sus
elementos repetidos. Emplear para ello una variante del método de selección.
#include <stdlib.h>
#include <stdio.h>
#include <time.h>

void imprimirArray(int *a, int n) {

int i;
for(i = 0; i < n-1; i++)
printf( "%d, ", a[i]);
printf( "%d\n", a[i]);
}
void imprimirArray2(int *a, int n) {
int i;
for(i = 0; i < n; i++)
if(a[i]!=200){
printf( "%d, ", a[i]);
}
}
void generarArray( int *a, int n ){
int i;
for(i = 0; i < n; i++)
a[i] = (int)(rand() % 100);
}
void ordenarSeleccion( int *a, int n ){
int minimo,i,j, aux;
for(i=0 ; i<n-1 ; i++) {
minimo=i;
for(j=i+1 ; j<n ; j++){
if ( a[minimo] > a[j] )
minimo=j;
}
if(a[minimo]!=a[i]){
aux = a[minimo];
a[minimo] = a[i];
 a[i] = aux;
}
}
}
void eliminar ( int *a, int n ){
int i,j;
for(i=0 ; i<n-1 ; i++) {
for(j=i+1 ; j<n ; j++){
if(a[i]==a[j]){
//fflush(stdin);
a[j]=200;
}
}
}
for(i=1 ; i<n ; i++) {
if(a[i]==200){
//fflush(stdin);
a[i]=a[i+1];
a[i+1]=200;
}
}
}
int main() {
int TAM;
srand (time(NULL));
TAM=rand() % 100;
int array[TAM];
printf("tamaño del arreglo: %d\n",TAM);
srand((unsigned int)time(NULL));
generarArray( array, TAM );
printf( "Antes de ordenar\n---------------------\n");
imprimirArray( array, TAM );
ordenarSeleccion( array, TAM );
printf( "\nDespués de ordenar\n------------------\n");
imprimirArray( array, TAM );
eliminar(array,TAM);
TAM--;
printf( "\nDespués de eliminar\n------------------\n");
 imprimirArray2( array, TAM );
return 0;
}

4. Se tiene un fichero con una lista de contactos con los siguientes datos:  Nombre
(método de la burbuja)  Apellidos (inserción)  Dirección (selección)  Teléfono
(quicksort) Se le pide crear un programa que permita ordenar dichos contactos por medio
de uno los campos (elegido por el usuario)

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

struct datos{
char nombre[20];
char apellido[20];
char direccion[50];
char numero[10];
};

void PedirDatos (int n, struct datos *D);

int seleccion (void);
void OrdenarNombre (int n,struct datos *D);
void OrdenarApellido (int n,struct datos *D);
void OrdenarDireccion (int n,struct datos *D);
void OrdenarNumero (struct datos *D,int inf,int sup);

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

int N,i,cond;
struct datos *Dt;

FILE *fich;

fich= fopen("alex sistema.txt","w");

if(fich==NULL){
perror("Error al abrir ");
exit(-1);
 }
printf ("Cuantos contactos desea ingresar: ");
scanf ("%d",&N);

Dt=(struct datos*)calloc(N,sizeof(struct datos));

if(Dt==NULL){
perror("Error al abrir ");
exit(-1);
}

PedirDatos(N,Dt);
cond=seleccion();

switch(cond){
case 1:OrdenarNombre(N,Dt);break;
case 2:OrdenarApellido(N,Dt);break;
case 3:OrdenarDireccion(N,Dt);break;
case 4:OrdenarNumero(Dt,0,N-1);break;
}

for (i=0;i<N;i++){
fwrite(Dt[i].nombre,sizeof(char),20,fich);
fprintf(fich,"\n");
fwrite(Dt[i].apellido,sizeof(char),20,fich);
fprintf(fich,"\n");
fwrite(Dt[i].direccion,sizeof(char),50,fich);
fprintf(fich,"\n");
fwrite(Dt[i].numero,sizeof(char),10,fich);
fprintf(fich,"\n");
fprintf(fich,"\n");
}
fclose(fich);
free(Dt);
return 0;
}

void PedirDatos (int n,struct datos *D){

int i;
 for(i=0;i<n;i++){
printf ("Digite el Nombre: ");
fflush(stdin);
gets(D[i].nombre);
printf ("Ingrese el apellido: ");
fflush(stdin);
gets(D[i].apellido);
printf ("Igrese la direccion: ");
fflush(stdin);
gets(D[i].direccion);
printf ("Ingrese numero celular: ");
fflush(stdin);
gets(D[i].numero);
printf("\n");
system("cls");
}
}
int seleccion (void){
int resp;

do {
printf ("Bajo que informacion desea ordenar los datos\n");
printf ("1. NOMBRES (BURBUJA)\n");
printf ("2. APELLIDOS (INSERCION)\n");
printf ("3. DIRECCION (SELECCION)\n");
printf ("4. CELULAR (QUICKSORT)\n");
scanf ("%d",&resp);
} while(resp>5 || resp<0);

return resp;
}
void OrdenarNombre (int n,struct datos *D){
int i,j;
char aux[50];
for (j=1;j<n;j++) {
for (i=0;i<n-1;i++){
if (strcmp(D[i].nombre,D[i+1].nombre)>0) {
strcpy(aux,D[i].nombre);
 strcpy(D[i].nombre,D[i+1].nombre);
strcpy(D[i+1].nombre,aux);

strcpy(aux,D[i].apellido);
strcpy(D[i].apellido,D[i+1].apellido);
strcpy(D[i+1].apellido,aux);

strcpy(aux,D[i].direccion);
strcpy(D[i].direccion,D[i+1].direccion);
strcpy(D[i+1].direccion,aux);

strcpy(aux,D[i].numero);
strcpy(D[i].numero,D[i+1].numero);
strcpy(D[i+1].numero,aux);
}
}
}
}

void OrdenarApellido (int n,struct datos *D){

int i, k;
char x[4][50];
for (i = 1; i < n; i++)/* desde el segundo elemento */
{
strcpy(x[1],D[i].apellido);
strcpy(x[0],D[i].nombre);
strcpy(x[2],D[i].direccion);
strcpy(x[3],D[i].numero);
k = i-1;
while (k >= 0 && strcmp(x[1],D[k].apellido)<0){
strcpy(D[k+1].apellido,D[k].apellido);
strcpy(D[k+1].nombre,D[k].nombre);
strcpy(D[k+1].direccion,D[k].direccion);
strcpy(D[k+1].numero,D[k].numero);
k--;
}
strcpy(D[k+1].apellido,x[1]);
strcpy(D[k+1].nombre,x[0]);
 strcpy(D[k+1].direccion,x[2]);
strcpy(D[k+1].numero,x[3]);

}
}
void OrdenarDireccion (int n,struct datos *D){
int minimo,i,j;
char aux[50];
for(i=0;i<n-1;i++) {
minimo=i;
for(j=i+1;j<n;j++){
if (strcmp(D[minimo].direccion,D[j].direccion)>0)
minimo=j;
}
strcpy(aux,D[minimo].apellido);
strcpy(D[minimo].apellido,D[i].apellido);
strcpy(D[i].apellido,aux);

strcpy(aux,D[minimo].nombre);
strcpy(D[minimo].nombre,D[i].nombre);
strcpy(D[i].nombre,aux);

strcpy(aux,D[minimo].direccion);
strcpy(D[minimo].direccion,D[i].direccion);
strcpy(D[i].direccion,aux);

strcpy(aux,D[minimo].numero);
strcpy(D[minimo].numero,D[i].numero);
strcpy(D[i].numero,aux);
}
}
void OrdenarNumero (struct datos *D,int inf,int sup){
int izq, der;
char x[50];
char mitad[10];
izq = inf; der = sup;
strcpy(mitad,D[(izq + der)/2].numero);
do{
while(strcmp(D[izq].numero,mitad)<0 && izq < sup) izq++;
 while(strcmp(mitad,D[der].numero)<0 && der > inf) der--;
if(izq <= der){
strcpy(x,D[izq].numero);
strcpy(D[izq].numero,D[der].numero);
strcpy(D[der].numero,x);

strcpy(x,D[izq].nombre);
strcpy(D[izq].nombre,D[der].nombre);
strcpy(D[der].nombre,x);

strcpy(x,D[izq].apellido);
strcpy(D[izq].apellido,D[der].apellido);
strcpy(D[der].apellido,x);

strcpy(x,D[izq].direccion);
strcpy(D[izq].direccion,D[der].direccion);
strcpy(D[der].direccion,x);
izq++;
der--;
}
}while(izq <= der);
if(inf < der) OrdenarNumero (D, inf, der);
if(izq < sup) OrdenarNumero (D, izq, sup);
}