我必须实现一个自制的Trie,我被困在Iterator部分.我似乎无法弄清楚trie的增量方法.
我希望有人能帮助我解决问题.
这是Iterator的代码:
template <typename T> class Trie<T>::IteratorPrefixe{
friend class Trie<T>;
public:
IteratorPrefixe() : tree(NULL), currentNode(NULL), currentKey("") {};
pair<string, T*> operator*() {return make_pair(currentKey, currentNode -> element);} ;
IteratorPrefixe operator++()throw(runtime_error);
void operator=(IteratorPrefixe iter) {tree = iter.tree; currentNode = iter.currentNode; currentKey = iter.currentKey;};
bool operator==(IteratorPrefixe iter) {return tree == iter.tree && currentNode == iter.currentNode;};
bool operator!=(IteratorPrefixe iter) {return tree != iter.tree || currentNode != iter.currentNode;};
private:
Trie<T> * tree;
Trie<T> * currentNode;
string currentKey;
};
这是我的特里:
template <typename T> class Trie { …只给出一个std :: string迭代器,是否可以确定字符串的起点和终点？假设我无法访问字符串对象,因此无法调用string.begin()和string.end(),我所能做的就是递增或递减迭代器并测试值.
谢谢,菲尔
我有一个std :: deque,我想在指定的索引处插入一个元素(我知道std :: list会更好).deque :: insert()函数使用迭代器指定要插入的位置.给定一个索引,如何获得指向该位置的迭代器,以便我可以将该迭代器传递给insert()？
例如:
void insertThing ( deque<Thing> & things, Thing thing, size_t index )
{
deque<Thing>::iterator it = /* what do I do here? */
things.insert ( it, thing );
}
我确信这是一个非常基本的问题,我为此道歉.自从我使用STL已经有很长一段时间了,我在std :: deque的成员列表中看不到任何显然符合我想要的东西.谢谢.
k = [1,2,3,4,5]
for n in k
puts n
if n == 2
k.delete(n)
end
end
puts k.join(",")
# Result:
# 1
# 2
# 4
# 5
# [1,3,4,5]
# Desired:
# 1
# 2
# 3
# 4
# 5
# [1,3,4,5]
其他数组迭代器,k.each也会发生同样的效果:
k = [1,2,3,4,5]
k.each do |n|
puts n
if n == 2
k.delete(n)
end
end
puts k.join(",")
具有相同的输出.
这种情况发生的原因非常清楚...... Ruby实际上并没有迭代存储在数组中的对象,而只是将它变成一个漂亮的数组索引迭代器,从索引0开始,每次都增加索引直到它结束.但是当你删除一个项目时,它仍然会增加索引,所以它不会两次评估相同的索引,这是我想要的.
这可能不是正在发生的事情,但这是我能想到的最好的.
有干净的方法吗？是否已有可以执行此操作的内置迭代器？或者我是否需要弄脏并执行数组索引迭代器,并且在删除项目时不会增加？(或遍历数组的克隆,并从原始数组中删除)
澄清
我不只是想从数组中删除项目; 对不起,如果那是清楚的.我想要做的是遍历每个元素,并"处理"它; 此过程有时可能会删除它.为了更准确:
class Living_Thing
def initialize tracker,id
@tracker = …我正在制作一个产生大量数据的C++ 11类.该数据目前来自数据库,并不能完全适合内存.我想为用户提供一个迭代器,其行为类似于常规的STL迭代器,但这将是懒惰的.更准确地说,我可以做类似的事情:
for (auto& item : big_bunch_of_data) {
do_stuff_with(item);
}
仅在每次迭代时从数据库中检索项目.如果我是对的,这个新语法就是糖
for (stuff::iterator it = big_bunch_of_data.begin();it != big_bunch_of_data.end();it++) {
do_stuff_with(*it);
}
这是否意味着通过提供begin,end并且operator++,我可以有所期望的行为？而且,这些方法应该做什么？我的意思是,我可以让他们懒惰而不破坏东西吗？
for k,v in targets.iteritems():
price= str(v['stockprice'])
Bids = str(u''.join(v['OtherBids']))
Bids = Bids.split(',')
# create a list of unique bids by ranking
for a, b in zip(float(price), Bids):
try:
del b[next(i for i, e in enumerate(b) if format(e, '.4f') == a)]
except StopIteration:
pass
我从我的字典中提取数据,但似乎所有这些都是unicode.我怎么能摆脱unicode废话？
我想在python中迭代一个闭合范围的整数[a,b],即.从a到b迭代,包括a和b.
我知道以下方法:
for i in range(a, b+1):
do_something(i)
为了反向迭代(即按b,b-1,b-2,...,a的顺序),我执行以下操作:
for i in range(b, a-1, -1):
do_something(i)
我不喜欢这个加法(在示例中为b + 1)和减法(在示例中为a-1)以达到范围的闭合端.我发现它的可读性低于c/c ++/Java对应物(<=在循环中的使用).
你有没有python中的东西可以用于在封闭范围之间迭代而无需人工干预边界？
我有一个问题,很可能之前就是这样问的,因为我认为我想要的东西是很多人想要的.但是,我无法想出任何方式表达它会返回我想要的搜索(不是谷歌,不是这里).所以这里的答案可能只是用来描述我的意思的单个术语.
我想要实现的是大致如下的内容:
它可以采用仿函数struct/class,并根据仿函数的函数为所述仿函数生成一系列值.应该可以使用有状态仿函数,即应该可以在状态a中实例化仿函数并使其运行直到它处于状态b,生成值范围{f(a),f(a + 1) ,...,f(b)},其中f(a + 1)表示由f表示的系列中的下一个项目.
它的行为类似于迭代器,即它可以传递而不是迭代器,例如用值填充向量.
我认为名称应该是生成器或生成迭代器,因为它就是它的作用,但是我在查找具有该术语的内容时非常失败.我已经编写了自己的实现,但它有它的问题,我想问一下,如果有更多的努力之前有这样的事情.
为了节省你粘贴所有后续代码的工作,以防你想尝试这个,我把它放在ideone上.我认为在运行代码后很清楚它的作用.
我当前的实现看起来像这样(fyi这是一个缩短的版本,其中有些东西像 - 和 - 缺失,所以我确实实现了它们,因此它至少可以作为双向迭代器工作.我也有一个[]函数,所以我想把它变成random_access.):
template <class F>
class generator{
public:
//typedefs required for iterator-use
typedef typename F::value_type value_type;
typedef typename F::step_type step_type;
typedef value_type * pointer;
typedef value_type & reference;
typedef typename F::size_type size_type;
typedef typename F::difference_type difference_type;
typedef std::bidirectional_iterator_tag iterator_category;
generator(value_type init, step_type step) : t(init), step(step){}
generator<F> &operator++() {
t += step; return *this;
}
generator<F> &
operator+=(size_type n)
{
t += n * …我有一个功能:
void get_good_items(const std::vector<T>& data,std::vector<XXX>& good_items);
这个函数应该检查所有资料后,发现满足条件和回报的项目,他们是在good_items.
什么是最好的而不是std::vector<XXX>？
std::vector<size_t> 包含所有好的指数.std::vector<T*> 包含指向项目的指针.std::vector<std::vector<T>::iterator> 包含项目的迭代器.编辑:
我该good_items怎么办？很多事情......其中之一是从矢量中删除它们并将它们保存在其他地方.也许晚些时候
编辑2:
对我来说最重要的一点是如何data根据结构来快速访问项目good_items？
编辑3:
我刚才认为我的想法是错的.保持原始指针(或智能)作为向量的项目不是更好,所以我可以保持向量的实际值(这是指针),我不怕重复,因为它们只是指针？
从python3到Julia,人们希望能够将快速迭代器编写为具有yield/yield语法的函数或类似的东西.
Julia的宏似乎暗示可以构建一个宏,将这种"生成器"函数转换为julia迭代器.[它甚至看起来你可以很容易地内联函数风格的迭代器,这是Iterators.jl包也尝试为其特定的迭代器提供的功能https://github.com/JuliaCollections/Iterators.jl#the-itr- macro-for-automatic-inlining-in-for-loops ]
只是举个例子来说明我的想法:
@asiterator function myiterator(as::Array)
b = 1
for (a1, a2) in zip(as, as[2:end])
try
@produce a1[1] + a2[2] + b
catch exc
end
end
end
for i in myiterator([(1,2), (3,1), 3, 4, (1,1)])
@show i
end
myiterator理想情况下应该在哪里创建一个尽可能低开销的快速迭代器.当然,这只是一个具体的例子.理想情况下,我想拥有适用于所有或几乎所有发电机功能的东西.
目前推荐的将生成器函数转换为迭代器的方法是通过Julia的任务,至少据我所知.然而,它们似乎也比纯粹的迭代器慢.例如,如果你可以用简单的迭代器表示你的函数imap,chain等等(由Iterators.jl包提供),这似乎是非常可取的.
在julia理论上是否有可能将生成器类型的宏转换为灵活的快速迭代器？
额外问题:如果可能的话,是否有一个通用宏可以内联这样的迭代器？