Implementación de lista, pila y cola simples doblemente enlazadas

Estos códigos se utilizan a menudo cuando usted mismo escribe informes de laboratorio. Por cierto, después de vomitarlo, podéis consultar las diferentes máquinas directamente aquí, y también podéis echarle un vistazo si lo necesitáis, espero tener alguna sugerencia. 

La lista vinculada usa la pila de estructuras y la clase utilizada por la cola. De hecho, no hay gran diferencia. Se puede usar. Cuando necesite cambiar el elemento, solo necesita cambiar el tipo de elemento almacenado en la lista vinculada. Si divides otras tareas, recuerda cambiar una plantilla de función y utilizarla.

código de lista enlazada

/* linknode.h */
typedef int linkelem;

typedef struct linknode{
    linkelem elem;
    /* 记得给一个合适的默认值 */
    linknode(linkelem e = 0,struct linknode* ne = 0,struct linknode* pr = 0);
    /* 前后指针 */
    struct linknode* next;
	struct linknode* prev;
    void add(linkelem e = 0);
}linknode,*link;


/* linknode.cpp */

#include <iostream>
#include "linknode.h"

using namespace std;

linknode::linknode(linkelem e,link ne,link pr){
	elem = e;
	next = ne;
	prev = pr;
}

void linknode::add(linkelem e){
    next = new linknode(e,0,this);
    if(!next){
        cout<<"error!"<<endl;
        return;
    }
}

Este código es ridículamente simple y no hay nada que explicar. Son múltiples constructores y una función de agregar. Es principalmente para la conveniencia de agregar y modificar la lista vinculada. Por supuesto, la eliminación de nodos aún debe implementarse por separado. No lo haré proporcione el código aquí. De hecho, se debe considerar la eliminación de nodos. Por ejemplo, si considera el problema de eliminar nodos en su cola, debe asegurarse de que la posición del puntero de cola de su cola sea legal. Si hay un problema con la eliminación, será problemático, pero es bastante simple decir que la implementación es bastante simple, pero le sugiero que si desea eliminar, debe implementar la operación de eliminación en la capa superior en lugar de en la capa inferior, porque a quién desea eliminar también es un problema. Debe encontrar el signo del nodo que desea eliminar, o puede especificar directamente una determinada dirección de nodo para eliminar esto.

código de cola

/* quene.h */
#include"linknode.h"

class quene{
public:
	quene(void);
	link tail;
	link base;
	void push(linkelem);
	linkelem pop();
	int length();
	bool empty();
};

/* quene.cpp */

#include "quene.h"

quene::quene(){
	base = new linknode;
	tail = base;
}

void quene::push(linkelem e){
	tail->add(e);
	tail = tail->next;
	return ok;
}

linkelem quene::pop(){
	linkelem rtn;
	rtn = 0;
	if(!empty()){
		rtn = base->next->e;
		if(tail == base->next){
		tail = base;
	}
	link temp = base->next;
	base->next = temp->next;
	delete(temp);
	}
	return rtn;
}

bool quene::empty(){
	if(!base->next){
		return true;
	}
	return false;
}

int quene::length(){
	link temp = base;
	int rtn = 0;
	while(temp->next){
		temp = temp->next;
		rtn++;
	}
	return rtn;
}

 Realmente no hay nada que decir sobre la cola, pero existe el problema de que la función de longitud debe atravesarse una vez cada vez que se llama. Si cree que esta función es una pérdida de recursos, puede agregar una variable de longitud a la clase. para reemplazarlo y luego hacer lo que quieras. La lógica funciona así.

código de pila

/* stack.h */

class stack{
public:
	stack(void);
	link base;
	link top;
	void push(linkelem);
	linkelem pop();
	bool empty();
	linkelem getop();
};

/* stack.cpp */

stack::stack(){
	base = new linknode;
	top = base;
}

void stack::push(linkelem e){
	top->add(e);
	top = top->next;
	return ok;
}

linkelem stack::pop(){
	linkelem rtn;
	rtn = top->e;
	if(!empty()){
		top = top->prev;
		delete(top->next);
		top->next = 0;
	}
	return rtn;
}

linkelem stack::getop(){
	linkelem rtn;
	rtn = top->e;
	return rtn;
}

bool stack::empty(){
	return base->next==0;
}

Pila, aquí hay una función gettop. De hecho, la cola frontal debería tener una función gethead correspondiente al pasado. Después de todo, a veces no necesitamos abrir los elementos de la pila para ver qué hay en la parte superior de la pila. Lo mismo ocurre con la cola, este código es del pasado, la implementación tiene el requisito de leer la parte superior de la pila, por lo que se conserva y las funciones que no sean necesarias se pueden eliminar.

Es suficiente proporcionar aquí tres modelos simples de estructuras de datos, y aquellos que acaban de aprender C ++ deberían poder comprenderlos, pero las operaciones de puntero aún pueden ser demasiado y es necesario comprender un poco.