Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Estructura de Datos II
Listas
12/10/2010
Universidad Argentina Jhon F. Kennedy
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.
"
Numero de fila
"
Numero de columna
"
Valor almacenado
#include<stdio.h>
#include<stdlib.h>
#define N 10
typedef struct r nodo;
struct r
{
int fila;
int columna;
int dato;
nodo *ptr;
};
3
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;
/*****************************************************************
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++)
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++)
{
/**************************************************
Avanzamos al proximo nodo
**************************************************/
paux=paux->ptr;
}
else
/************************************************************
/*********************************************************************
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);
/************************************************************************
Modificamos los valores de columna de todos los elementoas de la matriz
/******************************************************************
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
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
/*************************************************************************
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
/***************************************************************************
Esta funcion corre algunos nodos hacia la izquierda restando 1 a la columna.
pi=pi->ptr;
}
}
12
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:
"
"
Numero de la lista.
"
Numero de la lista.
"
C-) Apilar todas aquellas listas, cuyo porcentaje estuvo debajo del 10% de la
ganadora.
struct a
{
int lista;
int votos;
nodo *p;
};
typedef struct
{
char nombre[31];
14
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
limpiar
printf("CONTENIDO DEL ARCHIVO\n\n");
rewind(pf);
printf("%-15s %-10s %-10s\n","Nombre","Lista","Votos\n");
fread(®,sizeof(reg),1,pf);
while(!feof(pf))
{
printf("%-15s %-10d %-10d\n",reg.nombre,reg.lista,reg.votos);
fread(®,sizeof(reg),1,pf);
}
parar
rewind(pf);
fread(®,sizeof(reg),1,pf);
while(!feof(pf))
16
q->lista=reg.lista;
q->votos=reg.votos;
enlistar(&pil,q);
fread(®,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
if(pr&&pr->lista==q->lista)
pr->votos+=q->votos;
else
{
q->p=ant->p;
ant->p=q;
}
}
18
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>
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
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
if(pi)
eliminarLista(&pi);
22
return 0;
}
int menu(void)
{
/////////////////////////////////////////////////////////////////////////////
//
//
//
//
/////////////////////////////////////////////////////////////////////////////
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
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
pi=pi->p;
}
}
void eliminarLista(nodo**pi)
{
nodo *aux;
while(*pi)
{
aux=*pi;
*pi=(*pi)->p;
free(aux);
}
}
25
nodo* nuevonodo(void)
{
nodo*q;
q=(nodo*)malloc(sizeof(nodo));
limpiar
printf("Ingresar Nombre: ");
fflush(stdin);
26
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 :
"
"
Se pide:
1.
Generar una lista ordenada POR LEGAJO , indicando, para cada
empleado:
"
Nro. de Legajo
"
MES.
2.
3.
4.
"
Nro. Legajo
"
Sueldo mensual
********************************************************************************
LOTE DE PRUEBA EJEMPLO:
330
60
40
10
50
4
330
50
10
0
INFORMACIN MENSUAL RESULTANTE EN LA LISTA (ORDENADA POR LEGAJO)
Nro. legajo
40
28
22
60
330
13
SUELDO
40
200
50
440
60
180
330
195
*/
#include<stdio.h>
#include<stdlib.H>
struct a
{
int legajo;
int horas;
29
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
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
fwrite(®,sizeof(reg),1,parch);
}
printf("CONTENIDO ARCHIVO\n\n");
rewind(parch);
fread(®,sizeof(reg),1,parch);
while(!feof(parch))
{
printf("%-10d %10d \n",reg.legajo,reg.sueldo);
fread(®,sizeof(reg),1,parch);
}
PARAR
fclose(parch);
return 0;
}
32
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
nodo desenlistar(nodo**pi)
{
nodo*aux,datos;
aux=*pi;
datos=**pi;
*pi=(*pi)->p;
free(aux);
return datos;
}
34