Singly-linked list/Element definition: Difference between revisions

=={{header|Ada}}==

 

type Link_Access is access Link;

type Link is record

Next : Link_Access := null;

Data : Integer;

 

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

);</pre>

=={{header|C}}==

struct link *next;

int data;

 

=={{header|C++}}==

The simplest C++ version looks basically like the C version:

 

{

link* next;

int data;

 

Initialization of links on the heap can be simplified by adding a constructor:

 

{

link* next;

int data;

link(int a_data, link* a_next = 0): next(a_next), data(a_data) {}

 

With this constructor, new nodes can be initialized directly at allocation; e.g. the following code creates a complete list with just one statement:

 

 

However, C++ also allows to make it generic on the data type (e.g. if you need large numbers, you might want to use a larger type than int, e.g. long on 64-bit platforms, long long on compilers that support it, or even a bigint class).

 

{

link* next;

T data;

link(T a_data, link* a_next = 0): next(a_next), data(a_data) {}

 

Note that the generic version works for any type, not only integral types.

Generic template-based node element.

 

public:

T data;

Node next;

this(T d, Node n = null) { data=d; next=n; }

 

=={{header|Delphi}}==

=={{header|E}}==

 

def empty implements LinkedListStamp {

to null() { return true }

}

return link

 

=={{header|Forth}}==

=={{header|Fortran}}==

In ISO Fortran 95 or later:

real :: data

type( node ), pointer :: next => null()

!. . . .

!

 

=={{header|Haskell}}==

An equivalent declaration for such a list type without the special syntax would look like this:

 

 

A declaration like the one required in the task, with an integer as element type and a mutable link, would be

 

 

but that would be really awkward to use.

The simplest Java version looks basically like the C++ version:

 

{

Link next;

int data;

 

Initialization of links on the heap can be simplified by adding a constructor:

 

{

Link next;

int data;

Link(int a_data, Link a_next) { next = a_next; data = a_data; }

 

With this constructor, new nodes can be initialized directly at allocation; e.g. the following code creates a complete list with just one statement:

 

 

{{works with|Java|1.5+}}

However, Java also allows to make it generic on the data type. This will only work on reference types, not primitive types like int or float (wrapper classes like Integer and Float are available).

 

{

Link<T> next;

T data;

Link(T a_data, Link<T> a_next) { next = a_next; data = a_data; }

 

=={{header|Logo}}==

An equivalent declaration for such a list type without the special syntax would look like this:

 

 

A declaration like the one required in the task, with an integer as element type and a mutable link, would be

 

 

but that would be really awkward to use.

 

However, if all you got is an algorithm in a foreign language, you can use references to accomplish the translation.

data => 'say what',

next => \%foo_node,

);

 

=={{header|Pop11}}==

=={{header|Ruby}}==

 

attr_accessor :value, :succ

def initialize(v,s=nil)

end

include Enumerable

 

=={{header|Scheme}}==