标签: stack

我需要一个必须添加/删除一些结构的队列,例如:

struct MyObject
{
  int offset;
  BYTE status, data1, data2;
  double beatPos;

  enum Status
  {
    isOff = 8,
    isOn = 9,
  };
}   

当我.Add()是一个元素时,这个队列必须把元素放在正确的位置,因为这个beatPos值必须从下面(队列的顶部,即我要弹出的下一个元素)到上面(最后一个元素)排序我将从中提取).

我看到有std :: priority_queue,但我不确定我是否可以选择哪个是排序字段.

此外,一旦我在列表中添加了一些结构,我想删除第一个元素(例如)beatPos=1,567(例如,可能位于列表中间;不一定在开头).

有线索吗？

我最近进入了C#,我试图了解一下Stacks.我想尝试对堆栈进行排序,首先将其转换为数组,但我得到了一个奇怪的错误.

这是我的代码:

using System;
using System.Collections.Generic;

class Program
{
    public static Stack<int> numbers = new Stack<int>();
    static void Main(string[] args)
    {
        string[] input = Console.ReadLine().Split(' ');

        int n = int.Parse(input[0]);
        int s = int.Parse(input[1]);
        int x = int.Parse(input[2]);

        input = Console.ReadLine().Split(' ');
        for (int i = 0; i < n; i++)
        {
            numbers.Push(int.Parse(input[i]));
        }

        for (int i = 0; i < s; i++)
        {
            numbers.Pop();
        }

        if (numbers.Count == 0)
            Console.WriteLine(0);
        else if (numbers.Contains(x))
            Console.WriteLine("true");
        else
            Console.WriteLine(Array.Sort(numbers.ToArray()));


    }
}

我的问题是我的代码的最后一部分(最后一行): …

我是C#的新手.是否有可能通过索引获取堆栈项,就像我们在C#中的列表中所做的那样？

谢谢,

所以我遇到Visual Studio 2013的问题这段代码没有显示编译错误,但显示调试错误

变量'Joueur'周围的堆栈已损坏.

这是代码:

== Source.cpp

#include <stdlib.h>
#include <stdio.h>
#include "Header.h"

int main()
{
    Personne Joueur[2];
    printf("***** Bienvenue ***** \n \n \n");
    int k ;
    for (k = 0; k < 3; k++)
    {
        printf("Bonjour Joueur %d :\n", k+1);
        printf("Nom: ");
        fgets(Joueur[k].Nom,50,stdin);
        printf("Votre nom est: %s", &Joueur[k].Nom);
        printf("\n \n");
    }
    return 0;
}

== Header.h

typedef struct Personne Personne;
struct Personne
{
    char Nom[1500];
    char Prenom[1500];
    int Age;
    int Tel;
    double Moy;
};

我一直在学习堆栈和堆,特别是堆栈和它的LIFO方法.

这是否适用于方法中的嵌套块,并且可以用于提高性能,例如

public void Test() {
    int i = 5;
    // do something with i

    int j = 5;
    // do something with j
}

在此示例中,仅在方法结束时,i和j将从堆栈中释放.

以下会更有效吗？(我知道它的一个简单的程序.....)或者释放的努力是否会更多地节省堆栈的大小？

public void Test() {
    {
        int i = 5;
        // do something with i
    }
    {
        int j = 5;
        // do something with j
    }
}

这仅仅是为了示例目的,我知道我可以重构这个等等.我只对方法中的内存发生了什么感兴趣....

使用向量作为堆栈时(存储被推送和弹出的状态).

while stack.len() != 0 {
    let state = stack.pop().unwrap();
    // ... optionally push other states onto the stack.
}

在Rust中有一个不那么冗长的方法吗？

我最近接受了SDE的亚马逊采访.有人问我设计一个栈做push,pop并min在O(1).
我得到了逻辑并实现了堆栈的推送.在实现新堆栈的推送时,我调用了给定堆栈和最小堆栈的推送,这是新堆栈的一部分.面试官告诉我,我不能这样做,因为推送将是递归调用.我向他解释说,我们可以用不同的名字命名,但他坚持认为旧堆栈和新堆栈上的操作都称为推送.

我怎么能达到同样的目的？(面试官似乎非常卑鄙,因为我的逻辑是正确的,他仍然告诉我,由于上述原因,我做错了)

我试图编写一个使用节点来存储数据的堆栈,我试图将它与模板一起使用,以便存储的数据可以是不同的数据类型.我正在使用它与堆栈,所以节点可以移动或删除但是我已经初始化堆栈,我试图通过couting文本接收反馈,以确保一切正常,但事实并非如此.

没有反馈将返回到模板,并且Visual Studios 2013中没有错误.如果有人可以看一看并解释为什么那会很棒.此外,如果有人有更多关于使用"通用编程"的信息,以允许多种数据类型,这将是非常有用的.下面是分为两个标题和一个主要cpp的代码.

template <class T>
class Node {
public:
    T    data;
    Node * next;
    Node * start;
    Node(T inputdata){
        data = inputdata;
    }
    T getData() {
        return data;
    }
};



#include "node.h"
using namespace std;

template<typename DT>
class Stack{
private:
    int size;
    Node<DT> *top;
    Node<DT> *s_ptr;

public:
    Stack();
    void push(DT val);
    DT pop();
    void start();
};

template<typename DT>
Stack<DT>::Stack()
{
    cout << "Stack Started" << endl;
}

template<typename DT>
void Stack<DT>::push(DT val)
{

}

template<typename DT>
DT Stack<DT>::pop() …

即使在C(不仅仅是C++)中,您也可以在代码块的开头声明变量,该代码块用大括号括起来.

例:

#include <stdio.h>
void use_stack(int cnt)
{
    if (cnt<=16) {
        int a[16];
        int i;
        a[0]=3;
        a[1]=5;
        for (i=2;i<cnt;i++) {
            a[i]=a[i-1]+a[i-2];
        }
        printf("a[%d] == %d\n",cnt-1,a[cnt-1]);
    }
    else {
        printf("cnt is too big\n");
    }
}

现在我知道a[16]在这种情况下,像数组这样的变量会在堆栈上分配.

我想知道这个数组的空间是在函数的开头分配的(第一个打开大括号)还是在声明它的块的开头(打开大括号后if).

从检查汇编程序代码开始,编译器似乎a[16]直接在函数入口处分配空间.

我实际上期望在声明处分配堆栈(堆栈指针减少),a[16]并且在相应if代码块的末尾将堆栈解除分配(堆栈指针增加).

但是这似乎没有发生(堆栈a[16]直接在函数入口处分配,即使a[16]在else分支中没有使用).

有没有人解释为什么会这样？

那么是否有C语言标准的任何部分,它解释了这种行为,还是与"longjmp"或信号处理有关,这可能要求堆栈指针在函数内部是"常量"？

注意:我假设堆栈的原因是在代码块的开头/结尾分配/解除分配,因为在C++中,在堆栈上分配的对象的构造函数/析构函数将在代码块的开头/结尾处调用.因此,如果您检查C++程序的汇编代码,您会注意到堆栈仍然在函数入口处分配; 只是构造函数/析构函数调用将在代码块的开始/结束时完成.

我明确感兴趣为什么堆栈没有使用花括号在代码块的开头/结尾分配/解除分配.

问题:在什么时刻是本地变量分配存储？仅涉及在函数开始时分配的局部变量.我很惊讶稍后在代码块内分配的变量的堆栈分配也在函数入口处完成.

到目前为止,答案是:

• 与优化有关
• 可能与C,C++不同
• 在C语言规范中甚至没有提到堆栈

所以:我对C的答案感兴趣...(我坚信答案也适用于C++,但我不是在问C++ :-)).

优化:这是一个例子,它将直接说明为什么我如此惊讶,以及为什么我很确定这不是一个优化:

#include <stdio.h>

static char *stackA;
static char *stackB; …

为了在未加权图上实现Dijkstra的最短路径算法以使其在线性时间内运行，要使用的数据结构为：

1. 队列
2. 堆
3. 堆
4. B树

我发现以下答案：

1. 队列，因为我们可以使用广度优先搜索（BFS）算法在未加权图中找到单个源最短路径，该算法使用“队列”数据结构，时间为O（m + n）（即相对于顶点和边的数量呈线性） ）

2. 要在线性时间内实现它，就需要一个最小堆，因为如果我们在此处删除一个最小堆中的节点，则将不需要任何时间进行调整，因为所有r具有相同的权重，因此删除一个节点需要O（1）。 n-1个节点，它将是O（n）。

有人可以解释哪个是正确的答案吗？