circular-list

I have graph class that looks like: class Graph { public: typedef unsigned int size_type; typedef std::list<size_type> Neighbours; protected: size_type m_nodes_count, m_edges_count; public: Graph(size_type nodes_count = 0) : m_nodes_count(nodes_count), m_edges_count(0) {} virtual bool is_edge(size_type from, size_type to) = 0; virtual Neighbours neighbours(size_type node) = 0; virtual Graph& add_edge(size_type from, size_type to) = 0; virtual void delete_edge(size_type from, size_type to) = 0; size_type nodes_count() { return m_nodes_count; } size_type edges_count() { return m_edges_count; }

Closed . This question needs to be more focused . It is not currently accepting answers. Want to improve this question? Update the question so it focuses on one problem only by editing this post . Closed 11 months ago . How would I go about iterating through a list from 1-100, where I delete every other element starting with the first element, and repeat that step until there in only one element left in the list. Would I have to use a circular linked list, or can it be done just using loops and conditional statements? If you assume the circular list structure, when the last element of the list

Here is my attempt: 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) The problem comes when trying to do anything with x; causing x to be evaluated starts off a circular evaluation going through x, y, z and ends in a stack overflow. Is there a way of specifying that val a should be computed lazily? You need to make A.a itself lazy. You can do it by turning it into a by name parameter that is used to initialize a lazy field: class A(a0: => A, val b: Int){ lazy val a = a0 override def toString() = b

Referencing @dfeuer's answer to this question: Least expensive way to construct cyclic list in Haskell , which says that using cyclic lists 'defeats' the garbage collector as it has to keep everything you've consumed from a cyclic list allocated till you drop the reference to any cons cells in the list. Apparently in Haskell a cyclic list and an infinite list are two separate things. This blog ( https://unspecified.wordpress.com/2010/03/30/a-doubly-linked-list-in-haskell/ ) says that if you implement cycle as follows: cycle xs = xs ++ cycle xs it is an infinite list, not a cyclic list. To make

I want a simple yet efficient circular buffer/queue. If I use std::vector , I have to do this: if ( v.size() >= limit ) { std::vector<int> it = v.begin(); v.insert( it, data ); v.erase( it+1 ); } Is there any simpler solution? You want to maintain the size of the buffer, overwriting older items. Just overwrite the old ones as time goes on. If you want to deal with the case where nItems < limit, then you would need to deal with that, this is just a simple example of using modulo to insert into a fixed size buffer. std::vector<int> data(10); for (int i = 0 ; i < 100 ; ++i) { data[i%10] = i; }