栈和队用链表实现

栈是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();
  }
}