下面的代码试图创建一个地图,显示从该地图上的每个方块到指定位置所需的最小移动次数.作为一个整体的功能在很大程度上与问题无关,但我认为我应该在上下文中提出我的问题.我也从集合中导入了deque.奇怪的部分来自第7行.我得到TypeError:'int'对象不可迭代.但是声明"distance_from_loc,f_loc = squares_to_check.popleft()"不应该试图以最好的知识迭代任何东西.任何帮助将不胜感激.

    def complex_distance(self, loc):
        row, col = loc
        squares_to_check = deque((0, loc))
        self.complex_distance_map = zeros((self.height, self.width), int) + 999
        self.complex_distance_map[row][col] = 0
        while squares_to_check:
            distance_from_loc, f_loc = squares_to_check.popleft()
            distance_from_loc += 1
            for d in AIM:
                n_loc = self.destination(f_loc, d)
                n_row, n_col = n_loc
                if distance_from_loc < self.complex_distance_map[n_row][n_col] and not self.map[n_row][n_col] == -4:
                    squares_to_check.append((distance_from_loc, n_loc))
                    self.complex_distance_map[n_row][n_col] = distance_from_loc

如果数据结构具有随机访问,则标准表示std::binary_search(...)该两个相关函数std::lower_bound(...)和std::upper_bound(...)O(log n).因此,鉴于此,我假设这些算法具有O(log n)性能std::deque(假设其内容由用户保持排序).

然而,似乎内部表示std::deque是棘手的(它被分成块),所以我想知道:O(log n)搜索的要求是否成立std::deque.

我有一个程序,我收集一些数据并暂时存储在双端队列中

    typedef vector<float> floatVector;
    ...
    floatVector * currRecord;
    deque<floatVector *> data;
    ...
    ...

    for (...)
    {
        ...
        currRecord = new floatVector(10); 
        data.push_back(currRecord);
    }

后来,我想将数据保存到文件中

    while (data.size() > 0) 
    {
        for (int i=0; i < 10; i++) 
        {
            fprintf(fPtr, "%lf\t", data[0]->at(i) );
        }
    fprintf(fPtr,"\n");
    data.pop_front();
    }

所以,我的问题是,这个程序会导致内存泄漏吗？我使用new运算符为每个currRecord向量分配内存.deque pop_front功能会自动回收内存吗？或者我需要放

    delete [] data[0]

之前

    data.pop_front();

？另外,如果data是向量而不是双端队列,那么一切都是一样的吗？谢谢!

我正在寻找对此循环更优雅的解决方案。我的双端队列是动态创建的，并且长度可以变化。在下面的示例中，列表只有两个项目，可能最多三个项目。在我的应用程序中，列表最多可以包含30个项目。因此，我想避免编写大量的if语句，并在双端队列为空后停止执行代码。

from collections import deque

my_list = [ 1,2 ]
my_deque = deque ( my_list )

while my_deque:
    alpha = my_deque.popleft()
    beta = my_deque.popleft()
    gamma = my_deque.popleft()

上面的代码执行所有三个命令，并且在gamma命令上返回“ IndexError：从空双端队列弹出”。我了解为什么会发生此错误，但是想知道是否缺少一种技巧来评估while循环中间的列表/双端队列是否为空（或另一种创造性的循环长列表的方式） 。

谢谢您的帮助。

我想要一种方法来存储最多三个字符串.当我得到一个新的,我想将它添加到列表的底部,并从列表的顶部删除一个(最旧的一个).

我知道这可以在带有双端队列的python中完成,但不知道如何在AS3中实现它或者它是否已经存在.谷歌搜索在googlecode上发现了一些代码,但它没有编译.

当我在我的班级中使用std :: deque作为私人成员时,我会遇到很多错误,例如

/usr/include/c++/v1/deque:907:49: error: implicit instantiation of undefined template 'std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >' static const difference_type __block_size = sizeof(value_type) < 256 ? 4096 / sizeof(value_type) : 16;

/usr/include/c++/v1/deque:1181:30: error: '__alloc_traits' is a protected member of 'std::__1::__deque_base<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >' typedef typename __base::__alloc_traits __alloc_traits;

等等.

它在我使用矢量时有效,但我想要一个pop_front功能.

有任何想法吗？

编辑:
代码:

#include <deque>
class Example {
    public:
        Example() {}
        ~Example() {}
    private:
        std::deque<std::string> m_deque;
};

我是编程和Python的新手.
我编写了一个实现unix尾部的函数:

def tail(file):
    strin = open(file, 'r')
    lis = strin.readlines()
    lastline = lis[-1]
    return lastline
    strin.close()

但我认为它在性能上并不是最佳的.
我该如何改进？

我想根据节点结构中包含的int g值对双端队列进行排序.我的程序结构是这样的:

struct node
{
    int x;
    int y;
    int g;  
};

deque<node> open;

这是我正在尝试的排序功能,但它给出了垃圾值.请指导我:

deque<node> sort(deque<node> t)
{
    deque<node>::iterator it;
    int size= t.size();
    node te;
    for(int i=0; i<size; i++)
    {
        for(int j=0; j<size-i; j++)
        {
            if(t[j].g < t[j+1].g)
            {
                te.x = t[j].x;
                te.y = t[j].y;
                te.g = t[j].g;

                t[j].x = t[j+1].x;
                t[j].y = t[j+1].y;
                t[j].g = t[j+1].g;

                t[j+1].x = te.x;
                t[j+1].y = te.y;
                t[j+1].g = te.g;
            }
        }
    }

    for(it=t.begin();it!=t.end();it++)
    {   
        te = *it;
        cout<<te.x<<","<<te.y<<","<<te.g<<endl;
    }

    return t;
}

我创建了一个DeQueue作为follws

Deque<Integer> deque = new ArrayDeque<Integer>(8);

// use add() method to add elements in the deque
deque.add(20);
deque.add(30);
deque.addLast(12);
deque.add(18);        
deque.addFirst(22);
deque.add(24);

// let us print all the elements available in deque
for (Integer number : deque) {
    System.out.println("Number = " + number);
}

预期的产出是:

Number = 22
Number = 20
Number = 30
Number = 18
Number = 24
Number = 12

但实际输出是:

Number = 22
Number = 20
Number = 30
Number = 12
Number = 18
Number …

我试图在下面的“while”循环中擦除双端队列中的多个元素，但我的程序没有给出正确的结果。

问题背景：

packet_deque包含 9 个Packet对象 - 其中一些已发送，其他未发送。

#include <deque> 
#include <iostream> 

class Packet
{
public:
    void set_sent() { sent = true; };
    bool get_sent() { return sent; };
private:
    /* members of Test class */
    bool sent = false;
};

int main()
{ 
    size_t MAX = 9;
    std::deque<Packet> packet_deque(MAX);
    unsigned int i = 0;

    std::deque<Packet>::iterator itr = packet_deque.begin();
    printf("Before erasing sent packets - packet_dequeue size: %d \n", packet_deque.size());
    // initialise the packet queue - creating some sent …