Listas

En Ciencias de la Computación, una lista enlazada es una de las estructuras de

datos fundamentales, y puede ser usada para implementar otras estructuras de datos. Consiste

en una secuencia de nodos, en los que se guardan campos de datos arbitrarios y una o

dos referencias(punteros) al nodo anterior y/o posterior. El principal beneficio de las listas

enlazadas respecto a los array convencionales es que el orden de los elementos enlazados

puede ser diferente al orden de almacenamiento en la memoria o el disco, permitiendo que el

orden de recorrido de la lista sea diferente al de almacenamiento.

Una lista enlazada es un tipo de dato auto-referenciado porque contienen un puntero o link a

otro dato del mismo tipo. Las listas enlazadas permiten inserciones y eliminación de nodos en

cualquier punto de la lista en tiempo constante (suponiendo que dicho punto está previamente

identificado o localizado), pero no permiten un acceso aleatorio. Existen diferentes tipos de

listas enlazadas: Lista Enlazadas Simples, Listas Doblemente Enlazadas, Listas Enlazadas

Circulares y Listas Enlazadas Doblemente Circulares.

Las listas enlazadas pueden ser implementadas en muchos lenguajes. Lenguajes tales

como Lisp y Scheme tiene estructuras de datos ya construidas, junto con operaciones para

acceder a las listas enlazadas. Lenguajes imperativos u orientados a objetos tales

como C o C++ yJava, respectivamente, disponen de referencias para crear listas enlazadas.

Tipos de Listas Enlazadas

Listas enlazadas lineales

Listas simples enlazadas

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.

Una lista enlazada simple contiene dos valores: el valor actual del nodo y un enlace al siguiente nodo

Lista Doblemente Enlazada

Un tipo de lista enlazada más sofisticado es la lista doblemente enlazada o lista enlazadas

de dos vías. Cada nodo tiene dos enlaces: uno apunta al nodo anterior, o apunta al

valor NULL si es el primer nodo; y otro que apunta al nodo siguiente, o apunta al valor NULL si

es el último nodo.

Una lista doblemente enlazada contiene tres valores: el valor, el link al nodo siguiente, y el link al anterior

En algún lenguaje de muy bajo nivel, XOR-Linking ofrece una vía para implementar listas

doblemente enlazadas, usando una sola palabra para ambos enlaces, aunque el uso de esta

técnica no se suele utilizar.

Listas enlazadas circulares

En una lista enlazada circular, el primer y el último nodo están unidos juntos. Esto se puede

hacer tanto para listas enlazadas simples como para las doblemente enlazadas. Para recorrer

una lista enlazada circular podemos empezar por cualquier nodo y seguir la lista en cualquier

dirección hasta que se regrese hasta el nodo original. Desde otro punto de vista, las listas

enlazadas circulares pueden ser vistas como listas sin comienzo ni fin. Este tipo de listas es el

más usado para dirigir buffers para “ingerir” datos, y para visitar todos los nodos de una lista a

partir de uno dado.

Una lista enlazada circular que contiene tres valores enteros

Listas enlazadas circulares simples

Cada nodo tiene un enlace, similar al de las listas enlazadas simples, excepto que el

siguiente nodo del último apunta al primero. Como en una lista enlazada simple, los nuevos

nodos pueden ser solo eficientemente insertados después de uno que ya tengamos

referenciado. Por esta razón, es usual quedarse con una referencia solamente al último

elemento en una lista enlazada circular simple, esto nos permite rápidas inserciones al

principio, y también permite accesos al primer nodo desde el puntero del último nodo. 1

Lista Enlazada Doblemente Circular

En una lista enlazada doblemente circular, cada nodo tiene dos enlaces, similares a los de la

lista doblemente enlazada, excepto que el enlace anterior del primer nodo apunta al último y el

enlace siguiente del último nodo, apunta al primero. Como en una lista doblemente enlazada,

las inserciones y eliminaciones pueden ser hechas desde cualquier punto con acceso a algún

nodo cercano. Aunque estructuralmente una lista circular doblemente enlazada no tiene ni

principio ni fin, un puntero de acceso externo puede establecer el nodo apuntado que está en la

cabeza o al nodo cola, y así mantener el orden tan bien como en una lista doblemente

enlazada.

Nodos Centinelas

A veces las listas enlazadas tienen un nodo centinela (también llamado falso nodo o nodo

ficticio) al principio y/o al final de la lista, el cual no es usado para guardar datos. Su propósito

es simplificar o agilizar algunas operaciones, asegurando que cualquier nodo tiene otro anterior

o posterior, y que toda la lista (incluso alguna que no contenga datos) siempre tenga un “primer

y último” nodo.

La clase LinkedNode en C#. Interfaz Ilist

Las listas (List) en C# son colecciones de datos mucho más potentes y funcionales que los

arrays, por lo que su uso es muy común en el desarrollo de aplicaciones. Y es que con las

listas (List) todo se hace mucho más sencillo. Ahorramos código y disponemos de los métodos

que siempre soñamos tener en la clase Array.

En este tutorial veremos como crear nuestra propia lista de elementos usando nodos

enlazables, así como programar los métodos Add, Insert, Remove, IndexOf, Contains, Clear y

otras funciones disponibles en la Interfaz IList.

¿Qué es un nodo enlazable?

Un nodo enlazable es una clase que tiene principalmente un valor de tipo object y un enlace

hacia el nodo siguiente.

¿Para que sirve?

Los nodos enlazables pueden ser utilizados para almacenar los elementos de la lista que

queremos crear. De igual manera podríamos usar un array, pero además de ser mucho más

costoso, a mí me gustan más los nodos enlazables.

Por tanto esta sería la clase Nodo:

Ahora que ya tenemos nuestra clase Nodo, crearemos nuestra lista. Una clase a la que

llamaremos ListaEnlazable. Como todas, las listas van a tener las mismas funcionalidades, las

que heredaremos de una interfaz llamada IList.

Para quienes no lo saben, una interfaz es una especie de plantilla, con un conjunto de

métodos y propiedades definidas pero no programadas y que las podemos usar en clases y

estructuras.

Para usar la interfaz Ilist creamos la clase ListaEnlazable y heredamos de la interfaz Ilist que

viene por defecto con el Visual Studio. Luego hacemos clic derecho sobre Ilist y

seleccionamos Implementar Interfaz (Implement interface):

Pues bien, ahora vamos a crear las variables necesarias para programar cada uno de los

métodos de la interfaz Ilist.

Necesitaremos dos Nodos: primero y último, para poder recorrer la lista, y empezar desde

algún lugar. Además podríamos necesitar un contador, que permita saber la cantidad de

elementos que hay en un momento dado. Y el constructor por defecto lo único que haría es

inicializar las variables, para crear una nueva ListaEnlazable vacía. De esta forma, tendríamos

algo como lo siguiente:

public void Add(object x)

La función de este método es añadir un elemento al final de la lista. Veamos la

implementación de Add:

Como ven, es muy sencillo, solo hay que crear un nuevo nodo, enlazar el último con este

nuevo nodo y luego poner este nodo como último.

public void Insert(int index, object x)

Añade un elemento a la lista, pero a diferencia de Add(object x), este lo inserta en una

posición dada.

Como ven, hay que recorrer la lista hasta encontrar la posición donde queremos insertar el

elemento.

public int IndexOf(object x)

Devuelve la posición de un elemento de la lista.

Al final, si este método no encuentra el elemento x en la lista, retorna -1, veamos como usar

esto en el siguiente método.

public bool Contains(object x)

Este método nos dice si un elemento está o no en la lista. Devuelve true en caso de que la

lista contenga al elemento x y false en caso contrario.

La operación es muy simple, pues usamos IndexOf(x) que ya está implementado en esta clase.

public void Remove(object x)

Método para quitar el elemento x de la lista. Simplemente busca el elemento en la lista y

actualiza la propiedad siguiente saltándose el nodo cuyo valor es x.

Nos quedan dos métodos que deberás implementar tú mismo, usando los algoritmos que ya

hemos visto en la clase ListaEnlazable:

public void RemoveAt(int index)

Elimina de la lista el elemento que está en la posición index.

Public void Clear()

Clear no recibe ningún parámetro y su función es reiniciar la lista, o sea vaciarla. Fíjense en

el constructor.

Public object this [int index]

Por último, veamos cómo programar el indexer, una especie de propiedad que permite

seleccionar el elemento de la lista especificando una posición, como hacemos con el array,

por ejemplo:

No se asusten porque el código es un poco largo, fíjense que es casi lo mismo en el get y en el

set, la diferencia está en que get es para leer el elemento, y set para cambiarlo.

http://www.puntopeek.com/wp-content/uploads/2009/03/img101.png

Creando Listas de objetos en C# - List y ArrayList

Que son las colecciones de clases en C#? La colecciones de clases de C# son un conjunto de

clases diseñadas específicamente para agrupar objetos y llevar a cabo tareas con ellos.

Tanto la list<T> ArrayList y las clases tienen propiedades muy similares a los arrays de C# (para

más detalles sobre estos busquen informacion sobre matrices en C#). Una ventaja fundamental de

estas clases sobre los arrays es que puedan crecer y reducir el número de objetos almacenados.

La list<T> clase en contenida en System.Collections.Generic, mientras que la clase ArrayList

figura en el System.Collections.

La sintaxis para crear una colección list<T> es la siguiente:

List<type> nombre = new List<type>();

ArrayList es un objeto creado de una manera similar, aunque sin el argumento de tipo:

ArrayList nombre = new ArrayList ();

Con esta sintaxis ahora podemos crear una list<T> denominada colorlist:

using System;

using System.Collections.Generic;

public class Lists

{

static void Main()

{

List<string> colorList = new List<string>();

}

}

Añadir artículos a las listas

Una vez que una lista se ha creado hay una serie de métodos que pueden ser llamados a realizar

tareas en la lista. Una vez que ese método es el método Add() que, como su nombre indica, se

utiliza para añadir elementos a la lista de objetos:

List<string> colorList = new List<string>();

colorList.Add ("Red");

colorList.Add ("Green");

colorList.Add ("Yellow");

colorList.Add ("Purple");

colorList.Add ("Orange");

Acceso a los elementos

Los elementos individuales en una lista se puede acceder mediante el índice de valor de la partida

(teniendo en cuenta que el primer punto del índice es 0, el segundo índice 1 y así sucesivamente).

El valor del índice se encuentra entre corchetes tras el nombre de la lista. Por ejemplo, para

acceder al segundo punto de el objeto colorlist:

Console.WriteLine (colorList[1]);

Un elemento de la lista el valor puede ser cambiado de manera similar usando el índice combinado

con el operador de asignación. Por ejemplo, para cambiar el color de amarillo a verde:

colorList[2] = "Verde";

Todos los elementos de una lista se puede acceder mediante un bucle foreach. Por ejemplo:

foreach (string color in colorList)

{

Console.WriteLine ( color );

}

Cuando compilado y ejecutado, el código de salida anterior mostrara todos los colores.

Inserción de artículos en una lista

Anteriormente se utilizó el método Add() para añadir elementos a una lista. El método Add(), sin

embargo, sólo añade elementos al final de una lista. A veces es necesario añadir un nuevo tema

en una ubicación específica en una lista. Insert() es el método para este fin específico. Insert()

recibe dos argumentos, un entero que indica el índice de localización de la inserción y el tema que

se incluirá en ese lugar. Por ejemplo, para insertar un elemento en la posición 2 en nuestro

ejemplo la lista:

ColorList.Insert(2, "Blanco");

Ordenando Listas

No hay manera de decirle a C# que ordene automáticamente una lista de artículos despues de

añadir. Si los elementos de una lista deben estar siempre ordenados se debe llamar al metodo

Sort una vez se añaden nuevos elementos:

colorList.Sort ();

Búsqueda de elementos en una lista

Se proveen un buen número de métodos con las listas y la ArrayList clase. El método más básico

es el Contains(), en el cual cuando se pide a un objeto ArrayList o List devuelve true si el tema se

encuentra en la lista, o falso si no se encuentra.

El IndexOf() devuelve el valor de un índice de un elemento de la lista. Por ejemplo, el código

siguiente muestra el valor de salida de 2, que es el índice de la posición de "Amarillo" en la

cadena:

List<string> colorList = new List<string>();

colorList.Add ("Red");

colorList.Add ("Green");

colorList.Add ("Yellow");

colorList.Add ("Purple");

colorList.Add ("Orange");

Console.WriteLine(colorList.IndexOf("Yellow"));

Si el elemento no se encuentra en la lista devuelve -1.

Esta técnica podría utilizarse para reemplazar un valor con otro. Por ejemplo, sin conocer de

antemano el valor del índice del "Amarillo" cadena podemos cambiar a "Negro":

colorList[colorList.IndexOf("Yellow")] = "Black";

El LastIndexOf() método devuelve el valor del índice del último elemento de la lista para que

coincida con el punto especificado. Esto es particularmente útil cuando la lista contiene elementos

duplicados.

Obtener informacion de una lista

Hay dos miembros de la clase que son útiles para obtener información acerca de una lista de C #

o colección de objetos ArrayList. La propiedad Capacity puede ser utilizada para identificar el

número de artículos que puede almacenar una colección sin tener que cambiar el tamaño.

El propiedad Count, por otra parte, identifica cuantos artículos se encuentran actualmente

almacenados en la lista. Por razones obvias, Capacity sera siempre superior a Count.

En los casos en que existe una gran diferencia entre el Count y Capacity los elementos pueden ser

borrados con el método TrimExcess().

Borrado de elementos

Todos los elementos de una lista podrán ser borrados mediante el método Clear():

colorList.Clear();

Clear() elimina los elementos de la lista y establece la propiedad Count a cero. La propiedad

Capacity, sin embargo, sigue siendo la misma. Para eliminar la Capacity despues de el método

Clear() hay que llamar a TrimExcess().