You are on page 1of 34

Ejercicios Resueltos de

Estructura de Datos II
Listas
12/10/2010
Universidad Argentina Jhon F. Kennedy
Prof. Lic. Oscar Eduardo Malone

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone

Ejercicio 1
FUE TEMA DE FINAL
----------------Ingresar una matriz de N x N poco densa (con muchos ceros). El valor de N se
debe
declarar como constante.

Ejecutar las siguientes acciones:

A ) Generar, a partir de la matriz ingresada, una lista simplemente enlazada.


Donde la informacin de cada nodo tiene el siguiente diseo:

"

Numero de fila

"

Numero de columna

"

Valor almacenado

Solo se incluirn en la lista los elementos distintos de cero.

B ) Visualizar la matriz a partir de la lista creada.En la reproduccin los


ceros se deben ubicar donde corresponde.

C ) Eliminar de la lista los nodos correspondientes a la informacin de la


diagonal principal y luego visualizar nuevamente la matriz desde la lista.

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone
*************************************************************************
*************************************************************************
AL ELIMINAR LOS NODOS DE LA DIAGONAL PRINCIPAL SUPONEMOS QUE
TODOS LOS
ELEMENTOS QUE SE ENCUENTRAN A LA DERECHA DE LA DIAGONAL
PRINCIPAL SE CORREN
UNA POSICIN HACIA LA IZQUIERDA . COMO CONSECUENCIA DE ESTE
CORRIMIENTO
TERMINAMOS CON UNA MATRIX DE N x N-1 ELEMENTOS
**************************************************************************
**************************************************************************
*/

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

#define N 10
typedef struct r nodo;

struct r
{
int fila;
int columna;
int dato;
nodo *ptr;
};
3

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone

void enlistar(nodo**,nodo**,nodo*);
nodo desenlistar(nodo**);
nodo* eliminarNodosDiagonal(nodo**,nodo**);
void correrColumna(nodo*);

main()
{
int m[N][N];
int i,j,x;
nodo*pi,*pf,*q,*pant,*paux;
pi=pant=NULL;

/*****************************************************************
Cargamos la matriz con gran canidad de ceros
*****************************************************************/
for(i=0;i<N;i++)
for(j=0;j<N;j++)
{
x=random(25);
if(x>14)
m[i][j]= x;
else
m[i][j]=0;

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone
}
/*****************************************************************
Cargamos la matriz principal con el valor 88 para poder identificarla
facilmente
*****************************************************************/
for(i=0;i<N;i++)
m[i][i]=88;

/*****************************************************************
Mostramos la matriz Creada
*****************************************************************/
system("cls");
printf("MATRIZ ORIGINAL\n\n");
for(i=0;i<N;i++)
{
for(j=0;j<N;j++)
printf("%4d",m[i][j]);
printf("\n");
}

/******************************************************************
Recorremos la matriz y cargamos una la pila con los elementos no nulos
******************************************************************/
for(i=0;i<N;i++)

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone
{
for(j=0;j<N;j++)
{
if(m[i][j]>0)
{
q=(nodo*)malloc(sizeof(nodo));

q->fila=i;
q->columna=j;
q->dato=m[i][j];

enlistar(&pi,&pf,q);
}
}
}

/***************************************************************
Reproducimos la matriz leyendo la lista
***************************************************************/
printf("\n\nMATRIZ REPRODUCIDA\n\n");
paux=pi; /* Guardamos el valor de pi en paux para no perderlo */

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

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone
for(j=0;j<N;j++)
{
/*******************************************************
Si no es el fin de la lista
*******************************************************/
if(paux)
{
/****************************************************
Si el valor de i y el valor de j coinciden con los
valores de fila y columna leidos enj el nodo imprimimos
el dato del nodo
*****************************************************/
if(i==paux->fila && j==paux->columna)
{
printf("%4d",m[i][j]);

/**************************************************
Avanzamos al proximo nodo
**************************************************/
paux=paux->ptr;
}
else

/************************************************************

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone
Si los valores de i y j no coinciden con los valores de fila
y columna leidos en el nodo imprimimos cero
************************************************************/
printf("%4d",0);
}
}
printf("\n");
}

/*********************************************************************
Eliminamos los nodos de la digonal principal (i=j). Este proceso permite
recorrer la lista hasta el final. La funcion devuelve la direccion del
nodo anterior al eliminado. Al leer el ultimo nodo, este es eliminado
y pf toma el valor de pant lo cual pone fina a este proceso ( ver condicion
del while).
*********************************************************************/

pant=eliminarNodosDiagonal(&pi,&pf);

while(pant!=pf) /* Detecta la eliminacion del ultimo nodo */


pant=eliminarNodosDiagonal(&pi,&pf);

/************************************************************************
Modificamos los valores de columna de todos los elementoas de la matriz

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone
ubicados a la derecha de la matriz principal corriendolos una posicion a
la izquierda (columna - 1 ).
************************************************************************/
correrColumna(pi);

/******************************************************************
Reconstruimos la matriz reducida en una columna
******************************************************************/
printf("\n\nMATRIZ REDUCIDA ( una columna menos )\n\n");

for(i=0;i<N;i++)
{
/****************************************************************
El desplazamiento generado en la eliminacion de la diagonal principal
reduce la dimensin de la matriz a N x N-1
******************************************************************/
for(j=0;j<N-1;j++)
{
if(pi && pi->fila==i && pi->columna==j)
{
printf("%4d",pi->dato);
pi=pi->ptr;
}
else

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone
printf("%4d",0);
}
printf("\n");
}
printf("\n");
system("pause");

return 0;
}

/**************************************************************************
Elistar() funciona como acolar()
**************************************************************************/

void enlistar(nodo**pi,nodo**pf,nodo*q)
{
if(*pi==NULL)
{
*pi=*pf=q;
}
else
{
(*pf)->ptr=q;
*pf=q;

10

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone
}
q->ptr=NULL;
}

/*************************************************************************
Esta funcion elimina los nodos de la diagonal de a uno. Recorre hasta que
encuentra el nodo de la diagonal, lo elimina y retorna. Asi continua hasta
que elimina el ltimo nodo lo cual vuelve falsa la condicion de repeticion
y no se produce una nueva llamada.
*************************************************************************/
nodo* eliminarNodosDiagonal(nodo**pi,nodo**pf)
{
nodo *pant,*pr;
pr=pant=*pi;
while(pr->fila!=pr->columna)
{
pant=pr;
pr=pr->ptr;
}
if(*pi==pr)
*pi=(*pi)->ptr;
else
pant->ptr=pr->ptr;
if(*pf==pr)

11

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone
*pf=pant;
free(pr);
return pant;
}

/***************************************************************************
Esta funcion corre algunos nodos hacia la izquierda restando 1 a la columna.

Los elementos de la matriz que se encuentran a la derecha de la diagonal


principal
tinen un valor mayor al de la fila y por esta particularidad los identificamos
******************************************************************************/
void correrColumna(nodo*pi)
{
while(pi)
{
if(pi->columna > pi->fila)
pi->columna-=1;

pi=pi->ptr;
}
}

12

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone

Ejercicio 2
/*
Con los resultados parciales de las elecciones realizadas, en distintas zonas,
de una determinada institucin debe grabarse un archivo binario.
La informacin de cada mesa de votacion se presenta de la siguiente manera:
"

Nombre de la zona ( 30 caracteres)

"

Numero de la lista.

"

Cantidad de votos obtenidos en la zona

Por teclado se ingresan los resultados parciales. La informacin termina con


Nombre de la zona igual a "FIN" .

A-) A partir de la informacion del archivo generar una lista simplemente


enlazada
ordenada por Numero de la lista, cuya informacin sea:
"

Numero de la lista.

"

Cantidad total de votos obtenidos. (de todas las zonas)

Si el numero de la lista ya existe en la lista dinmica, sumar los votos


y si no existe, insertar ese numero y los votos correspondientes, respetando el
orden.

B-) Indicar la lista ganadora.


13

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone

C-) Apilar todas aquellas listas, cuyo porcentaje estuvo debajo del 10% de la
ganadora.

NOTA: La resolucin se considera correcta si utiliza las funciones


correspondientes.
*/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define limpiar system("cls");


#define parar printf("\n\n");system("pause");

typedef struct a nodo;

struct a
{
int lista;
int votos;
nodo *p;
};
typedef struct
{
char nombre[31];

14

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone
int lista;
int votos;
}registro;
void enlistar(nodo**,nodo*);
nodo* desenlistar(nodo**,float);
void apilar(nodo**,nodo*);
int winner(nodo*);
void listar(nodo*);

main()
{
nodo *pip,*q, *pil;
registro reg;
char
*localidades[]={"Lanus","Glew","Lanus","Gerli","Glew","Lanus","Gerli","Glew","
Gerli","Lanus","Glew","Glew"};
int listas[]={1,1,3,2,1,3,2,2,1,2,1,1};
int votos[]={12,32,15,23,56,65,17,19,41,99,102,87};
int i;
int suma[3]={0};
FILE *pf;
pip=pil=NULL;

pf=fopen("c:\\votos.dat","w+b");

15

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone
for(i=0;i<12;i++)
{
strcpy(reg.nombre,localidades[i]);
reg.lista=listas[i];
reg.votos=votos[i];
suma[listas[i]-1]+=votos[i];
fwrite(&reg,sizeof(reg),1,pf);
}

limpiar
printf("CONTENIDO DEL ARCHIVO\n\n");
rewind(pf);
printf("%-15s %-10s %-10s\n","Nombre","Lista","Votos\n");
fread(&reg,sizeof(reg),1,pf);
while(!feof(pf))
{
printf("%-15s %-10d %-10d\n",reg.nombre,reg.lista,reg.votos);
fread(&reg,sizeof(reg),1,pf);
}
parar

rewind(pf);
fread(&reg,sizeof(reg),1,pf);
while(!feof(pf))

16

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone
{
q=(nodo*)malloc(sizeof(nodo));

q->lista=reg.lista;
q->votos=reg.votos;

enlistar(&pil,q);

fread(&reg,sizeof(reg),1,pf);
}

limpiar
printf("CONTENIDO DE LA LISTA\n\n");
for(i=0;i<3;i++)printf("%8d",suma[i]);printf("\n\n");
listar(pil);
parar

return 0;
}

void enlistar(nodo**pi,nodo*q)
{

17

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone
nodo*ant,*pr;
pr=*pi;

if(*pi==NULL||q->lista < pr->lista)


{
q->p=*pi;
*pi=q;
return;
}

while(pr && q->lista > pr->lista)


{
ant=pr;
pr=pr->p;
}

if(pr&&pr->lista==q->lista)
pr->votos+=q->votos;
else
{
q->p=ant->p;
ant->p=q;
}
}

18

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone

void listar(nodo*pi)
{
while(pi)
{
printf("%-10d %-10d \n",pi->lista,pi->votos);
pi=pi->p;
}
}

Ejercicio 3
/*
Disear un programa que permita crear una lista de nombres ORDENADA DE A
aZ
El programa deber permitir la busqueda y eliminacion de un nombre de la
lista
y la eliminacion de la lista en caso que al optar por la salida del programa
la lista no se haya vaciado.
*/

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

#define limpiar system("cls");


#define parar printf("\n\n");system("pause");
19

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone
typedef struct r nodo;
struct r
{
char nombre[30];
nodo* p;
};

void enlistar(nodo**,nodo*);
nodo* desenlistar(nodo**,char*);
void listar(nodo*);
void eliminarLista(nodo**);
nodo* nuevonodo(void);
int menu(void);

main()
{
nodo *pi,*q,*pr;
nodo ;
int op;
char buscado[30];

pi=NULL;

20

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone
do
{
op=menu();

switch(op)
{
case 1:
q=nuevonodo();
enlistar(&pi,q);
break;
case 2:
limpiar
if(pi)
{
printf("Ingrese nombre a buscar: ");
fflush(stdin);
gets(buscado);

pr=desenlistar(&pi,buscado);

if(pr)
{
printf("\n\nNombre eliminado: %s",pr->nombre);
free(pr);

21

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone
}
else
printf("\n\nNOMBRE INEXISTENTE");
}
else
printf("\n\nLISTA VACIA");
parar
break;
case 3:
limpiar
if(pi)
{
printf("CONTENIDO DE LA LISTA\n\n");
listar(pi);
}
else
printf("\n\nLISTA VACIA");
parar
break;
}
}while(op<4);

if(pi)
eliminarLista(&pi);

22

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone

return 0;
}

int menu(void)
{
/////////////////////////////////////////////////////////////////////////////
//

EL MENU DE OPCIONES SOLO SE UTILIZA PARA TRABAJOS DE PRACTICA

//

EN CLASE: EN PARCIALES Y/O FINALES SOLAMENTE SI SE PIDE!!!

//
//

/////////////////////////////////////////////////////////////////////////////
int op;
do
{
limpiar
printf("MENU DE OPCIONES\n\n");
printf("1- Agregar Nombre\n");
printf("2- Buscar Nombre\n");
printf("3- Listar Contenido\n");
printf("4- SALIR\n\n");
printf("Ingresar Opcion: ");
scanf("%d",&op);
}while(op<1||op>4);

return op;
23

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone
}
void enlistar(nodo**pi,nodo*q)
{
nodo*pant,*pr;

pant=pr=*pi;

if(*pi==NULL ||strcmp(q->nombre,pr->nombre)<=0)
{
q->p=*pi;
*pi=q;
return;
}
while(pr&&strcmp(q->nombre,pr->nombre)>0)
{
pant=pr;
pr=pr->p;
}
pant->p=q;
q->p=pr;
}

void listar(nodo*pi)
{

24

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone
while(pi)
{
printf("%-20s\n",pi->nombre);

pi=pi->p;
}
}

void eliminarLista(nodo**pi)
{
nodo *aux;
while(*pi)
{
aux=*pi;
*pi=(*pi)->p;
free(aux);
}
}

nodo* desenlistar(nodo **pi,char*buscado)


{
nodo *pr,*pant;
pr=*pi;

25

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone
while(pr&&strcmp(pr->nombre,buscado)!=0)
{
pant=pr;
pr=pr->p;
}
if(pr)
{
if(pr==*pi)
*pi=(*pi)->p;
else
pant->p=pr->p;
}
return pr;
}

nodo* nuevonodo(void)
{
nodo*q;

q=(nodo*)malloc(sizeof(nodo));

limpiar
printf("Ingresar Nombre: ");
fflush(stdin);

26

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone
gets(q->nombre);

return q;
}

/*
Se ingresa por teclado informacin acerca de las horas trabajadas diarias por
los operarios en una planta fabril durante un determinado mes. Dicha
informacin
consta de :

"

Nro. de legajo del empleado (entero)

"

Cantidad de horas trabajas DIARIAS(entero)

Esta informacin termina con Nro. de legajo igual a cero.


Se sabe adems que los legajos de 1 a 199 el valor por hora es de $20 y para
los restantes es de $15.

Se pide:
1.
Generar una lista ordenada POR LEGAJO , indicando, para cada
empleado:
"

Nro. de Legajo

"

Cantidad total de horas trabajadas en EL

MES.

2.

Listar la informacin mensual resultante de la lista.


27

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone

3.

Con la informacin anterior generar un archivo binario, que guarde la


siguiente informacin:

4.

"

Nro. Legajo

"

Sueldo mensual

Listar los datos del archivo.

********************************************************************************
LOTE DE PRUEBA EJEMPLO:

INGRESO POR TECLADO


Nro. legajo

Cantidad de horas trabajadas DIARIAS


50

330

60

40

10

50

4
330

50

10

0
INFORMACIN MENSUAL RESULTANTE EN LA LISTA (ORDENADA POR LEGAJO)
Nro. legajo
40

Cantidad de hora trabajadas MENSUALES


10

28

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone
50

22

60

330

13

LISTADO DEL ARCHIVO


Nro. legajo

SUELDO

40

200

50

440

60

180

330

195

*/

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

#define LIMPIAR system("cls");


#define PARAR printf("\n\n");system("pause");
typedef struct a nodo;

struct a
{
int legajo;
int horas;

29

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone
nodo *p;
};

typedef struct
{
int legajo;
int sueldo;
}registro;

void enlistar(nodo**,nodo*);
nodo desenlistar(nodo**);
void listar(nodo*);
void archivar(nodo*);

main()
{
nodo *pi,*q,datos;
int i;
int legajos[]={215,190,45,321,12,120,223,231,156,171};
FILE *parch;
registro reg;
pi=NULL;

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

30

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone
{
q=(nodo*)malloc(sizeof(nodo));
q->legajo=legajos[i];
q->horas=rand()%100+100;// random(101)+99

enlistar(&pi,q);
}

LIMPIAR
printf("CONTENIDO LISTA\n\n");
listar(pi);
PARAR

parch=fopen("c:\sueldos","w+b");

while(pi)
{
datos=desenlistar(&pi);

reg.legajo=datos.legajo;
if(reg.legajo>199)
reg.sueldo=datos.horas*15;
else
reg.sueldo=datos.horas*20;

31

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone

fwrite(&reg,sizeof(reg),1,parch);
}

printf("CONTENIDO ARCHIVO\n\n");

rewind(parch);

fread(&reg,sizeof(reg),1,parch);

while(!feof(parch))
{
printf("%-10d %10d \n",reg.legajo,reg.sueldo);

fread(&reg,sizeof(reg),1,parch);
}

PARAR

fclose(parch);
return 0;
}

32

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone

void listar(nodo*pi)
{
while(pi)
{
printf("%5d %5d\n",pi->legajo,pi->horas);

pi=pi->p;
}
}

void enlistar(nodo**pi,nodo*q)
{
nodo *ant,*pr;
pr=*pi;

if(*pi==NULL|| q->legajo<=pr->legajo)
{
q->p=*pi;
*pi=q;
return;
}
while(pr&& q->legajo>pr->legajo)
{

33

Ejercicios Resueltos de Estructura de Datos II


Listas
Prof. Lic. Oscar Eduardo Malone
ant=pr;
pr=pr->p;
}
q->p=ant->p;
ant->p=q;
}

nodo desenlistar(nodo**pi)
{
nodo*aux,datos;
aux=*pi;
datos=**pi;
*pi=(*pi)->p;
free(aux);
return datos;
}

34