标签: stack

我不知道在哪里发布这个,但我想我在K&R的波兰计算器程序中发现了一个相当大的错误.基本上,当您执行操作时,会弹出两个值,而只会推送结果.问题是结果没有被推到堆栈顶部!这是一个例子:

教科书提供的波兰计算器的完整代码如下所示:

#include <stdio.h>
#include <stdlib.h> /* for atof() */

#define MAXOP 100 /* max size of operand or operator */
#define NUMBER '0' /* signal that a number was found */

int getop(char []);
void push(double);
double pop(void);

/* reverse Polish calculator */
main()
{
    int type;
    double op2;
    char s[MAXOP];

    while ((type= getop(s)) != EOF) {
        switch (type) {
        case NUMBER:
            push(atof(s));
            break;
        case '+':
            push (pop() + pop()) ;
            break;
        case '*':
            push(pop() * pop());
            break;
        case …

我正在尝试以下代码:

import java.util.Stack;
public class HelloWorld{

 public static void main(String []args){
    Stack s=new Stack();
    s.push(5-4);
    s.push(9);
    s.push(51);
    if(s.get(1).equals("9"))
        System.out.println("yes its comparable");
    System.out.println(s.get(1));

 }
}

实际输出是:

9

我希望输出为:

yes its comparable
9

我无法弄清楚.我已经尝试了s.get(1)=="9"但它也不起作用.这可能背后的关键是什么？它们都不是字符串吗？或者一个是字符串一是对象,但它们仍然具有可比性.有人可以开导我这个吗？

我正在尝试编写一个简单的程序来展示如何在堆栈上间接操作变量.在下面的代码中,一切都按计划工作:即使a的地址被传入,我也可以间接地改变c的值.但是,如果我删除最后一行代码(或最后三行代码),则不再适用.这些行是否以某种方式迫使编译器将我的3个变量按顺序放入堆栈中？我的期望是,情况总是如此.

#include <iostream>

using namespace std;

void  someFunction(int* intPtr)
{
  // write some code to break main's critical output
  int* cptr = intPtr - 2;
  *cptr = 0;
} 


int main() 
{
  int a = 1;
  int b = 2;
  int c = 3;

  someFunction(&a);

  cout << a << endl;
  cout << b << endl;
  cout << "Critical value is (must be 3): " << c << endl;

  cout << &a << endl;
  cout << &b << endl;
  cout << …

这是一个用于实现Stack的相当简单的程序.但与的声明一个问题push(),pop()和display()功能.错误陈述如下.请帮我弄清楚问题所在.

错误:

error C2664: 'push' : cannot convert parameter 1 from 'int [10]' to 'int'
error C2664: 'pop' : cannot convert parameter 1 from 'int [10]' to 'int'
error C2664: 'display' : cannot convert parameter 1 from 'int [10]' to 'int'

程序:

#include<iostream>
#define STACKSIZE 10
using namespace std;
void push(int,int,int);
void pop(int,int);
void display(int,int);
int main()
{
    int stack[STACKSIZE],n,data,stackptr=-1;
    while(1)
    {
        cout<<"1. Push\n2. Pop\n3. Display\n4. Exit\n";
        cin>>n;
        switch(n)
        {
        case 1:
            cout<<"\nEnter a …

我正在实现一个带有两个堆栈的字符缓冲区.我用insert()方法插入一个元素:

class Buffer
{
    private Stack<Character> stackLeft;
    private Stack<Character> stackRight;
    private int size;

    Buffer()
    {
        Stack<Character> stackLeft   = new Stack<Character>();
        Stack<Character> stackRight  = new Stack<Character>();
        size = 0;
    }

    public void insert(char c)
    {
        size ++;
        stackLeft.push(c); //This line returns NullPointerException
    }
}

每次尝试推送c字符变量时,它都会抛出Null指针异常.这是我从main调用它的方式:

public static void main(String[] args)
{
    Buffer tb = new Buffer();

    Character ch = new Character('a');
    tb.insert(ch);
    tb.insert(new Character('a'));
    tb.insert('a');
}

所有这些都返回null异常.断言Character到达方法内部很好.我用过java.util.Stack; 当它失败时,我实现了自己的.但它仍然失败了.
我能做错什么？
任何形式的帮助表示赞赏!

我正在尝试检查表达式是否在括号中是平衡的,我的程序应该输出相应的消息,如下所示:(我正在从文件中读取表达式)

如果对于每个")"有一个"("那么它是平衡的.如果有一个")"没有"("那么左括号丢失,依此类推.

我为"(A + B)"的情况制定了代码,它打印平衡,但对于"(A + B)"的情况,它打印平衡和左丢失,我似乎无法弄清楚是什么问题是

这里是代码:(编辑:我把它作为一种方法,当表达式平衡时,它工作正常,当右括号丢失时,如果左边的一个缺失它打印出"平衡")问题是当它左括号丢失,返回的堆栈为空,这就是它打印"平衡"的原因.我真的不知道如何解决这个问题!

 public static Stack isBalanced(String str) {

    Stack s = new Stack();
    char temp;

    for (int i = 0; i < str.length(); i++) {
        if (str.charAt(i) == '(') {
            s.push(str.charAt(i));
        } else if (str.charAt(i) == ')') {
                if (!s.isEmpty()) {
                temp = (char) s.pop();
            }
        }
    }
    return s;
}

我正在练习Try-Catch,异常处理,堆栈和队列,所以尽管代码可能不切实际,但它对我的实践很有用.

public class Practice {
public static void main(String args[]){
    Stack<String> sStack = new Stack<String>();
    Queue<String> sQueue = new LinkedList<String>();
    Scanner input = new Scanner(System.in);
    String inString = " ";

    boolean done = false;
    do{
        try{
            while(!inString.equals("")){
                System.out.println("Enter a string: ");
                inString = input.nextLine().toString();
                addS(sStack,inString);
            }
            done = true;
        }catch(Exception e){}
        sStack.pop();
        for(int i = 0; i<sStack.size()+1;i++){
            remS(sStack);
        }

    }while(done == false);
}

代码旨在根据用户输入循环并填充空堆栈,然后循环遍历堆栈并在提示时删除每个元素.我输入的第一组是:

[艺术,蝙蝠,猫,码头,眼睛,父亲]

第二组是:

[艺术,蝙蝠,猫,码头,眼睛,父亲,孩子]

我注意到无论我输入多少元素,它最多只能删除4个元素.我想帮助你搞清楚原因.正如你所看到的,我试着玩循环的界限,但无济于事.无论我在哪里开始或绑定,它总是最终只会弹出4个元素.

我在下面提供的addS和remS函数

public static void addS(Stack t, String s){
    t.push(s);
    System.out.printf("%s was added …

我知道从堆栈中分配内存更快,但是当访问更快的变量时:

void fn1()
{
    int *p=new int[50];
    for(int i=0;i<50;i++)
        p+i=i*i;
}

void fn2()
{
    int p[50];
    for(int i=0;i<50;i++)
        p[i]=i*i;
}

上述哪些功能会更快执行？

我问它是因为我正在用c ++创建一个游戏引擎,并且我经常进行绘制调用,这些调用很小,只涉及矩阵的转换,旋转等,因此哪个分配对我的目的最有用

我有以下代码,我得到堆栈溢出错误任何人都可以请解释我这里有什么问题.从我的理解,这个指针指向当前对象,所以为什么我不能在析构函数中删除它;

class Object 
{
private:
    static int objCount;
public:
    int getCount()
    {
        int i =10;
        return i++;
    }
    Object()
    {
        cout<< "Obj Created = "<<++objCount<<endl;
        cout <<endl<<this->getCount()<<endl;
    }
    ~Object()
    {
        cout<<"Destructor Called\n"<<"Deleted Obj="<<objCount--<<endl;
        delete this;
    }
};

int Object::objCount = 0;

int _tmain(int argc, _TCHAR* argv[])
{


    {
        Object obj1;
    }

    {

              Object *obj2 = new Object();
    }
    getchar();
    return 0;
}

我最初使用矢量存储"传入的项目",但即使有大量的RAM,这也不实用.因此我决定存储最后收到的X项.

什么是最好的数据结构？我在想一个std :: queue？这是我想到的伪代码:

if(queue.size() == max_size){
    queue.pop()
}

queue.push(new_item);

数据结构的用法是存储事件的历史记录,如果使用的话,将是回滚 - 因此迭代结构中的每个项目.