¿Cuáles son los diversos métodos para implementar una pila utilizando la (s) lista (s) vinculada (s) y qué método es el mejor?

A2A

Creo que implementar una pila usando Singly Linked List es un enfoque mejor y más fácil. Suponiendo que está implementando una pila de enteros.

El encabezado de la lista vinculada se trataría como stack top .

Push : esta operación es una inserción clásica en la primera operación en la lista vinculada.
Pop : esta operación es una operación clásica de eliminación del primer nodo en la lista vinculada.

A continuación se muestra la implementación de Java:

clase LLNode {
datos int;
LLNode siguiente;

LLNode público (datos int) {
this.data = datos;
}
}

pila de clase {
top privado de LLNode;

public boolean isEmpty () {
if (top == null) {
volver verdadero;
}
falso retorno;
}

public void push (datos int) {
// Crear un nodo
Nodo LLNode = nuevo LLNode (datos);

// Insertar este nuevo nodo al inicio
if (top == null) {
top = nodo;
} más {
node.next = top;
top = nodo;
}
}

public int pop () {
if (isEmpty ()) {
// Puede devolver algún valor no válido, lanzar excepción.
return Integer.MIN_VALUE;
}
int data = top.data;
// Eliminar nodo de puño
top = top.next;
devolver datos;
}
}

Disculpe los errores tipográficos / sintácticos en el código. Espero que esto ayude. Avíseme si tiene alguna pregunta, sugerencia o algún error.

Creo que es relativamente estrecho.
A menos que haya algún caso especial, elegiría una lista vinculada conectada individualmente .

[] -> [] -> [] -> x
^
Head Pointer / Start

1. Debe tener un puntero en la cabeza y una cola.
2. Cuando la cabeza apunta a nulo, la pila está vacía.
3. Puede mantener un límite superior definido para verificar que la pila esté llena:
#define MAXSIZE 1000
Mantenga un contador para realizar un seguimiento del tamaño de la pila actual.
4. Push () debería crear un nuevo nodo al ‘inicio’ cada vez y asignarle el valor (que se va a empujar).
5. Pop () debería devolver el valor del puntero de inicio / encabezado, mover el puntero de encabezado al siguiente nodo y eliminar el nodo anterior.

No veo ninguna razón por la que debería usar dos listas vinculadas?

Como stack es un ADT que es el primero en entrar, el último en salir, por lo que se puede implementar fácilmente usando una sola lista vinculada. Requiere dos funciones, Push () para colocar datos en la pila como la pila de platos, y una función Pop () para eliminar los datos uno por uno.

Solo haz una estructura:

nodo de estructura {
datos int;
nodo * siguiente;
}

Con esto, crea un nodo de la pila y coloca NULL en el “siguiente” del primer nodo. Un puntero debe apuntar al final del nodo. Cada vez que llame a Push (), cree un nuevo nodo, apunte ese puntero al nuevo nodo y asigne un valor a la variable “datos”. Siempre que llame a Pop (), elimine el último nodo y haga que el puntero apunte al nodo anterior.

La pila es una estructura de datos abstracta mágica. Incluso se puede implementar en lenguaje ensamblador con relativa facilidad.
¿Cómo funciona la pila en lenguaje ensamblador?

Considere leer este artículo en Wikipedia Stack (tipo de datos abstractos), contiene todas las implementaciones y se explica por sí mismo.

No usaría una lista vinculada. Las pilas se implementan mucho más fácilmente usando una matriz. O, si eres valiente, un área de memoria con un puntero. Una lista vinculada causará enormes cantidades de sobrecarga innecesaria y, a menos que tenga una buena razón por la que necesita hacer esto, una matriz será mucho más adecuada.

Empuje agregando al encabezado de la lista, y pop tomando el encabezado de la lista y convirtiendo a su sucesor en el nuevo encabezado.