栈和队用链表实现

栈是FILO，队是FIFO， 用类实现栈很简单，用链表操作需要注意的是内存问题，下面是用链表实现简单的数据结构--栈和队：

stack

#include<iostream>
#include<cstddef>
using namespace std;

class Stack {
public:
Stack() {
top_node = NULL;
node_num = 0;
}

Stack(const Stack &stack) {
top_node= NULL;
node_num= 0;
int n= stack.node_num;
Node* t= stack.top_node;
while (n--) {
push(t->element);
t= t->next;
}
reverse();
}
size_t size() const {
return node_num;
}

int top() const {
return top_node->element;
}

void push(int element) {
if (top_node == NULL) {
top_node = new Node(element);
} else {
Node*temp = new Node(element, top_node);
top_node = temp;
}
++node_num;
}

void pop() {
if (top_node == NULL) return;
Node *temp = top_node;
top_node = top_node->next;
delete temp;
--node_num;
}

void swap(Stack<ElementType>& stack) {
Node* temp = top_node;
top_node = stack.top_node;
stack.top_node = temp;
size_t temp_num = node_num;
node_num = stack.node_num;
stack.node_num = temp_num;
}

void reverse() {
if (node_num <= 1) return;

Stack temp;
while (!empty()) {
temp.push(top());
pop();
}
swap(temp);
}

void clear() {
while (!empty()) pop();
}

private:
struct Node {
int element;
Node* next;
Node(int ele, Node *n = NULL) {
element = ele;
next = n;
}
};
Node *top_node;
size_t node_num;
};

queue

#include <iostream>
using namespace std;

class Queue {
public:
Queue();

Queue(const Queue& another);
~Queue();
bool empty();
int size();
int front() const;
int back() const;
void push(int element);
void pop();
void swap(Queue<int>& queue);

private:
struct Node {
int element;
Node* next;
Node(int ele, Node* n = NULL) {
element = ele;
next = n;
}
};
Node* front_node;
Node* back_node;
int node_num;
};

Queue::Queue(const Queue& another) {
if (this == &another) return;
front_node = back_node = NULL;
node_num = 0;
Node* temp = another.front_node;
while (temp != NULL) {
push(temp->element);
temp = temp->next;
}
}

Queue::Queue() {
front_node = back_node = NULL;
node_num = 0;
}

Queue::~Queue() {
while (!empty()) {
pop();
}
}

bool Queue::empty() {
return node_num == 0;
}

int Queue::size() {
return node_num;
}

int Queue::front() const {
return front_node->element;
}

int Queue::back() const {
return back_node->element;
}

void Queue::push(int element) {
if (front_node == NULL) {
front_node = back_node = new Node(element);
} else {
back_node->next = new Node(element);
back_node = back_node->next;
}
node_num++;
}

void Queue::pop() {
if (empty()) return;
if (size() == 1) {
delete front_node;
front_node = back_node = NULL;
} else {
Node* temp = front_node;
front_node = front_node->next;
delete temp;
}
node_num--;
}

void Queue::swap(Queue& queue) {
int old_size = size();
while (!empty()) {
queue.push(front());
pop();
}
while (queue.size() > old_size) {
push(queue.front());
queue.pop();
}
}