Donar $20 Donar $50 Donar $100 Donar mensualmente
 


Enviar respuesta 
 
Calificación:
  • 2 votos - 4 Media
  • 1
  • 2
  • 3
  • 4
  • 5
Buscar en el tema
[Aporte] Listas + pila + cola + archivos (simple enlazada - strings)
Autor Mensaje
Feer Sin conexión
Presidente del CEIT
win-win
**********

Ing. Electrónica
Facultad Regional Buenos Aires

Mensajes: 4.565
Agradecimientos dados: 594
Agradecimientos: 2.483 en 411 posts
Registro en: Apr 2010
Mensaje: #1
[Aporte] Listas + pila + cola + archivos (simple enlazada - strings) Apuntes y Guias Informática I (Electrónica)
Bueno termine las funciones de listas simple enlazada para strings contiene:

Agregar al principio (pila cola)
Agregar al final (cola)
Borrar primer elemento (pila o cola)
Borrar ultimo elemento (pila o cola)
Ver la cantidad de elementos de la lista..
Insertar ordenado a la lista
Ordenar la lista.
Buscar la palabra "mínima"
Buscar la palabra "máxima"
Listar la lista..
Eliminar la lista.
Guardar la lista en un archivo
Recuperar la lista desde un archivo


En fin dejo el código funcionando, espero que sirvaFeer





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

#define ERROR -1
#define OK 1

#define MAX_CARACTERES 50
#define SALIR 0


typedef struct{
char elemento[MAX_CARACTERES];
struct nodo *siguiente;
}NODO;

int menu(void);
char *gets_s(char *, int);
int agregar_principio(char **);
int agregar_final(NODO **lista);
int borrar_primer_elemento(NODO **lista);
int cant_elementos(NODO *lista);
void listar(NODO *lista);
int elimiar_lista(NODO **lista);
void salir(NODO **lista);
int borrar_ultimo_elemento(NODO **lista);
int buscar_min(NODO *lista);
int buscar_max(NODO *lista);
int guardar_lista(NODO *lista);
NODO* cargar_lista(void);
int agregar_nodo(char **lista,NODO aux);
int insertar_ordenado(NODO **lista);
void ordenar_lista(NODO **lista);
int insertar_ordenado_ordenar_lista(NODO **lista_nueva,char *contenido);
void eliminar_primer_nodo(NODO **aux, char *contenido);


int main(void){

NODO *lista = NULL;
int opcion;
int cantidad;

printf("-------------------------\n");
printf("- Bienvenido al sistema -\n");
printf("-------------------------\n");

do{
opcion = menu();
switch(opcion){
case 1: agregar_principio(&lista); break;
case 2: agregar_final(&lista); break;
case 3: insertar_ordenado(&lista); break;
case 4: borrar_primer_elemento(&lista); break;
case 5: borrar_ultimo_elemento(&lista); break;
case 6: cantidad = cant_elementos(lista); break;
case 7: ordenar_lista(&lista); break;
case 8: buscar_min(lista); break;
case 9: buscar_max(lista); break;
case 10: listar(lista); break;
case 11: elimiar_lista(&lista);break;
case 12: guardar_lista(lista); break;
case 13: lista = cargar_lista(); break;
case 0: salir(&lista);break;
default: printf("Opcion incorrecta");break;
}
}while(opcion!=SALIR);
puts("Fin del programa");
getchar();
getchar();
return(1);
}

int menu(void){

int opcion;

printf("--------------------\n");
printf("- Menu del sistema -\n");
printf("--------------------\n");

printf("\n\t1- Agregar elemento al principio de la lista.\n"
"\t2- Agregar elemento al final de la lista.\n"
"\t3- Agregar elemento ordenado en la lista.\n"
"\t4- Borrar primer elemento de la lista.\n"
"\t5- Borrar ultimo elemento de la lista.\n"
"\t6- Cantidad de elementos de la lista.\n"
"\t7- Ordenar lista.\n"
"\t8- Buscar minimo.\n"
"\t9- Buscar maximo.\n"
"\t10- Listar lista.\n"
"\t11- eliminar lista.\n"
"\t12- Guardar lista (testeando).\n"
"\t13- Cargar lista (testeando).\n"
"\t0- Salir del programa.\n\n");
scanf("%d",&opcion);
return(opcion);
}

int agregar_principio(char **lista){

NODO *nuevo;
char nuevo_dato[MAX_CARACTERES];
getchar();
nuevo = (NODO*) malloc(sizeof(NODO));
if(nuevo == NULL){
puts("Error en pedido de memoria");
return(ERROR);
}
puts("Escriba el dato del nuevo nodo");
gets_s(nuevo_dato,MAX_CARACTERES);
strcpy(nuevo->elemento,nuevo_dato);
nuevo->siguiente = NULL;
if(*lista == NULL){
*lista = nuevo;
return(OK);
}
else{
nuevo->siguiente = *lista;
*lista = nuevo;
return(OK);
}
}

int agregar_final(NODO **lista){

NODO *nuevo;
NODO *ptr_ant = *lista;
NODO *ptr_aux = *lista;

char nuevo_dato[MAX_CARACTERES];
getchar();
nuevo = (NODO*) malloc(sizeof(NODO));
if(nuevo == NULL){
puts("Error en pedido de memoria");
return(ERROR);
}
nuevo->siguiente = NULL;
puts("Escriba el dato del nuevo nodo");
gets_s(nuevo_dato,MAX_CARACTERES);
strcpy(nuevo->elemento,nuevo_dato);

if(*lista == NULL){ //Si no inserte nodos todavia.
*lista = nuevo;
return(OK);
}
while(ptr_aux!=NULL){
ptr_ant = ptr_aux;
ptr_aux = ptr_aux->siguiente;
}
ptr_ant->siguiente = nuevo;
return(OK);
}

int borrar_primer_elemento(NODO **lista){

NODO *ptr_ant = *lista;
NODO *ptr_aux = *lista;
getchar();

if(*lista == NULL){ //Si no hay elementos en la lista.
puts("No hay elementos para borrar");
return(OK);
}
if(ptr_aux->siguiente == NULL){ //Unico elemento en la lista.
*lista = NULL;
free(ptr_aux);
return(1);
}
//Si hay 2 elementos o mas...

ptr_aux = ptr_aux->siguiente;
free(ptr_ant);
*lista = ptr_aux;
return(1);
}


int cant_elementos(NODO *lista){

int cantidad=0;

if(lista == NULL){
puts("No se insertaron elementos aun\n");
return(0);
}
while(lista != NULL){
lista = lista->siguiente;
cantidad++;
}
printf("Cantidad de elementos: %d\n",cantidad);
return(cantidad);
}

void listar(NODO *lista){

if(lista == NULL){
puts("No hay datos en la lista");
}
else{
do{
printf("%s\n",lista->elemento);
lista=lista->siguiente;
}while(lista != NULL);
}
}


int elimiar_lista(NODO **lista){

NODO *aux;
NODO *ptr_borrar;

if(*lista == NULL){
puts("No hay lista");
return(OK);
}
else{
aux = *lista;
do{
ptr_borrar = aux;
aux = aux->siguiente;
free(ptr_borrar);
}while(aux!=NULL);
}
*lista = NULL;
return(OK);
}


int borrar_ultimo_elemento(NODO **lista){

NODO *ptr_aux = NULL;
NODO *ptr_ant = NULL;
NODO *ptr_null= NULL;

if(*lista == NULL){
puts("No hay nodos ingresados en el sistema");
return(OK);
}
else{
ptr_aux = *lista;
ptr_ant = ptr_aux;

if((ptr_aux->siguiente) == NULL){ //unico nodo..
free(ptr_aux);
*lista = NULL;
return(OK);
}
do{
ptr_null= ptr_ant;
ptr_ant = ptr_aux;
ptr_aux = ptr_aux->siguiente;
}while(ptr_aux!=NULL);
ptr_null->siguiente = NULL;
free(ptr_ant);
return(OK);
}
}


int buscar_min(NODO *lista){

NODO *menor;
if(lista == NULL){
puts("No hay elementos ingresados aun en el sistema");
return(OK);
}
strcpy(menor->elemento,lista->elemento);
do{

if(strcmp(menor->elemento,lista->elemento)>0){ //lista->elemento menor
//que auxiliar
strcpy(menor->elemento,lista->elemento);
lista = lista->siguiente;
}
else{
lista = lista->siguiente;
}
}while(lista!=NULL);
printf("El menor elemento es: %s\n",menor->elemento);
return(1);
}


int buscar_max(NODO *lista){

NODO *menor;
if(lista == NULL){
puts("No hay elementos ingresados aun en el sistema");
return(OK);
}
strcpy(menor->elemento,lista->elemento);
do{

if(strcmp(menor->elemento,lista->elemento)<0){//lista->elemento menor
//que auxiliar
strcpy(menor->elemento,lista->elemento);
lista = lista->siguiente;
}
else{
lista = lista->siguiente;
}
}while(lista!=NULL);
printf("El menor elemento es: %s\n",menor->elemento);
return(1);
}


int guardar_lista(NODO *lista){

FILE *fd;

fd = fopen("DatosLista.txt","a+");
if(fd == NULL){
puts("Error al abrir el archivo");
return(ERROR);
}
do{
fwrite(lista,sizeof(NODO),1,fd);
lista = lista->siguiente;
}while(lista!=NULL);
fclose(fd);
return(OK);
}


NODO* cargar_lista(void){

FILE *fd;
NODO *lista = NULL;
NODO aux;

fd = fopen("DatosLista.txt","a+");
if(fd == NULL){
puts("Error al abrir el archivo");
return(ERROR);
}

do{
fread(&aux,sizeof(NODO),1,fd);
agregar_nodo(&lista,aux);
}while(!feof(fd));
fclose(fd);
return(lista);
}



char *gets_s(char *s, int size){
int len;

if (!fgets(s, size, stdin)){
if (size > 0)
s[0] = '\0';
return NULL;
}
else{
len = strlen(s);
if (len && s[len-1] == '\n')
s[len-1] = '\0';
return s;
}
}

void salir(NODO **lista){

NODO *aux;
NODO *ptr_borrar;

if(*lista == NULL){
return(OK);
}
else{
aux = *lista;
do{
ptr_borrar = aux;
aux = aux->siguiente;
free(ptr_borrar);
}while(aux!=NULL);
}
*lista = NULL;
return(OK);
}



int agregar_nodo(char **lista,NODO aux){

NODO *nuevo;

nuevo = (NODO*) malloc(sizeof(NODO));
if(nuevo == NULL){
puts("Error en pedido de memoria");
return(ERROR);
}
strcpy(nuevo->elemento,aux.elemento);
nuevo->siguiente = NULL;
if(*lista == NULL){
*lista = nuevo;
return(OK);
}
else{
nuevo->siguiente = *lista;
*lista = nuevo;
return(OK);
}
}



int insertar_ordenado(NODO **lista){

NODO *nuevo_dato = NULL; //nodo para el nuevo dato.
NODO *aux = NULL;//para recorrer la lista sin perder la referencia de la list
NODO *ant = NULL;//para recorrer la lista y poder realizar el agregado de nod
char nuevo_elemento[MAX_CARACTERES];

nuevo_dato = (NODO *) malloc(sizeof(NODO));
if(nuevo_dato == NULL){
printf("Error al pedir memoria");
return(-1);
}
getchar();
puts("Escriba el dato del nuevo nodo");
gets_s(nuevo_elemento,MAX_CARACTERES);
strcpy(nuevo_dato->elemento,nuevo_elemento);
nuevo_dato->siguiente = NULL;

if(*lista == NULL){ //Si todavia no ingrese ningun nodo..
*lista = nuevo_dato;
return(1);
}
else{ //Si ya habia ingresado nodos...
aux = *lista;

while((aux != NULL)&&(strcmp(aux->elemento,nuevo_elemento)<0)){ //mientras
//contenido no supere al valor del nodo actual.
ant = aux;
aux = aux->siguiente; //apunto al siguiente nodo.
}

if(ant == NULL){ //Si se mete al principio de la lista
nuevo_dato->siguiente = *lista;
*lista = nuevo_dato;
}

else{ //Si se mete en el medio de la lista.
ant->siguiente = nuevo_dato;
nuevo_dato->siguiente = aux;
}
return(1);
}
}


void ordenar_lista(NODO **lista){

NODO *lista_nueva = NULL; //aca guardo la lista como la voy ordenando.
NODO *aux; //Este es para recorrer la lista y no perder la referencia.
char contenido[MAX_CARACTERES]; //contiene el valor que saco de la lista
//para ubicar en la nueva ordenada.

aux = *lista;
while(aux!=NULL){
eliminar_primer_nodo(&aux,contenido);
insertar_ordenado_ordenar_lista(&lista_nueva, contenido);
}
*lista = lista_nueva;

}


int insertar_ordenado_ordenar_lista(NODO **lista_nueva,char *contenido){

NODO *nuevo_nodo = NULL; //nodo para el nuevo dato.
NODO *aux = NULL;//para recorrer la lista sin perder la referencia de la list
NODO *ant = NULL;//para recorrer la lista y poder realiz el agregado de nodo.

nuevo_nodo = (NODO *) malloc(sizeof(NODO));
if(nuevo_nodo == NULL){
printf("Error al pedir memoria");
return(-1);
}

strcpy(nuevo_nodo->elemento,contenido);
nuevo_nodo->siguiente = NULL;

if(*lista_nueva == NULL){ //Si todavia no ingrese ningun nodo..
*lista_nueva = nuevo_nodo;
return(1);
}
else{ //Si ya habia ingresado nodos...
aux = *lista_nueva;

while((aux != NULL)&&(strcmp(aux->elemento,contenido)<0)){ //mientras
//contenido no supere al valor del nodo actual.
ant = aux;
aux = aux->siguiente; //apunto al siguiente nodo.
}

if(ant == NULL){ //Si se mete al principio de la lista
nuevo_nodo->siguiente = *lista_nueva;
*lista_nueva = nuevo_nodo;
}

else{ //Si se mete en el medio de la lista.
ant->siguiente = nuevo_nodo;
nuevo_nodo->siguiente = aux;
}
return(1);
}
}


void eliminar_primer_nodo(NODO **aux, char *contenido){

NODO *temp = NULL; //para no tener problemas con el asteris. de aux.
NODO *siguiente_dato; //tenia problemas con el ** de aux

temp = *aux;
siguiente_dato = *aux;
strcpy(contenido,temp->elemento);
*aux = siguiente_dato->siguiente;
free(temp);
}




[Imagen: digitalizartransparent.png]
11-02-2013 18:37
Encuentra todos sus mensajes Agregar agradecimiento Cita este mensaje en tu respuesta
[-] Feer recibio 6 Gracias por este post
nanohueso (28-07-2013), Lucaas (08-09-2013), alfijuan (03-12-2014), inrockuptible (05-12-2014), Diegvar95 (26-07-2015), MarRodrigo (19-08-2016)
Buscar en el tema
Enviar respuesta 




Usuario(s) navegando en este tema: 1 invitado(s)



    This forum uses Lukasz Tkacz MyBB addons.