数据结构之——基于链表的队列的C++模板实现

//节点的结构
template<typename T>
struct node
{
    T data;
    node<T>* next;
    node():next(nullptr){};
    node(T t):data(t),next(nullptr){};
}
//模板类构造队列类
template<typename T>
Class Myqueue
{
public:
    Myqueue():head(nullptr),tail(nullptr),count(0)
    {
        head=new node<T>();
        tail=head;
        count=0;
    }
    void enqueue(T &x);
    T front();
    void dequeue();
    int counts();
    bool empty();
    ~Myqueue()
    {
        while(head->next!=nullptr)
        {
            node<T>* p=head;
            head=head->next;
        }
    }
private:
    int count;
    node<T>* head;
    node<T>* tail;
}
template<typename T>
void Myqueue<T>::enqueue(T &x)
{
    node<T>* p= new node<T>(x);//申请空间
    head->next=p;
    head=p;
    count++;
}
template<typename T>
bool Myqueue<T>::empty()
{
    return count==0;
}
template<typename T>
T MyStack<T>::front()
{
    if(!empty())
        return head->next->dada;
}
template<typename T>
void MyStack<T>::pop()
{
    if(!empty())
    {
        node<T>* del=head->next;
        head->next=haed->next->next;
        delete del;
        count--;
    }
}
template<typename T>
int MyStack<T>::counts()
{
    return count;
}
时间: 2024-10-19 01:26:04

数据结构之——基于链表的队列的C++模板实现的相关文章

数据结构之——基于数组的队列的C++模板实现

template<typename T> Class Myqueue { public: Myqueue(int max=50):capa(max),head(0),tail(0),data(nullptr) { data=new T[capa] } void enqueue(T &x);//入队 T front();//队首 void dequeue();//出队 int counts();//元素个数 bool empty();//判空 bool full();//判满 ~Myqu

数据结构 - 基于链表的队列

基于链表的队列 当我们基于链表实现队列时,需要从一端加元素,另一端取出元素,就需要引入一个新的变量tail指向链表的尾部,此时,向尾部进行添加操作时间复杂度会变为O(1),然而删除操作还是需要从head向后遍历,所以此时选择链表尾为队尾,链表头为队首. 基于链表的实现的源码如下: package queue; import linkedList.LinkedList; public class LinkedListQueue<E> implements Queue<E> {    

数据结构录 之 链表&amp;栈&amp;队列

三种基本的数据结构,来稍微说一下. 首先链表,这个几乎每本C++的语言书都会说的,直接看书上说的就好. 链表就是一个链,每一个都有一个指针指向下一个,然后这样串了起来.然后可以从头开始找,一直找到尾巴.然后对于某个数据点,都可以删除,只需要让他前面那个指向他后面那个,这样从头开始找的时候就找不到这个点了...在这个点之后添加一个点也是这样,直接让这个点指向那个新的,然后让新的指向原来这个点指向的后一个... 可以想象就是一个个点,然后第一个指向第二个,第二个指向第三个...就像是一条长长的链一样

基于链表的队列LinkedBlockingQueue学习

LinkedBlockingQueue为先进先出队列 1.链表中的节点,next为后继节点    static class Node<E> {        E item;        Node<E> next;        Node(E x) { item = x; } } 2.三种构造方法a.容量为最大值 b.容量为指定大小 c.容量为最大值,使用Collection c初始化队列 public LinkedBlockingQueue() {this(Integer.MAX

数据结构之——基于链表的栈的模板实现

//节点的结构 template<typename T> struct node { T data; node<T>* next; node():next(nullptr){}; node(T t):data(t),next(nullptr){}; } //模板类构造栈类 template<typename T> Class MyStack { public: stack(); void push(T &x); T top(); void pop(); int

数据结构--队列实现(顺序队列和链队列)与C++模板

数据结构--队列实现(顺序队列和链队列)与C++模板 一.顺序队列 队列的顺序存储结构称为顺序队列,顺序队列实际上是运算受限的顺序表. ①和顺序表一样,顺序队列用一个向量空间来存放当前队列中的元素. ②由于队列的队头和队尾的位置是变化的,设置两个指针front和rear分别指示队头元素和队尾元素在向量空间中的位置,它们的初值在队列初始化时均应置为0. 注意: ①当头尾指针相等时,队列为空. ②在非空队列里,队头指针始终指向队头元素,尾指针始终指向队尾元素的下一位置.(所以以下循环顺序队列中当队尾

数据结构 - 基于数组的队列

队列Queue *队列也是一种线性结构 *相比于数组,队列对应的操作是数组的子集 *只能从一端(队尾)添加元素,从另一端(队首)取出元素 *队列是一种先进先出的数据结构(先到先得 First In First Out) 基于数组的队列实现的源码如下: package queue; public interface Queue<E> {        public void enqueue(E e);        public E dequeue();        public E getF

Java数据结构——用双端链表实现队列

//================================================= // File Name : LinkQueue_demo //------------------------------------------------------------------------------ // Author : Common //类名:FirstLastList //属性: //方法: class FirstLastList_long{ private Lin

《Java数据结构与算法》笔记-CH5-链表-5用双端链表实现队列

1 //用双端链表实现队列 2 /** 3 * 节点类 4 */ 5 class LinkQ { 6 private long data; 7 public LinkQ next; 8 9 public LinkQ(long d) { 10 this.data = d; 11 } 12 13 public String toString() { 14 return String.valueOf(this.data); 15 } 16 } 17 /** 18 * 双端链表类 19 */ 20 cl