LISTA ENLAZADA SIMPLE.  La lista enlazada básica es la lista enlazada simple la cual tiene un enlace por nodo. Este enlace apunta al siguiente nodo en.

Slides:



Advertisements
Presentaciones similares
Instrucciones Básicas Entrada de Información
Advertisements

ÁRBOLES EN C UNIVERSIDAD “ALONSO DE OJEDA” Facultad de Ingeniería
Ejemplo de Programa C++
TDA LISTA ESTRUCTURAS DE DATOS.
Unidad 5 Listas Enlazadas Bibliografía: Algoritmos y Estructuras de datos de Aguilar y Martinez. Unidad 9 Autor: Ing Rolando Simon Titiosky.
Listas enlazadas c++ Prof. Franklin Cedeño.
Tipos de Datos Abstractos (III) Clase #23 Introducción a la Programación.
Programación II Listas
Estructuras de datos y algoritmos
1 Extensión de un Estructura de Datos Agustín J. González ELO-320: Estructura de Datos y Algoritmos.
LOGROS DEL PERÍODO Utiliza de forma correcta las funciones para entrada y salida de datos en c++. Utiliza los elementos básicos de un programa en c++.
Programación, Algoritmos y Estructuras de Datos
9A9A9A9A Grado en Ingeniería Informática Grado en Ingeniería del Software Grado en Ingeniería de Computadores Luis Hernández Yáñez Facultad de Informática.
Comparador de iluminación Sensor de puerta Potencia Iluminación Generador Alarma.
INFORMATICA I Funciones CLASE 13.
Programación en C (Segunda Parte) DATSI, FI, UPM José M. Peña
Tratamiento de listas en Java
UNIVERSIDAD NACIONAL AUTÓNOMA DE MÉXICO
Implementación de Listas
ESTRUCTURAS DE SECUENCIA
SOBRECARGA DE FUNCIONES
Unidad 3 Punteros.
Oscar Bedoya. Edificio 331, 2º piso, E.I.S.C. Estructuras de datos y algoritmos.
ÁRBOLES DE EXPRESION.
Estructuras dinámicas de datos, TAD Lista, parte 2
COLAS, IMPLEMENTACIÓN A PARTIR DE LISTAS Y PARA PILAS
Igor Santos Grueiro. De este tipo de pilas NO vamos a hablar.
Archivos Programación.
ÁRBOLES BINARIOS DE BÚSQUEDA
C++ LISTAS C++ 11/04/2017 Ing. Edgar Ruiz Lizama.
Estructuras.
TABLAS Definición. El tipo tabla permite definir objetos formados por un conjunto de elementos del mismo tipo. Ejemplos. El tipo tabla se utiliza para.
FUNCIONES O PROCEDIMIENTOS
Árboles binarios de búsqueda
Unidad VI Registros (estructuras, uniones y enumeraciones)
El lenguaje de programación C - Identificadores y variables – Isidro González Caballero ( Introducción.
1 Estructuras de Datos Elementales:stacks (pilas), queues (colas), linked lists (listas enlazadas), y rooted trees (árboles con raíz) Agustín J. González.
Estructuras de Datos Dinámicas: Listas Programación I Departamento de Informática Universidad Nacional de San Luis Argentina 2014.
Pilas y Colas Estructuras de Datos.
LISTA DOBLEMENTE ENLAZADA
Dinamismo y Contenedores Facultad de Ciencias Exactas y Naturales Universidad de Buenos Aires (C++ Avanzado) Depto. de Computación Algoritmos y Estructuras.
Universitarios: Ricardo Gonzales Jimenez Wilfredo Coca Reinaldo Yohan Docente: Lic. Israel Torrez Valverde Tema: Listas doblemente Enlazadas.
Laboratorio Análisis y Diseño de Algoritmos 2 Biblioteca estándar de templates de C++ Standard Template Library (STL)‏ Motivación Ejemplo: Lista + Iterador.
Listas Ligadas Simples. Definíción I  Es, en sencillas palabras. un grupo de datos organizados secuencialmente, pero a diferencia de los arreglos, la.
Diseño de Algoritmos. Curso J.L. Leiva O. TEMA3TEMA3 TEMA3TEMA3 Estructuras Dinámicas Contenido del Tema Profesor: José Luis Leiva Olivencia. Despacho:
Funciones Curso Propedéutico Maestría en Ingeniería Electrónica.
Unidad 4: LISTAS.
Pag. 1 LISTAS ENLAZADAS Ing. Betty Suárez Torres.
Conceptos Avanzados de Programación
Sesión 2. Este algoritmo ordena un arreglo de forma ascendente o descendente comparando la casilla de arriba con la casilla consecutiva de abajo, utiliza.
Registros Prof. Flor Narciso Departamento de Computación Escuela de Ingeniería de Sistemas Facultad de Ingeniería Universidad de Los Andes.
Estructuras de datos Fundamentos de análisis y diseño de algoritmos.
INSTITUTO TECNOLOGICO DE APIZACO
Algoritmos y Estructuras de datos Listas Doblemente enlazadas
INTRODUCCIÓN AL LENGUAJE C++. Instrucciones Temas.
Ayudantia 3: Pilas- Colas
Algoritmo.
Corporación Universitaria del Caribe CECAR Fundamentos de programación II.
Laboratorio de programación
Laboratorio de programación Luisa Fernanda Rincón Pérez
 Las funciones son un conjunto de instrucciones que realizan una tarea específica. En general toman unos valores de entrada, llamados parámetros y proporcionan.
PARCIAL 3. CADENAS Y CARACTERES PARA PODER DISTINGUIR LOS DATOS DE TIPO CARACTER (CHAR), ESTOS SE ENCIERRAN EN COMILLAS SIMPLES. LOS DATOS DE TIPO CARÁCTER.
Listas Dinámicas.
UNIDAD 8 Lista Enlazada: Eliminar Deseamos eliminar un elemento llamado elem de la lista enlazada. Es posible que la variable ini sea modificada. main(){
1 ListaUna Lista se define como una serie de N elementos E 1, E 2,..., E N, ordenados de manera consecutiva, es decir, el elemento E k (que se denomina.
UNIVERSIDAD DIEGO PORTALES Facultad de Ingeniería Programación Avanzada TIPOS ABSTRACTOS DE DATOS TAD Tema: TIPOS ABSTRACTOS DE DATOS TAD Subtema: LISTAS.
Lenguaje de Programación II Prof. Rafael Montenegro B. Carrera: T.S.U en Informática Periodo: 2014-I.
Computación I :: Prof. Yeniffer Peña Lenguaje C Presentación Computación I.
Estructuras PILA - COLA - LISTA.
LISTAS..
Transcripción de la presentación:

LISTA ENLAZADA SIMPLE

 La lista enlazada básica es la lista enlazada simple la cual tiene un enlace por nodo. Este enlace apunta al siguiente nodo en la lista, o al valor NULL o a la lista vacía, si es el último nodo.

 He aquí tenemos un ejemplo de una lista enlazada simple:  DECLARACIÓN DE PROTOTIPOS #include #include #include #include  DECLARAMOS LA ESTRUCTURA typedef struct nodo { int dato; struct nodo * siguiente; }tipoNodo;  RESERVAMOS EL ESPACIO DE MEMORIA tipoNodo *nuevo_elemento();

 OPERACIONES QUE VAMOS A AREALIZAR void crear(); void insertar(); void insertar_inicio(); void insertar_ordenado(); void insertar_final(); void presentar(); void modificar(); void buscar(); void ordenar(); void ordenar_ascendente(); void ordenar_descendente(); void eliminar(); void eliminar_cabeza();  FUNCIÓN PARA EL CUADRO void cuadro(int x1,int y1, int x2, int y2, char simb);

 NUESTRA CABEZA tipoNodo *cab; tipoNodo *nuevo_elemento() { tipoNodo *nodo1; nodo1=(tipoNodo *)malloc(sizeof(tipoNodo )); if(!nodo1) cout<<“No se ha reservado memoria para el nuevo “; return nodo1; } void main() { clrscr(); crear(); clrscr(); char opc=’ ‘;

do { clrscr(); cuadro(1,10,35,56,’²’); gotoxy(13,3);cout [ LISTAS ENLAZADAS ]<- \n”; gotoxy(12,6);cout<<” MENU PRINCIPAL\n”; gotoxy(12,9); cout<<” [1]: INSERTAR\n”; gotoxy(12,12);cout<<” [2]: MODIFICAR\n”; gotoxy(12,15);cout<<” [3]: BUSCAR\n”; gotoxy(12,17);cout<<” [4]: ORDENAR\n”; gotoxy(12,19);cout<<” [5]: ELIMINAR\n”; gotoxy(12,21);cout<<” [6]: PRESENTAR\n”; gotoxy(12,24);cout<<” [7]: SALIR DEL MENU\n”; gotoxy(12,27);cout >opc;

switch(opc) { case’1′: clrscr(); insertar();getch();break; case’2′: clrscr(); modificar();getch();break; case’3′: clrscr(); buscar();getch();break; case’4′: clrscr(); ordenar();getch();break; case’5′: clrscr(); eliminar();getch();break;

case’6′: clrscr(); presentar();getch();break; } }while(opc!=’7′); getch(); }  CREANDO LA CABEZA void crear() { clrscr(); cab=nuevo_elemento(); gotoxy(20,20); cout >cab->dato; cab->siguiente=NULL; getch(); }

 MENU DE INSERTAR void insertar() { clrscr(); char opc=’ ‘; do { clrscr(); cuadro(1,10,35,56,’²’); gotoxy(13,3);cout [ LISTAS ENLAZADAS ]<-\n”; gotoxy(12,6);cout<<” MENU PRINCIPAL\n”; gotoxy(12,9); cout<<” [1]: INSERTAR AL INICIO\n”; gotoxy(12,12);cout<<” [2]: insertar AL FINAL\n”; gotoxy(12,15);cout<<” [3]: INSERTAR ORDENADO\n”; gotoxy(12,18);cout<<” [4]: REGRESAR\n”; gotoxy(12,21);cout >opc;

switch(opc) { case’1′: clrscr(); insertar_inicio();getch();break; case’2′: clrscr(); insertar_final();getch();break; case’3′: clrscr(); insertar_ordenado();getch();break; } }while(opc!=’4′); getch(); }

 INSERATAR AL INICIO void insertar_inicio() { clrscr(); nodo *pAuxElem; nodo *recorre; pAuxElem=(tipoNodo*) malloc(sizeof(tipoNodo)); while(recorre->siguiente!=NULL) { recorre=recorre->siguiente; } int n; gotoxy(20,20); cout >n; pAuxElem->dato=n; pAuxElem->siguiente=cab; cab=pAuxElem; }

 INSERTAR AL FINAL void insertar_final() { clrscr(); nodo *elem; elem=nuevo_elemento(); clrscr(); gotoxy(20,20); cout >elem->dato; nodo *recorrer; recorrer=cab; while(recorrer->siguiente!=NULL) recorrer=recorrer->siguiente; recorrer->siguiente=elem; elem->siguiente=NULL; getch(); }

 INSERTAR ORDENADO void insertar_ordenado() { clrscr(); nodo *pAuxElem; nodo *post; nodo *recorre; pAuxElem=(tipoNodo*) malloc(sizeof(tipoNodo)); post=(tipoNodo*) malloc(sizeof(tipoNodo)); int n; gotoxy(20,20); cout >n; if(n dato) { post=cab->siguiente; while((pAuxElem->dato>post->dato)&&(post- >siguiente!=NULL)) { post=post->siguiente; }

if(post->siguiente!=NULL) { pAuxElem->siguiente=cab; cab=pAuxElem; } else { pAuxElem->siguiente=NULL; post->siguiente=pAuxElem; } } else { while(recorre->siguiente!=NULL) { recorre=recorre->siguiente; } pAuxElem->dato=n; pAuxElem->siguiente=cab; cab=pAuxElem; }

 PARA MODIFICAR void modificar() { clrscr(); nodo *elem; nodo *ele; gotoxy(10,25);cout >elem->dato; nodo *recorrer; recorrer=cab;

while(recorrer!=NULL) { if(recorrer->dato==elem->dato) { clrscr(); gotoxy(20,20); cout >ele->dato; recorrer->dato=ele->dato; } recorrer=recorrer->siguiente; } getch(); }  PARA BUSCAR void buscar() { clrscr(); nodo *elem;

gotoxy(10,25);cout >elem->dato; nodo *recorrer; recorrer=cab; while(recorrer!=NULL){ if(recorrer->dato==elem->dato){ clrscr(); gotoxy(20,20); cout dato dato=elem->dato; } recorrer=recorrer->siguiente; } getch(); }

 ORDENAR void ordenar() { clrscr(); char opc=’ ‘; do { clrscr(); cuadro(1,10,25,56,’²’); gotoxy(13,3);cout [ ORDENAR LAS LISTAS ENLAZADAS ]<-\n”; gotoxy(12,6);cout<<” MENU PRINCIPAL\n”; gotoxy(12,9); cout<<” [1]: ORDENAR ASCENDENTE\n”; gotoxy(12,12);cout<<” [2]: ORDENAR DESCENDENTE\n”; gotoxy(12,15);cout<<” [3]: REGRESAR\n”; gotoxy(12,17);cout >opc;

switch(opc){ case’1′: clrscr(); ordenar_ascendente();getch();break; case’2′: clrscr(); ordenar_descendente();getch();break; } } while(opc!=’3′); getch(); } void ordenar_ascendente(){ nodo* aux; nodo* temp; int vaux; aux=(tipoNodo *)malloc(sizeof(tipoNodo)); temp=(tipoNodo *)malloc(sizeof(tipoNodo)); aux=cab;

while (aux!=NULL){ temp=aux; while(temp->siguiente!=NULL){ temp=temp->siguiente; if(aux->dato>temp->dato){ vaux=aux->dato; aux->dato=temp->dato; temp->dato=vaux; } } aux=aux->siguiente; } } void ordenar_descendente(){ nodo* aux; nodo* temp; int vaux; aux=(tipoNodo *)malloc(sizeof(tipoNodo)); temp=(tipoNodo *)malloc(sizeof(tipoNodo)); aux=cab;

while (aux!=NULL) { temp=aux; while(temp->siguiente!=NULL) { temp=temp->siguiente; if(aux->dato dato) { vaux=aux->dato; aux->dato=temp->dato; temp->dato=vaux; } } aux=aux->siguiente; } }

 ELIMINAR void eliminar() { presentar(); nodo *eliminar; // nodo *recorrer; nodo *asigna; gotoxy(10,25);cout >eliminar->dato;

// recorrer=cab; if (eliminar->dato==cab->dato){ eliminar_cabeza(); }else{ nodo *anterior=cab; nodo * aux=cab->siguiente; while((aux!=NULL)&&(aux->dato!=eliminar->dato)){ anterior=aux; aux=aux->siguiente; } if(aux!=NULL){ anterior->siguiente=aux->siguiente; aux->siguiente=NULL; free(aux); }else{ gotoxy(10,33); cout<<“NO SE ENCUENTRA”; } } }

 ELIMINAR CABEZA void eliminar_cabeza(){ nodo *aux; aux=cab; cab=cab->siguiente; aux->siguiente=NULL; free(aux); }  PRESENTAR LA LISTA void presentar(){ clrscr(); int f=10; nodo *recorrer; recorrer=cab; gotoxy(20,f); while(recorrer!=NULL){ gotoxy(20,f); cout dato; cout<<“\n\n”;

recorrer=recorrer->siguiente; f=f+2; } getch();}  PRESENTAR LOS BORDES DE UN CUADRO void cuadro(int x1,int y1, int x2, int y2, char simb) { for (int i1=y1;i1<=y2;i1++) { gotoxy(i1,x1);cout<<simb; gotoxy(i1,x2);cout<<simb; } for (int i2=x1;i2<=x2;i2++) { gotoxy(y1,i2);cout<<simb; gotoxy(y2,i2);cout<<simb; } }