标签: circular-list

我想创建一个循环/循环链表,其中列表的尾部将指向列表的头部.因此,我可以java.util.LinkedList在创建列表后使用和修改尾节点以使其成为循环/循环吗？如果是这样,你能告诉我一些如何发生的代码吗？

如果我不能使用java.util.LinkedList,我应该如何创建自己的循环/循环链表实现？你能告诉我这个实现的外观吗？

如果您需要更多详细信息,请告诉我,我会清除任何困惑.

我想要一个简单而有效的循环缓冲区/队列.如果我使用std::vector,我必须这样做:

if ( v.size() >= limit ) {
    std::vector<int> it = v.begin();
    v.insert( it, data );
    v.erase( it+1 );
}

有没有更简单的解决方案？

我有兴趣以这样的方式迭代列表,我可以从任何位置开始并遍历整个列表,直到最后,然后循环回到开头并迭代到起始位置.

让我们说我想为一个保证4个元素的数组做这个:char array [4] = {'a','b','c','d'}

我在构造for循环时遇到困难,以至于我可以从'a'开始,循环abcd,或从'b'开始,循环bcda,或从d开始,循环dabc等.

我认为for循环的初始部分类似于i = startingPosition.

我认为for循环的增量部分将类似于i =(i + 1)%4.这样,从索引2开始,例如,将上升到3,然后是0,然后是1,等等.

中间"终止"条件应该是什么？

for(i = startingPosition; ???; i = (i+1)%4)

谢谢!

我有数据以环形结构(或循环缓冲区)排列,也就是说它可以表示为循环的序列:...- 1-2-3-4-5-1-2-3 -... .看到这张图片,了解一个5部分的戒指:

我想创建一个窗口查询,可以将滞后和铅项目组合成一个三点数组,但我无法弄清楚.例如,在5部分环的第1部分,滞后/超前序列是5-1-2,或者部分4是3-4-5.

这是一个两个环的示例表,它们具有不同数量的部件(每个环总是多于三个):

create table rp (ring int, part int);
insert into rp(ring, part) values(1, generate_series(1, 5));
insert into rp(ring, part) values(2, generate_series(1, 7));

这是一个几乎成功的查询:

SELECT ring, part, array[
    lag(part, 1, NULL) over (partition by ring),
    part,
    lead(part, 1, 1) over (partition by ring)
    ] AS neighbours
FROM rp;

 ring | part | neighbours
------+------+------------
    1 |    1 | {NULL,1,2}
    1 |    2 | {1,2,3}
    1 |    3 | {2,3,4}
    1 |    4 | {3,4,5} …

我知道如何创建Link和LinearLinkedList类,但我不能为我的生活弄清楚如何将它们修改为创建循环链接列表.我已经阅读了这个问题的答案:帮助Python中的循环链接列表.但是,我不明白如果头是None,那么None-type对象如何具有"next"属性？我似乎无法掌握这个概念.如果有人可以向我展示示例CircularLinkedList 的init函数以及关于它如何工作的简单解释,我想我能够理解它.感谢您的帮助

编辑:我只需要向前遍历列表.如果是这样的话,它背后的逻辑是否需要彻底改变？

环形缓冲区和循环链接列表有什么区别？

环形缓冲区服务于循环链接列表的目的是什么,反之亦然？

valgrind告诉我,XX块中有XX个字节,肯定会丢失记录等等

而来源是malloc,但是,我认为这是因为我没有为malloc释放足够的内存.无论如何,我提供了我认为导致堆错误的代码.

我知道我没有释放list_remove中的内存,我很确定这是问题的唯一来源.它可能需要一些临时转移,但我不知道这是否是唯一的问题.

list_t *list_remove(list_t *list, list_t *node) {
    list_t *oldnode = node;
    node->prev->next = node->next;
    node->next->prev = node->prev;
    if (list != oldnode) {
        free(oldnode);
        return list;
    } else {
         list_t *value = list->next == list ? NULL : list->next;
     free(oldnode);
        return value;
    }
}

void list_free(list_t *list) {
    if (list) {
       while (list_remove(list, list_last(list)) != NULL) {}
    } 
}

list last只是给出列表的最后一个节点.

编辑:我很抱歉没有提供足够的信息,Kerrek SB,alk.这是代码的其余部分,因为你可以看到malloc出现在newnode中,我可以在那里开始创建新列表.结构很简单,有一个值和一个prev,下一个:

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "ll.h"

struct list {
    char *value;
    struct list *next; …

这是我的尝试:

case class A(val a: A, val b: Int){
    override def toString() = b.toString
}

lazy val x: A = A(y, 0)
lazy val y: A = A(z, 1)
lazy val z: A = A(x, 2)

尝试用x做任何事情时出现问题; 导致x被评估的开始是通过x,y,z的循环评估,并以堆栈溢出结束.有没有办法指定应该懒惰地计算val？

它非常常见,我遇到了一些元素列表,xs并希望对每个第N个元素做一些事情.最简单的例子是Sieve或Erastothenes,你想要"敲掉"给定素数的每一个倍数.我可以这样做的两种方法是通过计数器变量传递显式递归; 或zipWith ($) (cycle (replicate (n-1) id ++ f)).那么哪种方式更好/更优雅/更常用,或者是否有一些mapEveryN :: (a -> a) -> Int -> [a] -> [a]我没有找到的库函数？

因此，如果我有一个列表a并附a加到它，我将得到一个包含它自己的引用的列表。

>>> a = [1,2]
>>> a.append(a)
>>> a
[1, 2, [...]]
>>> a[-1][-1][-1]
[1, 2, [...]]

这基本上会导致看似无限的递归。

不仅在列表中，在字典中也是如此：

>>> b = {'a':1,'b':2}
>>> b['c'] = b
>>> b
{'a': 1, 'b': 2, 'c': {...}}

这可能是将列表存储在最后一个元素中并修改其他元素的好方法，但这不会起作用，因为在每个递归引用中都会看到更改。

我明白为什么会发生这种情况，即由于它们的可变性。但是，我对这种行为的实际用例很感兴趣。有人可以启发我吗？