我使用泛型在java中创建了一个链表,现在我希望能够迭代列表中的所有元素.在C#中,我将yield return在链表中使用,同时浏览列表中包含的元素列表.

我如何创建上面的java版本,我可以迭代链表中包含的所有项目？

我希望能够编写代码ala

LinkedList<something> authors = new LinkedList<something>();
for (Iterator<something> i = authors.Values ; i.HasNext())
      doSomethingWith(i.Value);

并且认为价值'属性'/方法将包含类似的代码

LinkedListObject<something> current = first;
While (current != null){
 yield return current.getValue();
 current = current.getNext()
}

编辑:请注意,我对使用任何第三方API不感兴趣.仅内置java功能.

对于一个简单的链表,其中不需要随机访问列表元素,是否有任何显着的优势(性能或其他)使用std::list而不是std::vector？如果需要向后遍历,那么在迭代其元素之前使用std::slist和reverse()列表会更有效吗？

背景

我创建了一个主要用于学习目的的基本链表数据结构.该列表的一个目标是它可以处理不同的数据结构.因此,我已尝试在结构组合中模拟C中的"继承".以下是构成我的链表的基础的结构.

typedef struct Link {
    struct Link* next;
    struct Link* prev;
} Link;

typedef Link List;

在我的实现中,我选择了一个作为列表头部和尾部的Sentinel节点(这就是Link == List的原因).

为了使列表实际处理数据,结构只包含Link结构作为第一个成员:

typedef struct {
    Link link;
    float data;
} Node;

所以链表看起来像这样.

         ?????????????     ?????????     ?????????????     
... <--->? P ? N ? D ?<--->? P ? N ?<--->? P ? N ? D ?<---> ... 
         ?????????????     ?????????     ?????????????
         End Node          myList        First Node

List myList;
Node node1 = {{}, 1.024};
....
Node nodeN = {{}, 3.14};

list_init(&myList) // myList.next = &myList; myList.prev …

正如标题所示,我想知道LinkedList类中的size()方法是否需要分摊O(1)时间或O(n)时间.

如何用纯函数式语言编写双向链表？也就是说,像Haskell这样的东西,你不在Monad,所以你没有变异.可能吗？(单链表很明显很简单).

我试图比较堆栈和队列操作的增长率(运行时和空间),当实现为数组和链接列表时.到目前为止,我只能找到队列pop()的平均案例运行时间,但没有全面探索这两个数据结构并比较它们的运行时/空间行为.

具体地讲,我想找比较push()和pop()用于两个队列和堆栈,作为实现两个阵列和链表(因此2次操作×2种结构×2个实施方式中,或8个值).

另外,我会欣赏这两者的最佳,平均和最差情况值,以及与它们消耗的空间量有关的任何事情.

我能找到的最接近的是"所有cs作弊表的母亲"pdf,这显然是高级算法和离散函数的主人或博士级备忘单.

我只是在寻找一种方法来确定何时何地应该使用基于数组的实现与基于列表的堆栈和队列实现.

有没有人知道一个算法来查找链表是否只使用两个变量来遍历列表.假设您有一个链接的对象列表,它与哪种类型的对象无关.我在一个变量中有一个指向链表头部的指针,我只有一个其他变量来遍历列表.

所以我的计划是比较指针值以查看是否有任何指针相同.该列表的大小有限,但可能很大.我可以将两个变量都设置为头部,然后用另一个变量遍历列表,总是检查它是否等于另一个变量,但是,如果我确实打了一个循环,我将永远不会离开它.我认为它与遍历列表和比较指针值的不同速率有关.有什么想法吗？

下面的两个代码示例都在链接列表的顶部添加了一个节点.但是,第一个代码示例使用双指针,而第二个代码示例使用单个指针

代码示例1:

struct node* push(struct node **head, int data)
{
        struct node* newnode = malloc(sizeof(struct node));
        newnode->data = data;
        newnode->next = *head;
        return newnode;
}

push(&head,1);

代码示例2:

struct node* push(struct node *head, int data)
{
        struct node* newnode = malloc(sizeof(struct node));
        newnode->data = data;
        newnode->next = head;
        return newnode;
}

push(head,1)

两种策略都有效.但是,许多使用链表的程序使用双指针来添加新节点.我知道双指针是什么.但是如果单个指针足以添加新节点,为什么很多实现都依赖于双指针？

有没有一个指针不起作用的情况所以我们需要去一个双指针？

我理解链接列表的定义,但它如何表示并与一个共同的概念或项目相关？

例如,OOP中的组合(EDIT:最初称为'继承')可以与汽车相关.现实生活中的所有(大多数)汽车都是基本相同的东西; 汽车有一个引擎,你可以启动()它,你可以使汽车go(),停止()等.汽车通常具有最大乘客容量,但在公共汽车和SportsCar之间会有所不同,它们都是汽车.

是否有一些现实生活,直观的例子,就像我们继承的那样,单一链接列表？典型的教科书链接列表示例显示了一个带有整数和指向下一个节点的节点,它似乎不太有用.

感谢您的意见.

我看了一些面试问题,在网上关于你如何发现是否有一个链表一环,和解决方案(Floyd的循环查找算法)是有两个指针,一个是比其他快2倍,并检查他们再次相遇.

我的问题是:为什么我不能只保持一个指针固定,只是每次将另一个指针向前移动1步？