c/c++模板实现链表、栈、列队

一、模板数组实现栈

#include<iostream>
using namespace std;
const int SiZE=10;
template<typename Type>
class myStack
{

public:
  void init_stack()
  {
    stackTail= -1;
  }
  int pushStack(Type elm);
  Type popStack();
private:
    int stackTail;
    Type stack_arry[SiZE];

    
};
template<typename Type>
int myStack<Type>::pushStack(Type elm)
{
  if(stackTail == SiZE)
  {
    cout<<"堆栈已满,进堆栈失败"<<endl;
    return stackTail;
  }
  stackTail++;
  stack_arry[stackTail] = elm;
  return stackTail;
}
template<typename Type>
Type myStack<Type>::popStack()
{
  Type temp;
  if(stackTail == -1)
  {
    cout<<"堆栈已空,出堆栈失败"<<endl;
    return stackTail;
  }
  temp = stack_arry[stackTail];
  stack_arry[stackTail]=(Type)0;
  stackTail--;
  return temp;
}

int main()
{
  myStack<char> stack1;
  stack1.init_stack();
  stack1.pushStack('a');
  stack1.pushStack('c');
  cout<<stack1.popStack()<<endl;
  cout<<stack1.popStack()<<endl;
  cout<<stack1.popStack()<<endl;
  return 0;
}

二、模板链表实现栈

#include<iostream>
using namespace std;

template<typename Type>
class myStack
{

public:
  void init_stack()
  {
    stackTail=NULL;
  }
  void pushStack(Type elm);
  Type popStack();
private:
    struct node
    {
      Type elm;
      node *next;
    } *stackTail;

    
};
template<typename Type>
void myStack<Type>::pushStack(Type elm)
{
  node *temp=new node;
  temp->elm=elm;
  temp->next=stackTail;
  stackTail=temp;
}
template<typename Type>
Type myStack<Type>::popStack()
{
  node *temp=this->stackTail;
  Type elm;
  if(this->stackTail == NULL)
  {
    cout<<"堆栈为空，出栈失败！"<<endl;
  }
  else
  {
  elm=this->stackTail->elm;
  stackTail=stackTail->next;
  delete temp;
  }
  return elm;
}

int main()
{
  myStack<char> stack1;
  stack1.init_stack();
  stack1.pushStack('a');
  stack1.pushStack('c');
  cout<<stack1.popStack()<<endl;
  cout<<stack1.popStack()<<endl;
  cout<<stack1.popStack()<<endl;
  cout<<stack1.popStack()<<endl;

  myStack<float> stack2;
  stack2.init_stack();
  stack2.pushStack(6.7);
  stack2.pushStack(8.8);
  cout<<stack2.popStack()<<endl;
  cout<<stack2.popStack()<<endl;
  cout<<stack2.popStack()<<endl;
  cout<<stack2.popStack()<<endl;

  myStack<char *> stack3;
  stack3.init_stack();
  stack3.pushStack("123");
  stack3.pushStack("124");
  cout<<stack3.popStack()<<endl;
  cout<<stack3.popStack()<<endl;
  cout<<stack3.popStack()<<endl;
  cout<<stack3.popStack()<<endl;

  myStack<string> stack4;
  stack4.init_stack();
  stack4.pushStack("126");
  stack4.pushStack("127");
  cout<<stack4.popStack()<<endl;
  cout<<stack4.popStack()<<endl;
  cout<<stack4.popStack()<<endl;
  cout<<stack4.popStack()<<endl;
  return 0;
}

三、模板链表实现列队

#include<iostream>
#include<string>
using namespace std;
template<typename Type>
struct queueNode
{
  Type elem;
  queueNode *next;
};

template<typename Type>
class myQueue
{
private:
  queueNode<Type> *head_queue;
  queueNode<Type> *tail_queue;
public:
  myQueue()
  {
    head_queue = NULL;
    tail_queue = NULL;
  }
  void enQueue(Type elem);
  
  Type deQueue();
};

template<typename Type>
void myQueue<Type>::enQueue(Type elem)
{
  queueNode<Type> *temp = new queueNode<Type>;
  temp->elem=elem;
  temp->next=NULL;
  if(head_queue == NULL)
  {
    head_queue = temp;
  }
  if(tail_queue != NULL)
  {
    tail_queue->next = temp;
  }
  tail_queue = temp;
}

template<typename Type>
Type myQueue<Type>::deQueue()
{
  queueNode<Type> *temp;
  Type deElem;
  temp = head_queue;
  if(head_queue == NULL)
  {
    cout<<"列队为空，出队失败！"<<endl;
  }
  else
  {
    head_queue = head_queue->next;
    if(head_queue == NULL)
    {
      tail_queue=NULL;
    }
    deElem = temp->elem;
    delete temp;
    //cout<<deElem<<endl;
  }
  return deElem;
}
int main()
{
  myQueue<char> myque1;//不可以使用 myque1()
  myque1.enQueue('d');
  myque1.enQueue('a');
  myque1.enQueue('b');
  
  cout<<myque1.deQueue()<<endl;
  cout<<myque1.deQueue()<<endl;
  cout<<myque1.deQueue()<<endl;
  cout<<myque1.deQueue()<<endl;
  cout<<myque1.deQueue()<<endl;

  myQueue<char *> myque2;//不可以使用 myque1()
  myque2.enQueue("qwer2");
  myque2.enQueue("qwer3");
  myque2.enQueue("qwer4");
  
  cout<<myque2.deQueue()<<endl;
  cout<<myque2.deQueue()<<endl;
  cout<<myque2.deQueue()<<endl;
  cout<<myque2.deQueue()<<endl;
  cout<<myque2.deQueue()<<endl;

  myQueue<string> myque21;//不可以使用 myque1()
  myque21.enQueue("qwer4");
  myque21.enQueue("qwer6");
  myque21.enQueue("qwer9");
  
  cout<<myque21.deQueue()<<endl;
  cout<<myque21.deQueue()<<endl;
  cout<<myque21.deQueue()<<endl;
  cout<<myque21.deQueue()<<endl;
  cout<<myque21.deQueue()<<endl;

  myQueue<double> myque3;//不可以使用 myque1()
  myque3.enQueue(3.4);
  myque3.enQueue(4.7);
  myque3.enQueue(5.8);
  
  cout<<myque3.deQueue()<<endl;
  cout<<myque3.deQueue()<<endl;
  cout<<myque3.deQueue()<<endl;
  cout<<myque3.deQueue()<<endl;
  cout<<myque3.deQueue()<<endl;
  return 0;
  
    
  
}