Singly-linked list/Traversal: Difference between revisions

Traverse from the beginning of a singly-linked list to the end.

 

=={{header|ActionScript}}==

See [[Singly-Linked List (element)#ActionScript|Singly-Linked List (element) in ActionScript]]

//...

for(var i:Node = A; i != null; i = i.link)

{

doStuff(i);

=={{header|Ada}}==

The Ada standard container library provides a doubly-linked list. List traversal is demonstrated for the forward links.

 

with Ada.Text_Io; use Ada.Text_Io;

 

-- Traverse the list, calling Print for each value

The_List.Iterate(Print'access);

 

=={{header|ALGOL 68}}==

book examples. Or can be manually constructed, eg:

 

STRINGLIST list := ("Big",

 

REF STRINGLIST node := list;

print((value OF node, space));

node := next OF node

OD;

=={{header|AutoHotkey}}==

a_next = b

b = 2

name := %name% . "_next"

}

 

=={{header|C}}==

See [[Singly-Linked List (element)#C|Singly-Linked List (element) in C]].

// ...

struct link *iter;

for(iter = first; iter != NULL; iter = iter->next) {

// access data, e.g. with iter->data

 

=={{header|C sharp|C#}}==

 

=={{header|Clojure}}==

 

=={{header|Common Lisp}}==

 

 

Not using builtin list iteration:

 

until (null ref)

 

=={{header|D}}==

 

 

 

import tango.util.collection.LinkSeq;

 

m.append("charlie");

foreach (val; m)

 

 

 

 

while (linkedList =~ [value, next]) {

println(value)

linkedList := next

 

Using a list made from the structure defined at [[Singly-Linked List (element)#E|Singly-Linked List (element)]]:

 

while (!(linkedList.null())) {

println(linkedList.value())

linkedList := linkedList.next()

 

=={{header|Factor}}==

[ [ data>> ] dip call ]

[ [ next>> ] dip over [ list-each ] [ 2drop ] if ] 2bi ; inline recursive

[ B <linked-list> list-insert ] keep

 

<pre>

A

C

</pre>

 

=={{header|Forth}}==

And here is a function to walk a list, calling an XT on each data cell:

>r begin ?dup while

dup cell+ @ r@ execute

 

Testing code:

A ' emit walk <em>ABC ok</em>

 

=={{header|Haskell}}==

Lists are ubiquitous in Haskell, simply use Haskell's <em>map</em> library function:

 

map (++ "s") ["Apple", "Orange", "Mango", "Pear"] -- ["Apples","Oranges","Mangos","Pears"]

traverse :: [a] -> [a]

traverse list = map func list

 

Note that the <em>traverse</em> function is polymorphic; denoted by <em>traverse :: [a] -> [a]</em> where <em>a</em> can be of any type.

 

 

Using the implementation mentioned at [[Singly-Linked List (element)#J|Singly-Linked List (element) in J]], we can apply a function <tt>foo</tt> to each node the following way:

 

=={{header|Java}}==

{{works with|Java|1.5+}}

For Java.util.LinkedList<T>, use a for each loop (from [[Loop Structures]]):

 

for(Type i: list){

//each element will be in variable "i"

System.out.println(i);

 

=={{header|JavaScript}}==

Extending [[Singly-Linked_List_(element)#JavaScript]]

func(this);

if (this.next() != null)

 

var head = createLinkedListFromArray([10,20,30,40]);

Uses the <code>print()</code> function from [[Rhino]]

 

=={{header|Logo}}==

LAST is already a Logo built-in, but it could be defined this way:

if empty? bf :list [output first :list]

output last bf :list

 

 

 

for(current=first_of_the_list; current != nil; current = [current next] )

{

// to get the "datum":

// id dat_obj = [current datum];

 

=={{header|OCaml}}==

List.iter print_endline li ;;

big

waltz

nymph

 

=={{header|PicoLisp}}==

We might use map functions

or flow control functions

<pre>a

"cde"

999</pre>

 

 

"""USELESS academic/classroom example of a linked list implemented in Python.

Don't ever consider using something this crude! Use the built-in list() type!

for value in lst:

print value,;

<pre>

big fjords vex quick waltz nymph

</pre>

 

=={{header|Ruby}}==

referring to [[Singly-Linked List (element)#Ruby]] and [[Singly-Linked List (element insertion)#Ruby]]

head.insertAfter("b", "b+")

 

print current.value, ","

end while current = current.succ

<pre>a,b,b+,c,

a,b,b+,c,</pre>

 

=={{header|Scala}}==

 

 

}

 

=={{header|Scheme}}==

(if (null? seq)

 

=={{header|Tcl}}==

Using the class definition from [[Singly-Linked List (element)#Tcl|Singly-Linked List (element)]] (and bearing in mind the general notes on lists given there) we'll modify that class so that lists have an iteration method...

{{works with|Tcl|8.6}}

method for {varName script} {

upvar 1 $varName var

}

}

Now, a demonstration...

foreach n {1 3 5 7 2 4 6 8} {

set list [List new $n $list]

$list for x {

puts "we have a $x in the list"

 

=={{header|Trith}}==

 

=={{header|Visual Basic .NET}}==

Dim node = list.First

Do Until node Is Nothing

node = node.Next