Java LinkedList Help?

Question

I am new at Java LinkedList and I was wondering if it is possible to traverse a LinkedList backwards. And if so, how?

Answer 1

Assuming you refer to the java.util.LinkedList class, you can use LinkedList.get(int) to traverse the list backward:

for (int i=myLinkedList.size()-1; i>=0; --i)
Object o = myLinkedList.get(i);

Traditionally, most linked lists can be traversed forwards only efficiently, because each element contains a forward pointer to the next element but not a backward pointer to the previous. (To traverse backward, you'd have to walk N steps from the head of the list, then N-1 the next time, then N-2, etc.) A linked list that has pointers both forward and backward can be traversed in either direction efficiently, and is called a "doubly linked list."

Since the java.util.LinkedList implementation is done under the umbrella of the List interface, it supports all of the List methods (like get(int index)) and you can traverse it however you want.

http://en.wikipedia.org/wiki/Linked_list

Answer 2

List test = new LinkedList();
test.add("value in link list");

for(int i = test.size()-1; i >= 0; i--){
test.get(i);
}

:)

Answer 3

particular you may! You do could keep in mind that each and each physique you have carried out is tell the compiler which you have a hyperlink record of ArrayList. there is no ArrayList interior the hyperlink record as yet. good success!

Answer 4

public class DoublyLinkedList {
private Link first;

private Link last;

public DoublyLinkedList() {
first = null;
last = null;
}

public boolean isEmpty(){
return first == null;
}

public void insertFirst(long dd){
Link newLink = new Link(dd);

if (isEmpty())
last = newLink;
else
first.previous = newLink;
newLink.next = first;
first = newLink;
}

public void insertLast(long dd){
Link newLink = new Link(dd);
if (isEmpty())
first = newLink;
else {
last.next = newLink;
newLink.previous = last;
}
last = newLink;
}

public Link deleteFirst(){
Link temp = first;
if (first.next == null)
last = null;
else
first.next.previous = null;
first = first.next;
return temp;
}

public Link deleteLast(){
Link temp = last;
if (first.next == null)
first = null;
else
last.previous.next = null;
last = last.previous;
return temp;
}

public boolean insertAfter(long key, long dd) {
Link current = first;
while (current.dData != key){
current = current.next;
if (current == null)
return false; // cannot find it
}
Link newLink = new Link(dd); // make new link

if (current == last) // if last link,
{
newLink.next = null;
last = newLink;
} else // not last link,
{
newLink.next = current.next;

current.next.previous = newLink;
}
newLink.previous = current;
current.next = newLink;
return true; // found it, insert
}

public Link deleteKey(long key){
Link current = first;
while (current.dData != key)
{
current = current.next;
if (current == null)
return null; // cannot find it
}
if (current == first) // found it; first item?
first = current.next;
else
current.previous.next = current.next;

if (current == last) // last item?
last = current.previous;
else
// not last
current.next.previous = current.previous;
return current; // return value
}

public void displayForward() {
System.out.print("List (first to last): ");
Link current = first; // start at beginning
while (current != null) // until end of list,
{
current.displayLink();
current = current.next; // move to next link
}
System.out.println("");
}

public void displayBackward() {
System.out.print("List : ");
Link current = last;
while (current != null){
current.displayLink();
current = current.previous;
}
System.out.println("");
}

public static void main(String[] args) {
DoublyLinkedList theList = new DoublyLinkedList();

theList.insertFirst(22);
theList.insertFirst(44);
theList.insertLast(33);
theList.insertLast(55);

theList.displayForward();
theList.displayBackward();

theList.deleteFirst();
theList.deleteLast();
theList.deleteKey(11);

theList.displayForward();

theList.insertAfter(22, 77); // insert 77 after 22
theList.insertAfter(33, 88); // insert 88 after 33

theList.displayForward();
}

}

class Link {
public long dData; // data item

public Link next; // next link in list

public Link previous; // previous link in list

public Link(long d)
{
dData = d;
}

public void displayLink(){
System.out.print(dData + " ");
}

}

======================
output
---------- java ----------
List (first to last): 44 22 33 55
List : 55 33 22 44
List (first to last): 22 33
List (first to last): 22 77 33 88

Output completed (1 sec consumed) - Normal Termination
=========================================

for theory part
http://www.cs.cornell.edu/~rugina/papers/vmcai07.pdf

Answer 5

bubba try this link

http://www.leepoint.net/notes-java/data/collections/lists/simple-linked-list.html