C++中实现队列类链式存储与栈类链式存储的代码示例

// 队列类 
 
#pragma once 
 
#include "linklist.hpp" 
 
template  
class LinkQueue 
{ 
public: 
  LinkQueue(); 
  ~LinkQueue(); 
public: 
  int clear(); 
  int append(T &t); 
  int retieve(T &t); 
  int header(T &t); 
  int length(); 
protected: 
  LinkList *m_list; 
}; 
 
template  
LinkQueue::LinkQueue() 
{ 
  m_list = new LinkList  ; 
} 
 
template  
LinkQueue::~LinkQueue() 
{ 
  clear(); 
  delete m_list; 
  m_list = NULL; 
} 
 
template  
int LinkQueue::clear() 
{ 
  T t; 
  while (m_list->getLen() > 0) { 
    m_list->del(0, t); 
  } 
  return 0; 
} 
 
template  
int LinkQueue::append(T &t) 
{ 
  return m_list->insert(t, m_list->getLen()); 
} 
 
template  
int LinkQueue::retieve(T &t) 
{ 
  return m_list->del(m_list->getLen() - 1, t); 
} 
 
template  
int LinkQueue::header(T &t) 
{ 
  return m_list->get(0, t); 
} 
 
template  
int LinkQueue::length() 
{ 
  return m_list->getLen(); 
} 

// 队列类测试程序 
 
#include  
#include  
#include "linkqueue.hpp" 
 
using namespace std; 
 
struct Student 
{ 
  char name[32]; 
  int age; 
}; 
 
void play() 
{ 
  Student s1, s2, s3; 
  s1.age = 21; 
  s2.age = 22; 
  s3.age = 23; 
 
  LinkQueue lq; // 创建队列 
  lq.append(s1); // 入队列 
  lq.append(s2); 
  lq.append(s3); 
 
  Student tmp; 
  lq.header(tmp); 
  cout <<"header of queue: " < 0) { 
    lq.retieve(tmp); 
    cout <

// 栈类 
 
#pragma once 
 
#include "linklist.hpp" 
 
template  
class LinkStack 
{ 
public: 
  LinkStack(); 
  ~LinkStack(); 
public: 
  int clear(); 
  int push(T &t); 
  int pop(T &t); 
  int top(T &t); 
  int size(); 
protected: 
  LinkList *m_list; 
}; 
 
template  
LinkStack::LinkStack() 
{ 
  m_list = new LinkList  ; 
} 
 
template  
LinkStack::~LinkStack() 
{ 
  clear(); 
  delete m_list; 
  m_list = NULL; 
} 
 
template  
int LinkStack::clear() 
{ 
  T t; 
  while (m_list->getLen() > 0) { 
    m_list->del(0, t); 
  } 
 
  return 0; 
} 
 
template  
int LinkStack::push(T &t) 
{ 
  return m_list->insert(t, 0); 
} 
 
template  
int LinkStack::pop(T &t) 
{ 
  return m_list->del(0, t); 
} 
 
template  
int LinkStack::top(T &t) 
{ 
  return m_list->get(0, t); 
} 
 
template  
int LinkStack::size() 
{ 
  return m_list->getLen(); 
} 

// 链式存储栈类的测试程序 
 
#include  
#include  
#include "linkstack.hpp" 
 
using namespace std; 
 
struct Student 
{ 
  char name[32]; 
  int age; 
}; 
 
void play() 
{ 
  Student s1, s2, s3; 
  s1.age = 21; 
  s2.age = 22; 
  s3.age = 23; 
 
  LinkStack ls; // 创建栈 
 
  // 入栈 
  ls.push(s1); 
  ls.push(s2); 
  ls.push(s3); 
 
  // 获取栈顶元素 
  Student tmp; 
  ls.top(tmp); 
  cout <<"top of stack: " < 0) { 
    ls.pop(tmp); 
  } 
 
  ls.clear(); 
 
} 
 
int main() 
{ 
  play(); 
 
  return 0; 
} 

// 链表类 
 
#pragma once 
 
#include  
#include  
using namespace std; 
 
template  
struct Node 
{ 
  T t; 
  Node *next; 
}; 
 
template  
class LinkList 
{ 
public: 
  LinkList(); 
  ~LinkList(); 
 
public: 
  int clear(); 
  int insert(T &t, int pos); 
  int get(int pos, T &t); 
  int del(int pos, T &t); 
  int getLen(); 
 
protected: 
  Node *header; 
  int length; 
}; 
 
template  
LinkList::LinkList() 
{ 
  header = new Node  ; 
  header->next = NULL; 
  length = 0; 
} 
 
template  
LinkList::~LinkList() 
{ 
  Node *tmp = NULL; 
 
  while (header) { 
    tmp = header->next; 
    delete header; 
    header = tmp; 
  } 
} 
 
template  
int LinkList::clear() 
{ 
  ~LinkList(); 
  LinkList(); 
  return 0; 
} 
 
template  
int LinkList::insert(T &t, int pos) 
{ 
  Node *cur = NULL; 
 
  // 对pos的容错处理 
  if (pos >= length) { 
    pos = length; 
  } 
 
  cur = header; 
  for (int i = 0; i next; 
  } 
 
  // 把上层应用的t结点缓存到容器中 
  Node *node = new Node  ; 
  node->next = NULL; 
  node->t = t; // 把t缓存到容器中 
 
  node->next = cur->next; 
  cur->next = node; 
 
  ++length; 
 
  return 0; 
} 
 
template  
int LinkList::get(int pos, T &t) 
{ 
  Node *cur = NULL; 
 
  if (pos >= length) { 
    return -1; 
  } 
 
  cur = header; 
  for (int i = 0; i next; 
  } 
 
  t = cur->next->t; // 把pos位置的结点赋值给t 
 
  return 0; 
} 
 
template  
int LinkList::del(int pos, T &t) 
{ 
  Node *cur = NULL; 
 
  if (pos >= length) { 
    return -1; 
  } 
 
  cur = header; 
  for (int i = 0; i next; 
  } 
  Node *ret = NULL; 
  ret = cur->next; 
  t = ret->t; // 把缓存的结点给上层应用t 
 
  // 删除操作 
  cur->next = ret->next; 
  --length; 
  delete ret; // 注意释放内存，因为insert的时候new Node 
 
  return 0; 
} 
 
template  
int LinkList::getLen() 
{ 
  return length; 
}