INGENIERIA DE SISTEMAS 1 ESTRUCTURAS DE DATOS (Listas simples)

INTRODUCCIÓN A LAS ESTRUCTURAS DE DATOS

1. INTRODUCCIÓN

Las computadoras fueron diseñadas o ideadas como una herramienta mediante la cual podemos realizar
operaciones de cálculo complicadas en un lapso de mínimo tiempo. Pero, la mayoría de las aplicaciones de
este fantástico invento del hombre, son las de almacenamiento y acceso de grandes cantidades de
información.

La información que se procesa en la computadora es un conjunto de datos, que pueden ser simples o
estructurados. Los datos simples son aquellos que ocupan sólo una localidad de memoria, mientras que los
estructurados son un conjunto de casillas de memoria a las cuales hacemos referencia mediante un
identificador único.

Debido a que por lo general tenemos que tratar con conjuntos de datos y no con datos simples (enteros,
reales, booleanos, etc.) que por sí solos no nos dicen nada, ni nos sirven de mucho, es necesario tratar con
estructuras de datos adecuadas a cada necesidad.

2. CONCEPTO

Una estructura de datos es una colección de datos organizados de un modo particular, las estructuras de datos
pueden ser de dos tipos: estructuras de datos estáticas y estructuras de datos dinámicas. Las estructuras de
datos estáticas son aquellas en las que el espacio en memoria se define en tiempo de compilación y no
pueden ser modificados durante la ejecución del programa, corresponden a este tipo los arrays (vectores y
matrices). Las estructuras de datos dinámicas son aquellas en las que el espacio ocupado en memoria puede
ser modificada en tiempo de ejecución, corresponden a este tipo: las listas, árboles y grafos.

3. TIPOS DE DATOS PRIMITIVOS (SIMPLES)

Son aquellos que ya están definidos por los lenguajes de programación, donde solo utilizan una localidad de
memoria, entre ellos se encuentran:

- char
- boolean
- byte
- short
- int
- long
- float
- doublé

4. ESTRUCTURAS DE DATOS

TAD (Tipo de Dato Abstracto)

Los TAD son definidos por el programador

TAD = datos + Operaciones (funciones)
INGENIERIA DE SISTEMAS 2 ESTRUCTURAS DE DATOS (Listas simples)

5. LISTAS

La lista es un TAD, que consta de una secuencia de elementos llamados nodos.

Nodo

- Datos (Información)
- Enlace o apuntador (Apunta al siguiente nodo)

Info Enlace

Nodos enlazados

Los nodos forman una secuencia desde el primer elemento al último elemento. El primer nodo se enlaza al
segundo, éste se enlaza al tercero y así sucesivamente hasta llegar al último nodo, que debe ser representado
de forma diferente para especificar que este nodo no se enlaza a ningún otro.

6. PILA

Una pila es TAD de tipo de lista LIFO (el último en entrar es el primero en salir), tal como una pila de platos.

Operaciones sobre la pila:

- Meter (push)
- Sacar (pop)
- Es vacía

7. COLA

Una cola es TAD de tipo de lista FIFO (el primero en entrar es el primero en salir), tal como la fila de un
banco.

Operaciones sobre la cola:

- Insertar
- Remover
- Es vacia
INGENIERIA DE SISTEMAS 3 ESTRUCTURAS DE DATOS (Listas simples)

LISTAS ENLAZADAS SIMPLES

1. INTRODUCCIÓN

Las listas enlazadas son una secuencia de nodos que se encuentran enlazados uno con el siguiente mediante
un enlace. Cada elemento (nodo) de una lista enlazada debe tener dos campos: un campo (info) que contiene
el valor de ese elemento y un campo (enlace) que indica la posición del siguiente elemento.

Aunque se pueden crear muchos tipos de listas enlazadas, las tres variantes más populares son la lista de
enlace simple, la lista doblemente enlazada y la lista enlazada circular.

2. LISTA DE ENLACE SIMPLE.

Una lista de enlace simple es una lista enlazada de nodos, donde cada nodo tiene un único campo de enlace.
Una variable de referencia contiene una referencia al primer nodo, cada nodo (excepto el último) enlaza con
el nodo siguiente, y el enlace del último nodo contiene null para indicar el final de la lista.

En java para realizar listas enlazadas se utilizan clases autoreferenciadas.

Una clase autoreferenciada es una clase con al menos un campo cuyo tipo de referencia es el nombre de la
clase.

Las operaciones básicas sobre una lista simple son:

- Insertar nodo
- Eliminar nodo
- Buscar nodo
- Mostrar lista
- Eliminar lista

3. NODO

JAVA
Nodo class Nodo {
info enlace int info;
int info Nodo enlace;
Nodo enlace }
INGENIERIA DE SISTEMAS 4 ESTRUCTURAS DE DATOS (Listas simples)

4. LISTA ENLAZADA SIMPLE

cab
4 7 8 0 NULL

Lista JAVA

Nodo cab class Lista {

Nodo cab; //declaración del nodo
insertarNodo void InsertarNodo(int n) //inserción por delante
eliminarNodo {
buscarNodo if(cab==null) //entra la primera vez
mostrarLista {
eliminarLista cab=new Nodo(); //crea el nodo cab
cab.info=n;
cab.enlace=null; //su primer enlace apunta a null
}
else
{
Nodo temp=new Nodo(); //nodo temporal
temp.info=n;
temp.enlace=cab;
cab=temp;
}
}
void mostrarLista()
{
Nodo temp=cab;
while(temp!=null) //recorre hasta llegar a null
{
System.out.print(temp.info);
temp=temp.enlace;
}
}
}

Para probar la lista necesitamos una clase de prueba donde tenga la función main, como se muestra a
continuación
class Prueba {
public static void main(String[] args) {
Lista A=new Lista();
A.InsertarNodo(2);
A.InsertarNodo(3);
A.InsertarNodo(4);
A.mostrarLista();
}
}
En el IDE Eclipse debería crear 3 clases como se muestra a continuación
INGENIERIA DE SISTEMAS 5 ESTRUCTURAS DE DATOS (Listas simples)

Ejercicios.

Inserción al último

El método de inserción del ejemplo es la inserción por delante (al principio), ahora realizaremos el método de
inserción por detrás (al último).

void insertarUltimo(int a)
{
if(cab==null)
{
cab=new Nodo();
cab.info=a;
cab.enlace=null;
}
else
{
Nodo aux=cab;
Nodo temp=new Nodo();
temp.info=a;
temp.enlace=null;
while(aux.enlace!=null)
{
aux=aux.enlace;
}
aux.enlace=temp;
}
}
INGENIERIA DE SISTEMAS 6 ESTRUCTURAS DE DATOS (Listas simples)

MÁS EJERCICIOS CON LISTAS ENLAZADAS SIMPLES

Programa que permite insertar N datos en una lista enlazada (los datos son insertados ordenadamente
mediante una función insertarOrdenado())

class Nodo {
int info;
Nodo enlace;
public Nodo(int a){ //Constructor que recibe como parámetro un número
info=a;
}
}

public class Lista {

Nodo cab;
void mostrar() {
Nodo aux=cab;
while(aux!=null){
System.out.print(aux.info+" ");
aux=aux.enlace;
}
}
void insertarOrdenado(int a){
if(cab==null){
cab=new Nodo(a);
cab.enlace=null;
}
else{
Nodo temp=new Nodo(a);

if(a<cab.info){
temp.enlace=cab;
cab=temp;
}
else{
Nodo aux=cab;
while(aux.enlace!=null && a>aux.enlace.info)
aux=aux.enlace;

temp.enlace=aux.enlace;
aux.enlace=temp;
}
}
}
}
INGENIERIA DE SISTEMAS 7 ESTRUCTURAS DE DATOS (Listas simples)

import java.util.*;
public class Prueba {
public static void main(String[] args) {
Scanner en=new Scanner(System.in);
Lista l=new Lista();
System.out.print("inserte cantidad de datos: ");
int cant=en.nextInt();
int num;
for(int i=0;i<cant;i++)
{
System.out.print("inserte un dato: ");
num=en.nextInt();
l.insertarOrdenado(num);
}
l.mostrar();
}
}

Podemos modificar la clase Prueba para que los números insertados en la lista sean generados aleatoriamente
Estos números deben estar entre 10 y 20, la cantidad de números será introducido por teclado.

import java.util.*;
public class Prueba {
public static void main(String[] args) {
Scanner en=new Scanner(System.in);
Lista l=new Lista();
System.out.print("inserte cantidad de datos: ");
int cant=en.nextInt();
int num;
for(int i=0;i<cant;i++)
{
num=10+(int)(Math.random()*11); //numero aleatorio
l.insertarOrdenado(num);
}
l.mostrar();
}
}

Función que devuelve la suma de los datos de la lista

int sumarDatos()

int sumarDatos(){
int s=0;
Nodo temp=cab;
while(temp!=null){
s=s+temp.info;
temp=temp.enlace;
}
return s;
}
INGENIERIA DE SISTEMAS 8 ESTRUCTURAS DE DATOS (Listas simples)

Función que muestre los datos primos de la lista (función para la clase Lista)
void mostrarPrimos()

boolean primo(int a){

int c=0;
for(int i=1;i<=a;i++)
if(a%i==0)
c++;
if(c<=2)
return true;
return false;
}

void mostrarPrimos(){
Nodo aux=cab;
while(aux!=null){
if(primo(aux.info))
System.out.print(aux.info+" ");
aux=aux.enlace;
}
}

Función que recibe como parámetro una lista (un nodo) a la cual se enlazará la lista.

void enlazar(Nodo A)
{
Nodo temp=cab;
while(temp.enlace!=null)
temp=temp.enlace;
temp.enlace=A;
}