Hola. Primero que todo os pido disculpas sé que no es el objetivo hacer tareas ni nada parecido. Y, no es lo que pido.
Pido sencillamente que me ayuden en caso tal, tengas uds. algún código fuente de un programa que utilice las operaciones básicas en una lista enlazada. o que me puedan dar algun enlace o algo, cualquier información es bienvenida.

• creación


• recorrido


• inserción


• borrado


• búsqueda

He encontrado teoría, pero no un programa documentado o del todo entendible; ya que no sé mucho del tema y mis conocimientos son un poco bajos.
Reitero mis disculpas y os agradezco por cualquier ayuda que me puedan brindar.
Saludos y muchas gracias.

Pregunta tontísima...

Las listas enlazadas van con punteros, ¿no?

Lo digo porque poner un ejemplo de lista LILO, FIFO, LIFO o FILO es super chungo (por lo menos para mí).

Si quieres poner un ejemplo, será mejor que pongas ejemplos tontos en plan "cola del carrito de helados, pila de platos, almacén de maletines o outlet store" y te inventes un pseudocódigo que luego puedas pasar a c.

Te lo digo porque en TP me lo aprendí así.

Un saludo

"Pregunta tontísima..." Si, a lo mejor si sea una pregunta tonta; para los que manejan bien el tema de listas enlazadas. Pero, pregunto es porque no sé; vale.

"Las listas enlazadas van con punteros, ¿no?" ---> Si.

Definición: 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.

"Lo digo porque poner un ejemplo de lista LILO, FIFO, LIFO o FILO es super chungo (por lo menos para mí)."

No manejo bien todas las estructuras de datos... Hasta donde sabia, LILO, FIFO, LIFO, FILO, se manejan en estructuras de datos llamadas pilas.
En lo que he leido sobre listas enlazadas, no había visto nada acerca de que estos términos se usaran en las listas enlazadas.


"Si quieres poner un ejemplo, será mejor que pongas ejemplos tontos en plan "cola del carrito de helados, pila de platos, almacén de maletines o outlet store" y te inventes un pseudocódigo que luego puedas pasar a c."


Disculpa, pero como dije en el post anterior no sé como aplicarlo. Por eso, os preguntaba si me podrían ayudar, brindando un código o enlace alguna pagina que explicara el uso de este tipo de estructura o con cualquier otro tipo de ayuda.

"Te lo digo porque en TP me lo aprendí así." Si De repente, en turbo pascal, sea como dices; debido que la mayoría de lenguajes disponen de referencias para crear listas enlazadas.

De todas formas, gracias por tu comentario.

Mandrake... creo que no me has entendido...

lo de "pregunta tontísima" era la que yo te hacía a tí (de si iba con punteros o no), no la que tú hacías. La tuya me parecía interesante (sólo que yo no sabía si interpretarla como punteros).

Te pido disculpas por el malentendido.

Ahí va lo que (creo) pides.

Las listas enlazadas tienen todas un principio y un final (primer y último elemento). Hasta aquí, todos lo entendemos.

En C, si mal no recuerdo un puntero se crea con "*". Vamos a ejemplificar por ejemplo, una lista enlazada LILO (Last In, Last Out, es decir, el primero que entra es el primero que sale).

Imaginate la cola de la compra, un banco, el carrito de los helados mencionados... los elementos son los "clientes".

Supongamos que el banco, etc... está vacío.

Hasta aquí, espero ser clara, porque ahora llega la parte que no sé si sé explicar con total claridad.

El cliente entra en el banco y ¡sorpresa! ¡es el primero!. Por tanto, nosotros creamos un puntero, llamado P_Clie, cuya dirección sea:

P_Clie = &cliente (es decir, el puntero P_Clie apunta a donde está el cliente).

En este momento, el cliente es el principio y el final de la lista enlazada (¿se ve bien?), por tanto es su cabecera (primer elemento) y final (último elemento).

En otras palabras, existen 2 punteros que apuntan a este cliente.


De pronto, entra otro cliente (queremos añadir un nodo a nuestra lista enlazada).

Para situarlo, crearemos un puntero auxiliar, llamado P_aux (por ejemplo) para éste nuevo cliente.

Aquí es donde nos liamos. Ten en cuenta esto

El primer elemento tiene un siguiente (que es el que acaba de entrar),por tanto necesitamos un puntero P_sig.

De la misma forma, para no dejarlo huérfano, el nuevo cliente tiene un cliente anterior a él que está siendo atendido, por tanto, tenemos un puntero P_ant.

P_ant apunta al ciente que está delante del que estamos manipulando. De la misma forma, nuestro cliente reciente es el siguiente cliente de la cola, por tanto a él le apuntará un puntero p_sig.

Eso es en una pila, como bien has dicho.

¿Qué ocurre si lo metemos en medio de una lista ya creada? (no es una pila propiamente, es una lista, por ejemplo, de objetos)

Exactamente lo que te he dicho, pero primero tienes que comprobar:

a.- si la lista está creada.
b.-si aunque esté creada, tiene elementos.
c.-si el elemento que queires meter se queda primero, último, o por el centro.

y ponerle sus punteritos correspondientes.

Siento si me explico como la mierda. Te puedo poner algún ejemplo bien escrito, el único problema es que el mejor libro que encontré cone ste tema es uno de TP, y no tengo ninguno de C/C++.

¿Si te paso el código en pseudocódigo, lo podrías traducir a C?

Siento este post tan largo y espero haberte ayudado en algo.

Un saludo

Pilar_PA

Lo siento, dupliqué post. Alguien puede borrar este?

Disculpame tu a mi; por no haberte pedido que aclararas tu comentario. Lo entendi mal; y en verdad lo siento mucho.
Comenzaré a trabajar en un codigo, y cuando lo tenga listo lo subiré a ver que opinas.
En verdad muchas gracias, y disculpame. Lamento que en nuestra primera conversa se haya creado este mal entendido.
Saludos.

Buenas,

Yo estudié las listas con ada y en otro idioma para más inri, por lo que quizá me líe con ciertos términos y tal, aún así creo que me explicaré. Las listas enlazadas son una sucesión de registros enlazados mediante punteros.

- Por ejemplo, en caso de querer guardar enteros cada registro de la lista podría ser:

Código Fuente:


struct Nodo
{
  int dato
  struct Nodo *siguienteNodo
}


- o también:

Código Fuente:


struct Nodo
{
  struct Nodo *nodoAnterior
  int dato
  struct Nodo *siguienteNodo
}



- La lista será un puntero a el primer componente.

Código Fuente:


struct Nodo *Lista;


- El primer componente se añadiría:

Código Fuente:


Lista = (struct nodo *) malloc(sizeof(struct Nodo));
Lista->dato = 1;
Lista->siguienteNodo=NULL;


- Para los siguientes componentes se necesitarán punteros adicionales:

Código Fuente:


struct Nodo *nuevo; // Será el puntero en el que crearemos el nuevo Nodo
struct Nodo *actual; // Guardará la dirección al último Nodo que hayamos procesado hasta el momento

actual = Lista; // Esto solo para el segundo componente, para el resto         
                        //actual = actual->siguienteNodo;

nuevo = (struct Nodo *) malloc(sizeof(struct Nodo));
nuevo->dato = 2;
nuevo->siguienteNodo=NULL;
actual->siguienteNodo=nuevo;
actual = actual->siguienteNodo;


nuevo = (struct Nodo *) malloc(sizeof(struct Nodo));
nuevo->dato = 3;
nuevo->siguienteNodo=NULL;
actual->siguienteNodo=nuevo;
actual = actual->siguienteNodo;



- Para imprimir la lista, hay que ir pasando por los diferentes punteros, hasta llegar al que sea NULL:

Código Fuente:


struct Nodo *actual;
struct Nodo *previo; // En este caso el puntero previo no es necesario, pero para insertar o borrar sí, por lo que lo pongo aquí también
actual = Lista;
previo = actual;
while (actual != NULL)
{
printf("%d
",actual->dato);
previo = actual;
actual = actual->siguienteNodo;
}



- Para añadir un nuevo componente, hay que diferenciar entre tres situaciones

- Al principio

Código Fuente:


struct Nodo *nuevo;

nuevo = (struct Nodo *) malloc(sizeof(struct Nodo));
nuevo->dato = n;
nuevo->siguienteNodo=Lista;

Lista = nuevo;



  - Entre medio
  Dependiendo de donde se pare la lista y donde se quiera agregar el nuevo nodo se hace de diferente manera.
  -Delante del nodo actual en el que hemos parado
 

Código Fuente:


struct Nodo *nuevo;

nuevo = (struct Nodo *) malloc(sizeof(struct Nodo));
nuevo->dato = n;
nuevo->siguienteNodo=actual;
previo->siguienteNodo=nuevo;



  -Detrás del nodo actual en el que hemos parado
   

Código Fuente:


struct Nodo *nuevo;

nuevo = (struct Nodo *) malloc(sizeof(struct Nodo));
nuevo->dato = n;
nuevo->siguienteNodo=actual->siguienteNodo;
actual->siguienteNodo=nuevo;



- Al final

Se pasaría la lista hasta el ultimo elemento de nuestra lista, y luego:

Código Fuente:


struct Nodo *nuevo;

nuevo = (struct Nodo *) malloc(sizeof(struct Nodo));
nuevo->dato = n;
nuevo->siguienteNodo=NULL;
previo->siguienteNodo=nuevo; // Se usa el puntero previo, puesto que en este momento actual tiene valor NULL





Para borrar es parecido.


-El primer componente

Código Fuente:


Lista = Lista->siguienteNodo;


-El ultimo componente
Se pasaría la lista hasta el ultimo elemento, y luego:

Código Fuente:


previo->siguienteNodo=NULL;


-Un componente entre medio

Código Fuente:


previo->siguienteNodo=actual->siguienteNodo;


Espero haberme explicado bien, y si alguien encuentra alguna metedura de pata - que la habrá- que avise .

Saludos

No pasa nada. Por eso siempre digo que me expreso  mal, porque no soy capaz de hacer que la gente me entienda DD.

Tranquilo, que todos tenemos esos días

Está bien complicado esto de las listas enlazadas, intenté entenderlo para ver si lo lograba, pero creo que no me queda muy claro .

me sale un error cuando intento introducir el primer dato,

por el momento mi codigo es:

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

struct Nodo
    {
    struct Nodo *nodoAnterior;
    int dato;
    struct Nodo *siguienteNodo;
    };

int main()
{


    struct Nodo *Lista;

    Lista = (struct nodo *) malloc(sizeof(struct Nodo ));
    Lista->dato = 1;
    Lista->siguienteNodo=NULL;

    return 0;
}


y me sale esto:
aviso: asignación desde un tipo de puntero incompatible
la linea del error es:

    Lista = (struct nodo *) malloc(sizeof(struct Nodo ));

Gracias de antemano, por cualquier ayuda.

Es porque en la linea del error pusiste "nodo" en lugar de "Nodo". Quedaría así:

Código Fuente:


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

struct Nodo
    {
    struct Nodo *nodoAnterior;
    int dato;
    struct Nodo *siguienteNodo;
    };

int main()
{
    struct Nodo *Lista;

    Lista = (struct Nodo *) malloc(sizeof(struct Nodo ));
    Lista->dato = 1;
    Lista->siguienteNodo=NULL;

    return 0;
}


Salu2