标签: circular-list

是否存在链表类型结构的名称,其中头部和尾部节点相互链接？在这样的列表中,您显然可以永远地遍历它,因为它会自动加倍.

我正在尝试制作一个循环的单链表.我希望能够修改我的代码以获得一个单独喜欢的列表但我遇到了一些麻烦.

对于我的链表,我有:

class Link (object):
  def __init__ (self, data, next = None):
    self.data = data
    self.next = next


class LinkedList(object):
  def __init__(self):
    self.first = None

  def __str__(self):
    a = "["
    current = self.first
    while current != None:
      a += str(current.data) + ', ' 
      current = current.next
    a = a[:-2] + ']'  
    return a  

  def __iter__(self):
    current = self.first
    a = []
    while current != None:
      a += [current.data]
      current = current.next
    return iter(a)

  def __len__ (self):
    current = self.first
    a …

有没有人有一个使用C#非常简单地实现循环链​​接列表的例子？

我有这个链表但我不知道怎么做特别的:

    public class LinkedList
    {
        public class Node
        {
            public Node next;
            public Object data;
        }

        private Node head;

        public void Add(Object data)
        {
            Node toAdd = new Node();
            toAdd.data = data;
            Node current = head;                
            current.next = toAdd;
        }

    }

谢谢.

是否可以在erlang中定义循环列表？ http://en.wikipedia.org/wiki/Linked_list

第一个问题是循环列表在erlang中的意思是什么？它有两个元素,一个元素是它自己,旁边的元素是否存放在下一个元素中,存储在一个列表中？

如果是这样我可以说有可能在erlang中定义循环列表.但我需要澄清天气是我认为循环列表是在erlang？

我对Haskell中的循环/无限列表感兴趣.我读到了let..in语句和where子句,我觉得他们有重要的部分可以玩,但我仍然没有得到它.

具体来说,我已经编写了三个版本的代码,用于交替0和1的无限列表.我认为这就是Haskell中循环列表的含义.

cyclic = let x = 0 : y 
             y = 1 : x
         in x

cyclic' = [0,1] ++ cyclic'

cyclic'' = [0,1] ++ x
    where x = cyclic''

第二个对我来说似乎最简单,最短,最自然,但也许那是因为我对let..in和while仍然不太满意.

所有这三个列表都表示相同的方式吗？

我正在写一个小型的战略游戏,但我在实现循环链​​表方面存在问题.

游戏涉及几个人一个接一个地采取行动,直到比赛结束.我可以通过使用循环链表来完成,其中每个元素都是一个引用下一个玩家的玩家.结构是这样的:

#[derive(Debug, Clone)]
struct Player {
    name: String,
    killed: bool,
    next: Option<Box<Player>>,
}

我还想要一个指向当前活动播放器的指针并能够修改它的状态,但我认为Rust不允许我对同一个对象有两个可变引用,因为每个播放器已经有一个对下一个播放器的可变引用.

我想出的是,我可以使用一个简单的可变引用,该引用Box由其之前的播放器拥有并指向当前播放器.我写了一个简单的main函数,出现问题:

fn main() {
    let mut p3: Player = Player {
        name: "C".to_string(),
        killed: false,
        next: None,
    };
    let mut p2: Player = Player {
        name: "B".to_string(),
        killed: false,
        next: Some(unsafe { Box::from_raw(&mut p3) }),
    };
    let mut p1: Player = Player {
        name: "A".to_string(),
        killed: false,
        next: Some(unsafe { Box::from_raw(&mut p2) }),
    };
    p3.next = Some(unsafe { Box::from_raw(&mut p1) });
    println!("GAME STARTED!"); …

我正在尝试使用 OCaml 类型声明来实现一个循环双向链表。这是我所拥有的：

type 'a cList = 
{ 
mutable value : 'a; 
mutable left : 'a cList option; 
mutable right : 'a cList option 
}
;;

当我需要声明包含单个元素的第一个列表时，问题就出现了。因为元素在被赋值之前不能被引用，所以我不能让单元格的左右成员指向它自己。到目前为止，我唯一的解决方法是允许左右成员为 option 类型，将它们设置为 None 然后修改它们，使它们指向单元格本身。

let unitClist v = let a = {
                      value = v; 
                      left = None; 
                      right = None
                      }
              in
              a.left <- Some a; 
              a.right <- Some a;
              a
;;

它可以工作，但是当您确定有一个值时，必须使用选项类型有点绑定。有没有更好的方法来做到这一点？提前致谢。

在Scheme / Lisp中，我尝试创建一个将列表转换为循环列表的函数。因此，我相信我需要构造一个无限的流，其中列表的尾部指向列表的头部。

到目前为止，这是我的代码：

(define (rotate-list l1 l1copy)
  (if (null? (force (cdr l1)))
      (cons (car l1) (delay l1copy)))
      (cons (car l1) (delay (rotate-list (force (cdr l1)) l1copy))))

非常感谢所有帮助。

我的任务是实现一个返回Thue-Morse序列的函数.我通过原始递归完成了它,但现在我必须使用循环列表(使用列表理解),并且当我调用它时它必须返回它:

>take 4 thueSeq
[[0],[0,1],[0,1,1,0],[0,1,1,0,1,0,0,1]]

这是我(可怕的)实施尝试:

> thueSeq = 0: [x | x <- zipWith (mod) (tail thueSeq) [1] ]

我立即意识到这是错误的(头部应该是[0],而不是0)但是写作[0] ++ [0,1] ++ ...并没有返回列表列表.

我的问题是,首先,我怎么"开始"与列表[[0],[0,1]],因为从我所用的圆形表看到,他们有基础的情况下,然后通过递归.其次,我的列表理解试图适用(mod x 1)于每个值,但这也是错误的,因为它[[0,1]]会变成[[0,1,0]]而不是[[0,1,1,0]].所以我想我必须将它应用于列表中的每个其他元素(第1个元素,第3个,第5个等)？

我正在尝试创建一个函数来测试给定列表是否为循环,重新起始点是列表的开头.

预期成绩:

(setq liste '(a b c))
(rplacd (cddr liste) liste)

(circular liste) => t
(circular '(a b c a b c)) => nil  

因为我只是想测试任何后续项目是否为第一个'eq',我不想构建整个乌龟和野兔算法.

这是我的代码:

(defun circular (liste)
    (let (beginningliste (car liste)))
    (labels ( (circ2 (liste)
      (cond
        ((atom liste) nil)
        ((eq (car liste) beginningliste) t)
        (t (circ2 (cdr liste)))
        ) ) ) ) )

1. 它没有给出预期的结果,但我不明白我的错误在哪里
2. 我不确定我是否正确使用'标签'
3. 有没有办法在不使用'标签'的情况下做到这一点？

编辑.我想我已经回答了我的第三个问题,因为我觉得我找到了一个更简单的方法.这会有用吗？

(defun circular (liste)
   (cond
      ((atom liste) nil)
      ((eq (car liste) (cadr liste)) t)
      (t  (circular (rplacd liste  (cddr liste)))) …