Question

我正在处理一个ItemType堆栈的链表实现（当前设置为double但可以更改）值。虽然我的代码编译得很好，但我已经意识到我的size方法效率很低，因为它使用迭代来获得链表的大小--O（n）时间复杂度 - 当它可以简单地将大小存储为节点字段时，在我的其他方法中更新它，然后返回该值 - 改进方法，使其具有O（1）时间复杂度。不幸的是，我在解决如何集成这个新的大小字段时遇到了一些问题，特别是如何初始化它的值，我的编译器一直告诉我它无法编辑。那么，我的问题是如何将size作为节点类的一个字段实现（或者我应该在其他地方实现它？）我的代码应该在哪里初始化并更新它？

以下是链接列表堆栈的头文件：

#ifndef DBLSTACK_H
#define DBLSTACK_H


typedef double ItemType; // stack currently holds doubles


class DblStack
{
private:
    //Node class
    class Node
    {
    public:
        double data;
        Node *next;

        // Node constructor
        Node(double value, Node * link = 0)
        {
            data = value;
            next = link;
        }
    };

    typedef Node * NodePtr;

    // Data members
    NodePtr myTop;  //points to top of stack

  public:
    // Class Constructor
    DblStack();

    // Copy Constructor
    DblStack(const DblStack& rhs);

    // Class Deconstructor
    ~DblStack();

    // Assignment operator
    // Assigns a stack to another
    const DblStack& operator= (const DblStack& rhs);

    // isEmpty
    // Checks if the stack is empty
    bool isEmpty() const;

    // push
    // Pushes an item on top of the stack.
    void push(const ItemType& item);

    // pop
    // Pops the top item off the stack.
    void pop();

    // top
    // Returns the top item of the stack without popping it.
    ItemType top() const;

    // size
    // Returns the number of items on the stack.
    size_t size() const;

};

#endif

这是我的源文件：

#include <cstddef>  //for NULL
#include <stdexcept>
#include "DblStack.h"
using namespace std;

// Class Constructor
DblStack::DblStack()
: myTop(0)
{
}


// Copy Constructor
DblStack::DblStack(const DblStack& rhs)
{
    myTop = 0;
    if (!rhs.isEmpty())
    {
        // Copy first node
        myTop = new DblStack::Node(rhs.top());

        // Set pointers to run through stack
        DblStack::NodePtr lastPtr = myTop;
        DblStack::NodePtr origPtr = rhs.myTop->next;
        while (origPtr != 0)
        {
            lastPtr->next = new DblStack::Node(origPtr->data);
            lastPtr = lastPtr->next;
            origPtr = origPtr->next;
        }
    }
}



// Class Deconstructor
DblStack::~DblStack()
{
    // Set pointers to run through stack
    DblStack::NodePtr curr = myTop, next;
    while (curr != 0)
    {
        next = curr->next;
        delete curr;
        curr = next;
    }
}


// Assignment operator
// Assigns a stack to another
const DblStack& DblStack::operator= (const DblStack& rhs)
{
    if (this != &rhs)
    {
        this->~DblStack();
        if (rhs.isEmpty())
        {
            myTop = 0;
        }
        else
        {
            DblStack tmp(rhs);  // Call copy constructor
            std::swap(myTop, tmp.myTop);
        }
    }
    return *this;
}


// isEmpty
// Checks if the stack is empty
bool DblStack::isEmpty() const
{
    return (myTop == 0);
}


// push
// Pushes an item on top of the stack.
void DblStack::push(const ItemType& item)
{
    myTop = new DblStack::Node(item, myTop);
}


// pop
// Pops the top item off the stack.
void DblStack::pop()
{
    if (!isEmpty())
    {
        DblStack::NodePtr ptr = myTop;
        myTop = myTop->next;
        delete ptr;
    }
    else
    {
        throw std::underflow_error("Stack is empty");
    }
}


// top
// Returns the top item of the stack without popping it.
ItemType DblStack::top() const
{
    if (!isEmpty())
    {
        return myTop->data;
    }
    else
    {
        throw std::underflow_error("Stack is empty");
    }
}


// size
// Returns the number of items on the stack.
size_t DblStack::size() const
{
    size_t size = 0;
    DblStack::NodePtr ptr;
    for (ptr = myTop; ptr != 0; ptr = ptr->next)
    {
        size++;
    }
    return size;
}

虽然改进我的尺寸方法是这个问题的主要目标，但我也非常感谢您为优化我的代码而提出的任何其他建议。谢谢！

Answer 1

将大小包含为DblStack的成员，并修改其他方法以使其保持最新。

Answer 2

您想要将 size 成员变量添加到DblStack类中：

class DblStack
{
private:
    size_t size;
// ...
}

当你第一次构造DblStack时，它没有任何内容，所以它的大小应为0：

DblStack::DblStack()
    : myTop(0)
    , size(0)
{ }

现在您需要考虑尺寸何时会发生变化！您应该发现它更改的唯一情况是从堆栈中推送或弹出项目。因此，您希望您的推送和流行方法能够反映出这一点：

// Push increases stack size
size++;

// Pop decreases stack size
size--;

最后，您可以将size（）方法更改为仅返回大小：

size_t size() const { return size; }

在堆栈C ++的链表实现中跟踪堆栈大小

2 个答案: