Question

我想要实现堆栈，我在互联网上找到了一个工作模型，不幸的是它基于我知道我想立即实现的堆栈大小的想法。我想要做的是能够在需要时将片段添加到我的堆栈中，因为所需的插槽的潜在最大数量可以达到成千上万，并且从我的理解中将大小设置为一成不变（当不需要所有这些时）大多数时候）是一个巨大的内存浪费和程序执行速度的损失。我也不想在我的实现中使用任何复杂的预先编写的函数（STL提供的函数或不同的库，例如vector等），因为我想通过尝试自己制作/简单帮助来理解所有这些函数。< / p>

        struct variabl {
            char *given_name;
            double value;
        };
        variabl* variables[50000];
        int c = 0;
        int end_of_stack = 0;

        class Stack
        {
        private:
            int top, length;
            char *z;
            int index_struc = 0;


        public:
            Stack(int = 0);
            ~Stack();
            char pop();
            void push();

        };

        Stack::Stack(int size) /* 
This is where the problem begins, I want to be able to allocate the size 
      dynamically.
    */
     {
            top = -1;
            length = size;
            z = new char[length];
        }
        void Stack::push()
        {
            ++top;
            z[top] = variables[index_struc]->value;
            index_struc++;
        }
        char Stack::pop()
        {
            end_of_stack = 0;
            if (z == 0 || top == -1)
            {
                end_of_stack = 1;
                return NULL;
            }
            char top_stack = z[top];
            top--;
            length--;

            return top_stack;
        }
        Stack::~Stack()
        {
            delete[] z;
        }

我有点想法，并试着做了

Stack stackk
//whenever I want to put another thing into stack
stackk.push = new char;

但后来我并没有完全理解它是如何为我的目的工作的，我认为它不会完全可以使用pop方法等，因为它将是一组独立的数组/变量对吗？我希望实现保持相当简单，以便我能理解它。

Answer 1

更改push功能以获取参数，而不是需要引用variables。

要处理推送，请从数组z的初始长度开始（将z更改为更好的变量名称）。当您推送新值时，请检查新值是否意味着数组的大小太小（通过比较length和top）。如果它将超过当前大小，请分配一个更大的数组并将值从z复制到新数组，释放z，并使z指向新数组。

Answer 2

这里有一个简单的实现，无需重新分配数组。它使用辅助类Node，它包含一个值，以及指向另一个Node的指针（设置为NULL以指示堆栈的结尾）。

main（）通过读取表单

的命令来测试堆栈

p c：将c推送到堆栈

g：打印堆叠顶部并弹出

#include <cstdlib>
#include <iostream>
using namespace std;

class Node {
    private:

    char c;
    Node *next;

    public:

    Node(char cc, Node *nnext){
        c = cc;
        next = nnext;
    }

    char getChar(){
        return c;
    }

    Node *getNext(){
        return next;
    }

    ~Node(){}
};

class Stack {
    private:

    Node *start;

    public:

    Stack(){
        start = NULL;
    }
    void push(char c){
        start = new Node(c, start);
    }
    char pop(){
        if(start == NULL){
            //Handle error
            cerr << "pop on empty stack" << endl;
            exit(1);
        }
        else {
            char r = (*start).getChar();
            Node* newstart = (*start).getNext();
            delete start;
            start = newstart;
            return r;
        }
    }

    bool empty(){
        return start == NULL;
    }
};

int main(){
    char c, k;

    Stack st;

    while(cin>>c){
        switch(c){
            case 'p':
                cin >> k;
                st.push(k);
                break;
            case 'g':
                cout << st.pop()<<endl;
                break;
        }
    }
    return 0;
}

使用C ++实现堆栈而不使用<stack> </stack>

2 个答案: