单向链表高效的实现栈类，不含链表头和尾节点~使用单项链表实现高效的队类，不含链表头和尾节点

最新推荐文章于 2021-02-26 12:24:38 发布

u010944926

最新推荐文章于 2021-02-26 12:24:38 发布

阅读量979

点赞数

CC 4.0 BY-SA版权

分类专栏： C/C++数据结构

本文链接：https://blog.youkuaiyun.com/u010944926/article/details/18312641

C/C++数据结构专栏收录该内容

58 篇文章

订阅专栏

本文介绍了一种使用单向链表高效实现栈和队列的方法，不使用额外的头尾节点，通过模板定义了通用的节点结构，并分别提供了栈和队列的基本操作如压入、弹出等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

单向链表高效的实现栈类，不含链表头和尾节点:

template <typename Object>
struct node
{
    Object data;
    node *next;
    node( Object obj, node *ptr ):data( obj ),next( ptr ){ }
    node( ) : next( NULL ){ }
};

template <typename Object>
class stack
{
private:
    node<Object> *head;
public:
    stack( ):head( NULL ){ }
    ~stack ( )
    {
        while (head) {
            pop();
        }
    }
    void push( Object obj )
    {
        node<Object> *ptr = new node<Object>( obj, head );
        
        head = ptr;
    }
    void top( )
    {
        return head->data;
        
    }
    void pop( )
    {
        node<Object> *ptr = head->next;
        delete head;
        head = ptr;
    }
    

};



int main(int argc, const char * argv[])
{

    // insert code here...
    std::cout << "Hello, World!\n";

    return 0;
}

使用单项链表实现高效的队类，不含链表头和尾节点:

template <typename Object>
class queue
{
private:
    node<Object> *front;
    node<Object> *rear;
public:
    queue( ):front(NULL), rear(NULL){ }
    ~queue( )
    {
        while (front) {
            deque();
        }
    }
    
    void enque( Object obj )
    {
        node<Object> *ptr = new node<Object>(obj);
        if (rear) {
            rear = rear->next = ptr;
        }else
        {
            front = rear = ptr;
        }
        
    }
    
    
    Object deque( )
    {
        Object temp = front->data;
        node<Object> *ptr = front;
        if (front->next == NULL) {
            front = rear = NULL;
        }
        else
        {
            front = front->next;
            delete ptr;
            return temp;
        }
    }
};