标签: stack

我开始在学校最后一年开始之前检查数据结构和算法,以确保我掌握一切.一个评论问题说"使用链表或动态数组实现堆栈并解释为什么你做出了最好的选择".

对我来说,使用带有尾指针的列表来实现堆栈似乎更直观,因为它可能需要经常调整大小.对于大量数据来说,列表是更好的选择,因为动态数组重新调整大小是一项昂贵的操作.此外,使用列表,您不需要分配比实际需要更多的空间,因此它更节省空间.

但是,动态数组肯定允许更快地添加数据(除非需要调整大小).但是,我不确定使用数组是否整体更快,或者只是不需要调整大小.

该书的解决方案说"存储非常大的对象,列表是一个更好的实现",但我不明白为什么.

哪种方式最好？应该使用哪些因素来确定哪种实施方式"最佳"？还有,我的逻辑是什么？

这与"为什么堆栈通常会向下生长？"这个问题有关.,但从安全的角度来看更多.我通常指的是x86.

当缓冲区通常在内存中向上写入时,堆栈会向下增长,这让我觉得很奇怪.例如,典型的C++字符串的结尾位于比开头更高的内存地址.

这意味着如果存在缓冲区溢出,则会进一步覆盖调用堆栈,我理解这是一种安全风险,因为它可以更改返回地址和本地变量内容.

如果堆栈在内存中向上增长,那么缓冲区溢出会不会简单地运行到内存中？这会提高安全性吗？如果是这样,为什么还没有这样做？那么x64,那些堆栈是否会增长,如果不是,为什么不呢？

以下两个C#代码片段产生不同的结果(假设在递归调用之前和之后都使用变量级别).为什么？

public DoStuff(int level)
{
  // ...
  DoStuff(level++);
  // ...
}

,

public DoStuff(int level)
{
  // ...
  DoStuff(level+1);
  // ...
}

在阅读了下面的一些回复后,我认为值得发布级别++,++级别和级别+ 1的堆栈跟踪以突出显示欺骗这个问题的方式.

我已经为这篇文章简化了它们.递归调用序列以DoStuff(1)开始.

// level ++

DoStuff(int level = 1)
DoStuff(int level = 2)
DoStuff(int level = 2)
DoStuff(int level = 2)

// ++级别

DoStuff(int level = 4)
DoStuff(int level = 4)
DoStuff(int level = 3)
DoStuff(int level = 2)

// level + 1

DoStuff(int level = 4)
DoStuff(int level = 3)
DoStuff(int level = 2)
DoStuff(int level …

我知道每个正在运行的进程都在虚拟内存中有与之关联的页面,其中很少会根据需要加载到主内存中.我也知道程序将有一个堆栈,也有一个堆来分配动态内存.这是我的问题.

1. 堆栈也是主内存中某些页面的一部分吗？
2. 当程序进入等待状态时会发生什么？堆栈指针,程序计数器和其他信息存储在哪里？
3. 为什么堆栈增长和堆增长？
4. L1,L2缓存是否只包含一个连续内存块,或者它可以包含堆栈和堆的某些部分？

你能推荐一本涵盖这些东西的好书吗？

例如,当我们调用say,一个递归函数时,连续调用存储在堆栈中.但是,由于错误无效,因此错误是"分段错误"(如GCC所示).

它不应该是'堆栈溢出'吗？那两者之间的基本区别是什么？

顺便说一句,解释比维基百科链接更有帮助(经历过这一点,但没有特定查询的答案).

我正在Albahari兄弟的Nutshell中阅读C#4.0,我发现了这个:

堆栈在内部实现,其数组根据需要调整大小,与Queue和List一样.(第288页,第4段)

我不禁想知道为什么.LinkedList提供O(1)头尾插入和删除(这应该适用于堆栈或队列).可调整大小的数组有O(1)缓冲插入(如果我没记错的话),但O(n)最坏的情况(我不确定删除).它可能比链表使用更多的空间(对于大型堆栈/队列).

还有更多吗？双链表实现的缺点是什么？

很难实现node.js/server.js设置

我现在有点卡住了,希望有人可以解决一些问题.我对套接字一般来说比较新,但是已经在javascript中打开和关闭了几年,尽管只有完成手头任务所需的深度.因此,我对javascript堆栈堆和一般套接字的一些概念的理解有些局限.好的情况如下:

我创建了一个应用程序,旨在简单地在几台机器上增加一个计数器.有几个用户可以点击"下一步"按钮,它会立即在所有机器上更新.首次连接时,它会检索当前数字,并在本地将其吐出.

我在这里创建了服务器:

var io = require("socket.io");
var sockets = io.listen(8000);
var currentlyServing=0;
sockets.on("connection", function (socket)
{ 
    console.log("client connected");
    socket.emit("receive", currentlyServing);
    socket.on("update", function(serving)
    {
        currentlyServing=serving;
        if(currentlyServing>100)
            currentlyServing=0;
        if(currentlyServing<0)
            currentlyServing=99;
        socket.broadcast.emit("receive", currentlyServing);
        console.log("update received: "+currentlyServing);
    });
});
console.log("Server Started");

以下是客户端的相关(我希望)摘录:

var socket = io.connect("http://www.sampledomain.com:8000");

//function to update the page when a new update is received
socket.on("receive", function(receivedServing)
{
    document.getElementById('msgs').value=""+String("00" + receivedServing).slice(-2);
    document.getElementById('nowServing').value=receivedServing;
});

//this is called in an onClick event in the HTML source
//sends the new number to all …

无论是使用堆栈还是DFS或BFS的队列,我总是混淆.有人可以提供一些关于如何记住哪种算法使用哪种数据结构的直觉？

假设我们有4个课程如下:

class A
{
    public:           
        A(void) : m_B()
        {
        }
    private:
        B m_B;
}

class B
{
    public:            
        B(void)
        {
           m_i = 1;
        }
    private:
        int m_i;
}

class C
{
    public:           
        C(void) 
        {
            m_D = new D();
        }
        ~C(void) 
        {
            delete m_D;
        }
    private:
        D *m_D;
}

class D
{
    public:           
        D(void)
        {
           m_i = 1;
        }
    private:
        int m_i;
}

可以说有4种情况:

情况1:在堆栈上外部分配,B在堆栈内部分配

A myA1;

情况2:在堆上外部分配,B内部分配在堆栈上

A *myA2 = new A();

情况3:C在堆栈外部分配,D在堆内部分配

C myC1;

情况4:C在堆上外部分配,D在堆内部分配

C *myC2 = new …

我想在C函数中引发堆栈下溢,以测试我系统中的安全措施.我可以使用内联汇编程序来完成此操作.但是C会更便携.但是,我无法想到使用C引发堆栈下溢的方法,因为堆栈内存在这方面由语言安全地处理.

那么,有没有办法使用C激发堆栈下溢(不使用内联汇编程序)？

如注释中所述:堆栈下溢意味着使堆栈指针指向堆栈开头下方的地址(堆栈从低到高的架构"下方").