标签: circular-list

如何找到循环队列中的项目数？

|前 - 后| 并不总是有效.

是否有一个方程式可以知道循环队列中有多少元素？

因此,如果我想构建一个n 0和1 1的循环列表,以下哪种方式更好/更便宜？还有更好/更便宜的方式吗？考虑到n是一个Integer并且可能很大(尽管实际上它不会超过2 ^ 32).

aZerosAndOnes :: Integer -> [Int]
aZerosAndOnes n 
    | n >= 0    = cycle (genericReplicate n 0 ++ [1])
    | otherwise = []

与

bZerosAndOnes :: Integer -> [Int]
bZerosAndOnes n 
    | n >= 0    = tail (cycle (1 : genericReplicate n 0))
    | otherwise = []

我想将给定的函数（特别是 np.std()）应用于测量数组，并且我想将其应用于给定大小的滚动窗口。

但是 - 由于测量是在圆形阵列中 - 我还需要滚动窗口能够从阵列末端重叠到其开头。

因此，我无法在 Numpy 中的 1D 数组滚动窗口中使用答案？...我尝试修改它的方法，但我不是 numpy 专家，我无法理解 np.lib.stride_tricks.as_strided 的作用（它的文档在哪里？？？）

因此，如果我有一个列表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': {...}}

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

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

我有一个创建循环列表的功能,我有编译问题,不确定它是否是语法,如果有人可以提供帮助,请欣赏.

    void CreateCircularList(struct node** listRef, struct node** tailRef)

    {    
    Push(&*listRef, "String 1");
    *tailRef=*listRef;
    Push(&*listRef, "String 2");
    Push(&*listRef, "String 3");
    Push(&*listRef, "String 4");

    *(tailRef->next)=*listRef;

    } 

编译器在最后一行标记错误:

"成员引用基类型'结构节点*'不是结构或联合"

有什么想法吗？谢谢

我是一个更新鲜的人,我在最近的一次采访中被问到了这个问题.

问题是--- 通过遍历链表的每个元素只需查看单个链表是否在任何点都是循环的.

对此我回答说,我们将在遍历另一个链表中的列表时存储每个节点的引用,并且对于正在测试的列表中的每个节点,我们将查找列表中是否存在引用存储引用.

采访者说他需要一种更优化的方法来解决这个问题.

任何人都可以告诉我什么是更优化的方法来解决这个问题.

PS:在任何一点我都是圆形的,我的意思是这个.http://s22.postimg.org/g0iwevfnl/2013_06_30_15_56_34_362.jpg

我遇到了一个被称为Great Tree-List问题的有趣问题.问题如下:

在有序二进制树中,每个节点包含一个数据元素和指向子树的" 小 "和" 大 "指针."小"子树中的所有节点都小于或等于父节点中的数据."大"子树中的所有节点都大于父节点.而一个循环双向链表包括以前和未来的指针.

问题是采用一个有序的二叉树并重新排列内部指针,从而形成一个循环的双向链表." 小 "指针应扮演" 前一个 " 的角色," 大 "指针应扮演" 下一个 " 的角色.应该安排列表,以便节点按递增顺序排列.我必须写一个递归函数并将头指针返回到新列表.

操作应在O(n)时间内完成.

我知道递归将沿着树,但如何递归地将小型和大型子树更改为列表,我还必须将这些列表与父节点一起追加.

我应该如何处理这个问题？我只需要一个方向来解决问题!

假设我有一个这样的列表:

my_list = [A, B, C, D, E, F, G]

实际上,我使用我的列表就像一个循环.这意味着在G有之后A,之前A有之G.

我想知道例如B和之间的最短距离是多少F.

显然,答案是3因为F -> G -> A -> B比短B -> C -> D -> E -> F.

计算这种距离的"pythonic"方法是什么？

到目前为止,我觉得非常难看(假设我知道索引):

def distance(len_my_list, idx_1, idx_2):
    right = max(idx_1, idx_2)
    left = min(idx_1, idx_2)
    dist_1 = right - left
    dist_2 = (len_my_list - right) + left
    return min(dist_1, dist_2)

我一直在使用Common-lisp(SBCL)中的循环列表,并在尝试调用REDUCE这样的列表时遇到以下问题.

首先,我们创建一个列表:

CL-USER> (defvar *foo* (list 1 1 1 1))
*foo*

当然,现在我们可以做到

CL-USER> (reduce #'+ *foo*)
4

要么

CL-USER> (reduce #'+ *foo* :end 3)
3

但是,如果我们创建一个循环列表:

CL-USER> (setf *print-circle* t)
CL-USER> (setf (cdr (last *foo*)) *foo*)
CL-USER> *foo*
#1=(1 1 1 1 . #1#)

显然(reduce #'+ *foo*)现在永远不会回来.

但是当我尝试的时候

 CL-USER> (reduce #'+ *foo* :end 3)
 ...

我也有一个无限循环.

为什么会这样？有没有办法解决这个问题,而没有明确使用循环结构,如LOOP或DO？我正在使用SBCL,但尝试使用其他实现(CLISP,ECL),它们都有同样的问题.

我有一个列表列表，其中包含角度集的下限和上限

就像是

[[1,22],[2,24]...[359,15],[360,21]]

总共360个元素

现在我想检查从 1 到 360 的每个角度，列表中包含该角度的元素

我正在考虑使用下限和上限来使用rangeor创建列表的所有元素np.arange(lower,upper)并检查是否包含角度，但当np.arangelower 高于 upper 时会生成空列表

for i in range(1,361):
    sel=[]
    for coe in coef:
        if i in range(coe[0],coe[1]):
            sel.append(coe)

我也尝试过itertoolsandcycle但我不知道如何在这种情况下应用它