Doubly-linked list/Element definition: Difference between revisions
Content added Content deleted
(Added Java example.) |
m (→{{header|Java}}: Formatting.) |
||
Line 31: | Line 31: | ||
=={{header|Java}}== |
=={{header|Java}}== |
||
'''Compiler''': [[Java]] 1.5+ |
|||
public class Node<T> { |
public class Node<T> { |
||
private T element; |
private T element; |
||
Node<T> next, prev; |
Node<T> next, prev; |
||
public Node<T>(){ |
public Node<T>(){ |
||
next = prev = element = null; |
next = prev = element = null; |
||
} |
} |
||
public Node<T>(n, p, elem){ |
public Node<T>(n, p, elem){ |
||
next = n; |
next = n; |
||
Line 45: | Line 45: | ||
element = elem; |
element = elem; |
||
} |
} |
||
public void setNext(Node<T> n){ |
public void setNext(Node<T> n){ |
||
next = n; |
next = n; |
||
} |
} |
||
public Node<T> getNext(){ |
public Node<T> getNext(){ |
||
return next; |
return next; |
||
} |
} |
||
public void setElem(T elem){ |
public void setElem(T elem){ |
||
element = elem; |
element = elem; |
||
} |
} |
||
public T getElem(){ |
public T getElem(){ |
||
return element; |
return element; |
||
} |
} |
||
public void setNext(Node<T> n){ |
public void setNext(Node<T> n){ |
||
next = n; |
next = n; |
||
} |
} |
||
public Node<T> setPrev(Node<T> p){ |
public Node<T> setPrev(Node<T> p){ |
||
prev = p; |
prev = p; |
||
} |
} |
||
public getPrev(){ |
public getPrev(){ |
||
return prev; |
return prev; |
||
Line 76: | Line 76: | ||
For use with [[Java]] 1.4 and below, delete all "<T>"s and replace T's with "Object". |
For use with [[Java]] 1.4 and below, delete all "<T>"s and replace T's with "Object". |
||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
Just use an array. You can traverse and splice it any way. Linked lists are way too low level. |
Just use an array. You can traverse and splice it any way. Linked lists are way too low level. |
Revision as of 14:35, 14 December 2007
Doubly-linked list/Element definition
You are encouraged to solve this task according to the task description, using any language you may know.
You are encouraged to solve this task according to the task description, using any language you may know.
Define the data structure for a doubly-linked list element. The element should include a data member to hold its value and pointers to both the next element in the list and the previous element in the list. The pointers should be mutable.
Ada
type Link; type Link_Access is access Link; type Link is record Next : Link_Access := null; Prev : Link_Access := null; Data : Integer; end record;
Ada's standard container library includes a generic doubly linked list. The structure of the link element is private.
ALGOL 68
MODE LINK = STRUCT ( REF LINK next, REF LINK prev, INT data ); LINK example; ~
C
struct link ( struct link *next; struct link *prev; int data; );
Java
Compiler: Java 1.5+
public class Node<T> { private T element; Node<T> next, prev; public Node<T>(){ next = prev = element = null; } public Node<T>(n, p, elem){ next = n; prev = p; element = elem; } public void setNext(Node<T> n){ next = n; } public Node<T> getNext(){ return next; } public void setElem(T elem){ element = elem; } public T getElem(){ return element; } public void setNext(Node<T> n){ next = n; } public Node<T> setPrev(Node<T> p){ prev = p; } public getPrev(){ return prev; } }
For use with Java 1.4 and below, delete all "<T>"s and replace T's with "Object".
Perl
Just use an array. You can traverse and splice it any way. Linked lists are way too low level.
However, if all you got is a algorithm in a foreign language, you can use references to accomplish the translation.
my %node = ( data => 'say what', next => \%foo_node, prev => \%bar_node, ); $node{next} = \%quux_node; # mutable
Pop11
uses objectclass; define :class Link; slot next = []; slot prev = []; slot data = []; enddefine;
Ruby
class ListNode attr_accessor :val, :nxt, :prv def initialize(mval,mprv=nil,mnxt=nil) self.val=mval self.prv=mprv prv.nxt=self if prv self.nxt=mnxt nxt.prv=self if nxt end def each(&b) yield val nxt.each(&b) if nxt self end include Enumerable end
Python
class Node(object): def __init__(self, data = None, prev = None, next = None): self.prev = prev self.next = next self.data = data def __str__(self): return str(self.data) def __repr__(self): return repr(self.data) def iter_forward(self): c = self while c != None: yield c c = c.next def iter_backward(self): c = self while c != None: yield c c = c.prev