Traversing a List
How do I traverse a list?
For example, in the following linked list -
(0, hello), (7, bye-bye) (8, today) where 0, 7 and 8 are unique identifiers and they have associated values- how do I move from position 0 to position just before (8,today) ?
how can you think of storing key vale pairs in a linked list?if it is a map, then ya have lot of methods.please refer to the java Docs
Similar Messages
-
Traversing var of type List List String
hello all,
i hope someone can help me with this little problem.
im still a newbie on java devt.
the problem is, i have retrieved some records from a database
and i am trying to display it on a table. but i am having some issues
with traversing the info returned to me, which is of type List<List<String>>.
im using SWT by the way.
here is the code snippet of my function:
================================
* Displays the search result on the table
* @param searchResult - search result returned after db query
public void populateTable (List<List<String>> searchResult) {
logger_.debug("===SearchView::populateTable()=== - START");
logger_.debug("searchResult received: " + searchResult.toString());
//traverse rows
List <String> row = new ArrayList<String>();
for (int i = 0; i < searchResult.size(); ++i) {
row = searchResult.get(i);
logger_.debug("row value: " + row);
if ( (row != null) && (!row.isEmpty()) ) {
//get row attribs
String custId = row.get(0);
String custName = row.get(1);
String custAdd = row.get(2);
String custContact = row.get(10);
String custPhone = row.get(11);
TableItem tableItem = new TableItem(searchTable_, SWT.NONE);
tableItem.setText( new String[] { custId, custName, custAdd, custContact, custPhone } );
logger_.debug("===SearchView::populateTable()=== - END");
================================
thanks,
doods* Displays the search result on the table
* @param searchResult
public void populateTable (List<List<String>> searchResult) {
logger_.debug("===SearchView::populateTable()=== - START");
logger_.debug("searchResult received " + searchResult.toString());
logger_.debug("searchResult.size() = " + searchResult.size());
//traverse rows
List <String> row = new ArrayList<String>();
for (int i = 0; i < searchResult.size(); ++i) {
row = searchResult.get(i);
logger_.debug("row value: " + row);
if ( (row != null) && (!row.isEmpty()) ) {
//get row attribs
String custId = row.get(0);
String custName = row.get(1);
String custAdd = row.get(2);
String custContact = row.get(10);
String custPhone = row.get(11);
TableItem tableItem = new TableItem(searchTable_, SWT.NONE);
tableItem.setText( new String[] { custId, custName, custAdd, custContact, custPhone } );
// Iterator <List<String>> iter = searchResult.iterator();
// List <String> row = new ArrayList<String>();
// while (iter.hasNext()) {
// row = iter.next();
// String custId = row.get(0);
// String custName = row.get(1);
// String custAdd = row.get(2);
// String custContact = row.get(10);
// String custPhone = row.get(11);
// logger_.debug(row.toString());
// logger_.debug(row.size());
// TableItem tableItem = new TableItem(searchTable_, SWT.NONE);
// tableItem.setText( new String[] { custId, custName, custAdd, custContact, custPhone } );
logger_.debug("===SearchView::populateTable()=== - END");
}sorry bout the code formatting.
i have already tried using the iterator but it doesn't work.
is this the right way to use the iterator?
i commented it out already.
basically, the searchResult returns 3 rows,
when i try to print the records on the table, it displays 3 rows
but the info on those 3 rows are all from the first row.
ex: row1 = doods, 123, aaa
row2 = doodies, 333, bbb
row3 = doodles, 444, ccc
whats printed on the table:
doods, 123, aaa
doods, 123, aaa
doods, 123, aaa -
Splitting a Linked List at a Given Node, into Two Sublists??
My code just will not work!! Any help would be appreciated! My problem is in the last method SplitAt. These are the conditions set and my code:
Splitting a Linked List at a Given Node, into Two Sublists
a. Add the following as an abstract method to the class
LinkedListClass:
public void splitAt (LinkedListClass<T> secondList, T item);
//This method splits the list at the node with the info item into two sublists.
//Precondition: The list must exist.
//Postcondition: first and last point to the first and last nodes of the first sublist,
// respectively. secondList.first and secondList.last point to the first
// and last nodes of the second sublist.
Consider the following statements:
UnorderedLinkedList<Integer> myList;
UnorderedLinkedList<Integer> otherList;
Suppose myList points to the list with the elements 34, 65, 18, 39, 27, 89, and 12 (in this order). The statement
myList.splitAt(otherList, 18);
splits myList into two sublists: myList points to the list with elements 34 and 65, and otherList points to the sublist with elements 18, 39, 27, 89, and 12.
b. Provide the definition of the method splitAt in the class UnorderedLinkedList. Also write a program to test your method.
public class UnorderedLinkedList<T> extends LinkedListClass<T>
//Default constructor
public UnorderedLinkedList()
super();
//Method to determine whether searchItem is in
//the list.
//Postcondition: Returns true if searchItem is found
// in the list; false otherwise.
public boolean search(T searchItem)
LinkedListNode<T> current; //variable to traverse
//the list
boolean found;
current = first; //set current to point to the first
//node in the list
found = false; //set found to false
while (current != null && !found) //search the list
if (current.info.equals(searchItem)) //item is found
found = true;
else
current = current.link; //make current point to
//the next node
return found;
//Method to insert newItem in the list.
//Postcondition: first points to the new list
// and newItem is inserted at the
// beginning of the list. Also,
// last points to the last node and
// count is incremented by 1.
public void insertFirst(T newItem)
LinkedListNode<T> newNode; //variable to create the
//new node
newNode =
new LinkedListNode<T>(newItem, first); //create and
//insert newNode before
//first
first = newNode; //make first point to the
//actual first node
if (last == null) //if the list was empty, newNode is
//also the last node in the list
last = newNode;
count++; //increment count
//Method to insert newItem at the end of the list.
//Postcondition: first points to the new list and
// newItem is inserted at the end
// of the list. Also, last points to
// the last node and
// count is incremented by 1.
public void insertLast(T newItem)
LinkedListNode newNode; //variable to create the
//new node
newNode =
new LinkedListNode(newItem, null); //create newNode
if (first == null) //if the list is empty, newNode is
//both the first and last node
first = newNode;
last = newNode;
else //if the list is not empty, insert
//newNode after last
last.link = newNode; //insert newNode after last
last = newNode; //set last to point to the
//actual last node
count++;
}//end insertLast
//Method to delete deleteItem from the list.
//Postcondition: If found, the node containing
// deleteItem is deleted from the
// list. Also, first points to the first
// node, last points to the last
// node of the updated list, and count
// is decremented by 1.
public void deleteNode(T deleteItem)
LinkedListNode<T> current; //variable to traverse
//the list
LinkedListNode<T> trailCurrent; //variable just
//before current
boolean found;
if ( first == null) //Case 1; the list is empty
System.err.println("Cannot delete from an empty "
+ "list.");
else
if (first.info.equals(deleteItem)) //Case 2
first = first.link;
if (first == null) //the list had only one node
last = null;
count--;
else //search the list for the given info
found = false;
trailCurrent = first; //set trailCurrent to
//point to the first node
current = first.link; //set current to point to
//the second node
while (current != null && !found)
if (current.info.equals(deleteItem))
found = true;
else
trailCurrent = current;
current = current.link;
}//end while
if (found) //Case 3; if found, delete the node
count--;
trailCurrent.link = current.link;
if (last == current) //node to be deleted
//was the last node
last = trailCurrent; //update the value
//of last
else
System.out.println("Item to be deleted is "
+ "not in the list.");
}//end else
}//end else
}//end deleteNode
public void splitAt(LinkedListClass<T> secondList, T item)
LinkedListNode<T> current;
LinkedListNode<T> trailCurrent;
int i;
boolean found;
if (first==null)
System.out.println("Empty.");
first=null;
last=null;
count--;
else
current=first;
found=false;
i=1;
while(current !=null &&!found)
if(current.info.equals(secondList))
found= true;
else
trailCurrent=current;
i++;
if(found)
if(first==current)
first=first;
last=last;
count=count;
count=0;
else
first=current;
last=last;
last=null;
count = count- i+1;
count = i-1;
else
System.out.println("Item to be split at is "
+ "not in the list.");
first=null;
last=null;
count=0;
}I dont have a test program at all. The program is supposed to prompt for user input of numbers. (it does) Take the input and end at input of -999 (it does). Then it asks user where it wants to split list (it does). When I enter a number it does nothing after that. I am going to post updated code and see if that helps along with all the classes. Thanks!
This is the class to prompt:
import java.util.*;
public class Ch16_ProgEx6
static Scanner console = new Scanner(System.in);
public static void main(String[] args)
UnorderedLinkedList<Integer> list
= new UnorderedLinkedList<Integer>();
UnorderedLinkedList<Integer> subList =
new UnorderedLinkedList<Integer>();
Integer num;
System.out.println("Enter integers ending with -999.");
num = console.nextInt();
while (num != -999)
list.insertLast(num);
num = console.nextInt();
System.out.println();
System.out.println("list: ");
list.print();
System.out.println();
System.out.println("Length of list: " + list.length());
System.out.print("Enter the number at which to split list: ");
num = console.nextInt();
list.splitAt(subList, num);
System.out.println("Lists after splitting list");
System.out.print("list: ");
list.print();
System.out.println();
System.out.println("Length of list: " + list.length());
System.out.print("sublist: ");
subList.print();
System.out.println();
System.out.println("Length of sublist: " + subList.length());
}This is the ADT:
public interface LinkedListADT<T> extends Cloneable
public Object clone();
//Returns a copy of objects data in store.
//This method clones only the references stored in
//each node of the list. The objects that the
//list nodes point to are not cloned.
public boolean isEmptyList();
//Method to determine whether the list is empty.
//Postcondition: Returns true if the list is empty;
// false otherwise.
public void initializeList();
//Method to initialize the list to an empty state.
//Postcondition: The list is initialized to an empty
// state.
public void print();
//Method to output the data contained in each node.
public int length();
//Method to return the number of nodes in the list.
//Postcondition: The number of nodes in the list is
// returned.
public T front();
//Method to return a reference of the object containing
//the data of the first node of the list.
//Precondition: The list must exist and must not be empty.
//Postcondition: The reference of the object that
// contains the info of the first node
// is returned.
public T back();
//Method to return a reference of object containing
//the data of the last node of the list.
//Precondition: The list must exist and must not be empty.
//Postcondition: The reference of the object that
// contains the info of the last node
// is returned.
public boolean search(T searchItem);
//Method to determine whether searchItem is in the list.
//Postcondition: Returns true if searchItem is found
// in the list; false otherwise.
public void insertFirst(T newItem);
//Method to insert newItem in the list.
//Postcondition: newItem is inserted at the
// beginning of the list.
public void insertLast(T newItem);
//Method to insert newItem at the end of the list.
//Postcondition: newItem is inserted at the end
// of the list.
public void deleteNode(T deleteItem);
//Method to delete deleteItem from the list.
//Postcondition: If found, the node containing
// deleteItem is deleted from the
// list.
public void splitAt(LinkedListClass<T> secondList, T item);
}This is the linked list class:
import java.util.NoSuchElementException;
public abstract class LinkedListClass<T> implements LinkedListADT<T>
protected class LinkedListNode<T> implements Cloneable
public T info;
public LinkedListNode<T> link;
//Default constructor
//Postcondition: info = null; link = null;
public LinkedListNode()
info = null;
link = null;
//Constructor with parameters
//This method sets info pointing to the object to
//which elem points to and link is set to point to
//the object to which ptr points to.
//Postcondition: info = elem; link = ptr;
public LinkedListNode(T elem, LinkedListNode<T> ptr)
info = elem;
link = ptr;
//Returns a copy of objects data in store.
//This method clones only the references stored in
//the node. The objects that the nodes point to
//are not cloned.
public Object clone()
LinkedListNode<T> copy = null;
try
copy = (LinkedListNode<T>) super.clone();
catch (CloneNotSupportedException e)
return null;
return copy;
//Method to return the info as a string.
//Postcondition: info as a String object is
// returned.
public String toString()
return info.toString();
} //end class LinkedListNode
public class LinkedListIterator<T>
protected LinkedListNode<T> current; //variable to
//point to the
//current node in
//list
protected LinkedListNode<T> previous; //variable to
//point to the
//node before the
//current node
//Default constructor
//Sets current to point to the first node in the
//list and sets previous to null.
//Postcondition: current = first; previous = null;
public LinkedListIterator()
current = (LinkedListNode<T>) first;
previous = null;
//Method to reset the iterator to the first node
//in the list.
//Postcondition: current = first; previous = null;
public void reset()
current = (LinkedListNode<T>) first;
previous = null;
//Method to return a reference of the info of the
//current node in the list and to advance iterator
//to the next node.
//Postcondition: previous = current;
// current = current.link;
// A refrence of the current node
// is returned.
public T next()
if (!hasNext())
throw new NoSuchElementException();
LinkedListNode<T> temp = current;
previous = current;
current = current.link;
return temp.info;
//Method to determine whether there is a next
//element in the list.
//Postcondition: Returns true if there is a next
// node in the list; otherwise
// returns false.
public boolean hasNext()
return (current != null);
//Method to remove the node currently pointed to
//by the iterator.
//Postcondition: If iterator is not null, then the
// node that the iterator points to
// is removed. Otherwise the method
// throws NoSuchElementException.
public void remove()
if (current == null)
throw new NoSuchElementException();
if (current == first)
first = first.link;
current = (LinkedListNode<T>) first;
previous = null;
if (first == null)
last = null;
else
previous.link = current.link;
if (current == last)
last = first;
while (last.link != null)
last = last.link;
current = current.link;
count--;
//Method to return the info as a string.
//Postcondition: info as a String object is returned.
public String toString()
return current.info.toString();
} //end class LinkedListIterator
//Instance variables of the class LinkedListClass
protected LinkedListNode<T> first; //variable to store the
//address of the first
//node of the list
protected LinkedListNode<T> last; //variable to store the
//address of the last
//node of the list
protected int count; //variable to store the number of
//nodes in the list
//Default constructor
//Initializes the list to an empty state.
//Postcondition: first = null, last = null,
// count = 0
public LinkedListClass()
first = null;
last = null;
count = 0;
//Method to determine whether the list is empty.
//Postcondition: Returns true if the list is empty;
// false otherwise.
public boolean isEmptyList()
return (first == null);
//Method to initialize the list to an empty state.
//Postcondition: first = null, last = null,
// count = 0
public void initializeList()
first = null;
last = null;
count = 0;
//Method to output the data contained in each node.
public void print()
LinkedListNode<T> current; //variable to traverse
//the list
current = first; //set current so that it points to
//the first node
while (current != null) //while more data to print
System.out.print(current.info + " ");
current = current.link;
}//end print
//Method to return the number of nodes in the list.
//Postcondition: The value of count is returned.
public int length()
return count;
//Method to return a reference of the object containing
//the data of the first node of the list.
//Precondition: The list must exist and must not be empty.
//Postcondition: The reference of the object that
// contains the info of the first node
// is returned.
public T front()
return first.info;
//Method to return a reference of object containing
//the data of the last node of the list.
//Precondition: The list must exist and must not be empty.
//Postcondition: The reference of the object that
// contains the info of the last node
// is returned.
public T back()
return last.info;
//Returns a copy of objects data in store.
//This method clones only the references stored in
//each node of the list. The objects that the
//list nodes point to are not cloned.
public Object clone()
LinkedListClass<T> copy = null;
try
copy = (LinkedListClass<T>) super.clone();
catch (CloneNotSupportedException e)
return null;
//If the list is not empty clone each node of
//the list.
if (first != null)
//Clone the first node
copy.first = (LinkedListNode<T>) first.clone();
copy.last = copy.first;
LinkedListNode<T> current;
if (first != null)
current = first.link;
else
current = null;
//Clone the remaining nodes of the list
while (current != null)
copy.last.link =
(LinkedListNode<T>) current.clone();
copy.last = copy.last.link;
current = current.link;
return copy;
//Method to return an iterator of the list.
//Postcondition: An iterator is instantiated and
// returned.
public LinkedListIterator<T> iterator()
return new LinkedListIterator<T>();
//Method to determine whether searchItem is in
//the list.
//Postcondition: Returns true if searchItem is found
// in the list; false otherwise.
public abstract boolean search(T searchItem);
//Method to insert newItem in the list.
//Postcondition: first points to the new list
// and newItem is inserted at the
// beginning of the list. Also,
// last points to the last node and
// count is incremented by 1.
public abstract void insertFirst(T newItem);
//Method to insert newItem at the end of the list.
//Postcondition: first points to the new list and
// newItem is inserted at the end
// of the list. Also, last points to
// the last node and
// count is incremented by 1.
public abstract void insertLast(T newItem);
//Method to delete deleteItem from the list.
//Postcondition: If found, the node containing
// deleteItem is deleted from the
// list. Also, first points to the first
// node, last points to the last
// node of the updated list, and count
// is decremented by 1.
public abstract void deleteNode(T deleteItem);
public abstract void splitAt(LinkedListClass<T> secondList, T item);
}And this is the UnorderedLinked Class with the very last method the one being Im stuck on. The SplitAt Method.
public class UnorderedLinkedList<T> extends LinkedListClass<T>
//Default constructor
public UnorderedLinkedList()
super();
//Method to determine whether searchItem is in
//the list.
//Postcondition: Returns true if searchItem is found
// in the list; false otherwise.
public boolean search(T searchItem)
LinkedListNode<T> current; //variable to traverse
//the list
boolean found;
current = first; //set current to point to the first
//node in the list
found = false; //set found to false
while (current != null && !found) //search the list
if (current.info.equals(searchItem)) //item is found
found = true;
else
current = current.link; //make current point to
//the next node
return found;
//Method to insert newItem in the list.
//Postcondition: first points to the new list
// and newItem is inserted at the
// beginning of the list. Also,
// last points to the last node and
// count is incremented by 1.
public void insertFirst(T newItem)
LinkedListNode<T> newNode; //variable to create the
//new node
newNode =
new LinkedListNode<T>(newItem, first); //create and
//insert newNode before
//first
first = newNode; //make first point to the
//actual first node
if (last == null) //if the list was empty, newNode is
//also the last node in the list
last = newNode;
count++; //increment count
//Method to insert newItem at the end of the list.
//Postcondition: first points to the new list and
// newItem is inserted at the end
// of the list. Also, last points to
// the last node and
// count is incremented by 1.
public void insertLast(T newItem)
LinkedListNode newNode; //variable to create the
//new node
newNode =
new LinkedListNode(newItem, null); //create newNode
if (first == null) //if the list is empty, newNode is
//both the first and last node
first = newNode;
last = newNode;
else //if the list is not empty, insert
//newNode after last
last.link = newNode; //insert newNode after last
last = newNode; //set last to point to the
//actual last node
count++;
}//end insertLast
//Method to delete deleteItem from the list.
//Postcondition: If found, the node containing
// deleteItem is deleted from the
// list. Also, first points to the first
// node, last points to the last
// node of the updated list, and count
// is decremented by 1.
public void deleteNode(T deleteItem)
LinkedListNode<T> current; //variable to traverse
//the list
LinkedListNode<T> trailCurrent; //variable just
//before current
boolean found;
if ( first == null) //Case 1; the list is empty
System.err.println("Cannot delete from an empty "
+ "list.");
else
if (first.info.equals(deleteItem)) //Case 2
first = first.link;
if (first == null) //the list had only one node
last = null;
count--;
else //search the list for the given info
found = false;
trailCurrent = first; //set trailCurrent to
//point to the first node
current = first.link; //set current to point to
//the second node
while (current != null && !found)
if (current.info.equals(deleteItem))
found = true;
else
trailCurrent = current;
current = current.link;
}//end while
if (found) //Case 3; if found, delete the node
count--;
trailCurrent.link = current.link;
if (last == current) //node to be deleted
//was the last node
last = trailCurrent; //update the value
//of last
else
System.out.println("Item to be deleted is "
+ "not in the list.");
}//end else
}//end else
}//end deleteNode
public void splitAt(LinkedListClass<T> secondList, T item)
LinkedListNode<T> current;
LinkedListNode<T> trailCurrent;
int i;
boolean found;
if (first==null)
System.out.println("Empty.");
first=null;
last=null;
count--;
count=0;
else
current=first;
found=false;
i=1;
while(current !=null &&!found)
if(current.info.equals(item))
found= true;
else
trailCurrent=first;
current=first;
i++;
if(found)
if(first==current)
first.link=first;
last.link=last;
count--;
count=0;
else
first.link=current;
last.link=last;
last=null;
count = count- i+1;
count = i-1;
} else {
System.out.println("Item to be split at is "
+ "not in the list.");
first=null;
last=null;
count=0;
Any help or just advice would be fine. Im not the best at Java, better at VB. Am completely stumped! Thanks so much! -
Hi,
I need the below implementation in JAVA :
Scenario : Need to traverse once through all nodes of a tree
Input :
(i) Starting node of traversal
(ii) List of nodes in the Tree
(iii) Parent of all nodes, say, mapping like (each_node, list_of_its_parent) (OR) (each_node, list_of_its_child)
Eg TREE :
A___________________ F
| | | |
|__B | | |
| C D_____|
| |___
H | |
E G
In the above example
(node, child_list) :--
=============
(A, {B,C,D})
(B, {H})
(C, {E,G})
(F, {D})
In the above tree, if any node is given as the starting node, I need to traverse through the complete tree visiting all nodes once.
Please help,
Thanks
SamThat is not a tree;Does it matter? You can always traverse a DAG as a
tree can't you? The A in DAG means acyclic so a DAG
is always also a tree.Check the definitions before you reply please: a DAG
is not "aways also" a tree; no discussion about it. Don't confuse
matters.Who's confusing matters? You introduced the DAG so
you explain why and what consequences it has!No, I just gave a name to what the OP said: s/he didn't show a tree,
s/he showed a DAG; that's all I did.
So a DAG can not always be expanded to a tree? Is that what you're
saying?There's no 'expanding' here; A tree is a very restricted DAG instead.
kind regards,
JosAnd zip up please. Your fake intimacy isn't always wellcome.Stay out of this discussion then; easy as that: a) you lack the knowledge
to participate in this discussion and b) you don't like my friendly greetings,
so the best thing for you, and for this discussion, is that you stay out of it.
kind regards,
Jos -
Array of references to references to objects? Skip lists...
I'm trying to hammer out a SkipList ADT by tomorrow night. The structure of my SkipList is basically: A Skip list has a reference to the first SkipListNode. Each SkipListNode has an array of links, where a link of level 1 links to the next node that is at least level 1 (every node is at least level 1), and array of 2 links to the next node down the list that is at least that tall, etc. For the last tallest node in the list, it will have links that are null, as there are no nodes after it which can reach up to its higher level links.
My problem is that as I traverse the list looking for the insert position, I need to keep track of the taller links which may be 'cut-off' by the newly inserted node. Just as with a normal LinkedList, I would want to make the new node point to where these old links pointed, and point the old links to the new node. What I have been trying to do is build an array:
SkipListNode previousLinks[] = new SkipListNode[levelOfTallestNodeInSkipList];
As I traverse a SkipListNode, I over-write the previousLinks[i] with every level i link I encounter. For example say I'm in a level 5 node (currentNode) with key 15. I'm trying to inser key 17. I try the level 5 node's level 5 link and its null, so I would want to make previousLinks[5] = currentNode[5]. I then try currentNode's level 4 link, it's not null but it points to a node with key 47, which is past the insertion point for a node with key 17. So again, I want previousLinks[4] to REFER TO currentNode[4]. Etc, etc... I get down to currentNode's level 1 link and see it links to a node with key 16 and level 1. Ok, this is less than 17 so I make currentNode = key 16 node (which is lvl 1). Then I traverse currentNode's only link- a level 1 link- and see that it links to a node with key 18. BOOM: here's the insert point. I randomly select level 4 for the new node which will hold 17. This means that I will 'cut-off' the level four link of the node holding key 15. What I want to be able to do is:
/*connect new links to where old links point to*/
for (int k = 0; k < newNode.level; k++) {
if (k < current.level)
newNode.links[k] = previousLinks[k];
else
newNode.links[k] = null;
/*connect old links to newly created node*/
for (int k = 0;
k < Math.min(current.level, newNode.level); k++)
previousLinks[k] = newNode;
But this doesn't work. The previousLinks array seems to only hold the values which were copied from the earlier nodes, not references to the fields in the nodes which point further down the list. What I want is a C++ style array of pointers to fields in an object's array so that I can change where these fields point (refer).
I hope this post makes enough sense for someone to at least give me a clue... thanks.My skiplist implementation has a method to lookup a node. The resultant array of nodes has length the maximum height of the skiplist. At each level the array containes a reference to the node prior to the one I am looking for at that level. This allows me to patch all the relevant nodes when I add/remove an item to/from the skiplist.
My code might help give you the idea.
* Looks up the payload in the list returning an array
* of nodes that point to the element immediately before
* the desired element.
* @param target the node we are searching for
* @return and array of Nodes that are just prior to the
* node we are looking for.
private Node[] lookup(Node target)
Node[] update = new Node[MAX_HEIGHT+1];
int k = m_height;
Node p = m_header;
do
Node q = null;
while (((q = p.getNext(k) )!= null) && (m_comparator.lessThan(q, target))) p = q;
update[k] = p;
} while (--k >= 0);
return update;
} -
Can someone help with splitting a Linked List.??
Any help would be awesome!!!
My code just will not work!! Any help would be appreciated! My problem is in the last method SplitAt. These are the conditions set and my code:
Splitting a Linked List at a Given Node, into Two Sublists
a. Add the following as an abstract method to the class
LinkedListClass:
public void splitAt (LinkedListClass<T> secondList, T item);
//This method splits the list at the node with the info item into two sublists.
//Precondition: The list must exist.
//Postcondition: first and last point to the first and last nodes of the first sublist,
// respectively. secondList.first and secondList.last point to the first
// and last nodes of the second sublist.
Consider the following statements:
UnorderedLinkedList<Integer> myList;
UnorderedLinkedList<Integer> otherList;
Suppose myList points to the list with the elements 34, 65, 18, 39, 27, 89, and 12 (in this order). The statement
myList.splitAt(otherList, 18);
splits myList into two sublists: myList points to the list with elements 34 and 65, and otherList points to the sublist with elements 18, 39, 27, 89, and 12.
b. Provide the definition of the method splitAt in the class UnorderedLinkedList. Also write a program to test your method.
public class UnorderedLinkedList<T> extends LinkedListClass<T>
//Default constructor
public UnorderedLinkedList()
super();
//Method to determine whether searchItem is in
//the list.
//Postcondition: Returns true if searchItem is found
// in the list; false otherwise.
public boolean search(T searchItem)
LinkedListNode<T> current; //variable to traverse
//the list
boolean found;
current = first; //set current to point to the first
//node in the list
found = false; //set found to false
while (current != null && !found) //search the list
if (current.info.equals(searchItem)) //item is found
found = true;
else
current = current.link; //make current point to
//the next node
return found;
//Method to insert newItem in the list.
//Postcondition: first points to the new list
// and newItem is inserted at the
// beginning of the list. Also,
// last points to the last node and
// count is incremented by 1.
public void insertFirst(T newItem)
LinkedListNode<T> newNode; //variable to create the
//new node
newNode =
new LinkedListNode<T>(newItem, first); //create and
//insert newNode before
//first
first = newNode; //make first point to the
//actual first node
if (last == null) //if the list was empty, newNode is
//also the last node in the list
last = newNode;
count++; //increment count
//Method to insert newItem at the end of the list.
//Postcondition: first points to the new list and
// newItem is inserted at the end
// of the list. Also, last points to
// the last node and
// count is incremented by 1.
public void insertLast(T newItem)
LinkedListNode newNode; //variable to create the
//new node
newNode =
new LinkedListNode(newItem, null); //create newNode
if (first == null) //if the list is empty, newNode is
//both the first and last node
first = newNode;
last = newNode;
else //if the list is not empty, insert
//newNode after last
last.link = newNode; //insert newNode after last
last = newNode; //set last to point to the
//actual last node
count++;
}//end insertLast
//Method to delete deleteItem from the list.
//Postcondition: If found, the node containing
// deleteItem is deleted from the
// list. Also, first points to the first
// node, last points to the last
// node of the updated list, and count
// is decremented by 1.
public void deleteNode(T deleteItem)
LinkedListNode<T> current; //variable to traverse
//the list
LinkedListNode<T> trailCurrent; //variable just
//before current
boolean found;
if ( first == null) //Case 1; the list is empty
System.err.println("Cannot delete from an empty "
+ "list.");
else
if (first.info.equals(deleteItem)) //Case 2
first = first.link;
if (first == null) //the list had only one node
last = null;
count--;
else //search the list for the given info
found = false;
trailCurrent = first; //set trailCurrent to
//point to the first node
current = first.link; //set current to point to
//the second node
while (current != null && !found)
if (current.info.equals(deleteItem))
found = true;
else
trailCurrent = current;
current = current.link;
}//end while
if (found) //Case 3; if found, delete the node
count--;
trailCurrent.link = current.link;
if (last == current) //node to be deleted
//was the last node
last = trailCurrent; //update the value
//of last
else
System.out.println("Item to be deleted is "
+ "not in the list.");
}//end else
}//end else
}//end deleteNode
public void splitAt(LinkedListClass<T> secondList, T item)
LinkedListNode<T> current;
LinkedListNode<T> trailCurrent;
int i;
boolean found;
if (first==null)
System.out.println("Empty.");
first=null;
last=null;
count--;
else
current=first;
found=false;
i=1;
while(current !=null &&!found)
if(current.info.equals(secondList))
found= true;
else
trailCurrent=current;
i++;
if(found)
if(first==current)
first=first;
last=last;
count=count;
count=0;
else
first=current;
last=last;
last=null;
count = count- i+1;
count = i-1;
else
System.out.println("Item to be split at is "
+ "not in the list.");
first=null;
last=null;
count=0;
}Edited by: romeAbides on Oct 10, 2008 1:24 PMI dont have a test program at all. The program is supposed to prompt for user input of numbers. (it does) Take the input and end at input of -999 (it does). Then it asks user where it wants to split list (it does). When I enter a number it does nothing after that. I am going to post updated code and see if that helps along with all the classes. Thanks!
This is the class to prompt:
import java.util.*;
public class Ch16_ProgEx6
static Scanner console = new Scanner(System.in);
public static void main(String[] args)
UnorderedLinkedList<Integer> list
= new UnorderedLinkedList<Integer>();
UnorderedLinkedList<Integer> subList =
new UnorderedLinkedList<Integer>();
Integer num;
System.out.println("Enter integers ending with -999.");
num = console.nextInt();
while (num != -999)
list.insertLast(num);
num = console.nextInt();
System.out.println();
System.out.println("list: ");
list.print();
System.out.println();
System.out.println("Length of list: " + list.length());
System.out.print("Enter the number at which to split list: ");
num = console.nextInt();
list.splitAt(subList, num);
System.out.println("Lists after splitting list");
System.out.print("list: ");
list.print();
System.out.println();
System.out.println("Length of list: " + list.length());
System.out.print("sublist: ");
subList.print();
System.out.println();
System.out.println("Length of sublist: " + subList.length());
}This is the ADT:
public interface LinkedListADT<T> extends Cloneable
public Object clone();
//Returns a copy of objects data in store.
//This method clones only the references stored in
//each node of the list. The objects that the
//list nodes point to are not cloned.
public boolean isEmptyList();
//Method to determine whether the list is empty.
//Postcondition: Returns true if the list is empty;
// false otherwise.
public void initializeList();
//Method to initialize the list to an empty state.
//Postcondition: The list is initialized to an empty
// state.
public void print();
//Method to output the data contained in each node.
public int length();
//Method to return the number of nodes in the list.
//Postcondition: The number of nodes in the list is
// returned.
public T front();
//Method to return a reference of the object containing
//the data of the first node of the list.
//Precondition: The list must exist and must not be empty.
//Postcondition: The reference of the object that
// contains the info of the first node
// is returned.
public T back();
//Method to return a reference of object containing
//the data of the last node of the list.
//Precondition: The list must exist and must not be empty.
//Postcondition: The reference of the object that
// contains the info of the last node
// is returned.
public boolean search(T searchItem);
//Method to determine whether searchItem is in the list.
//Postcondition: Returns true if searchItem is found
// in the list; false otherwise.
public void insertFirst(T newItem);
//Method to insert newItem in the list.
//Postcondition: newItem is inserted at the
// beginning of the list.
public void insertLast(T newItem);
//Method to insert newItem at the end of the list.
//Postcondition: newItem is inserted at the end
// of the list.
public void deleteNode(T deleteItem);
//Method to delete deleteItem from the list.
//Postcondition: If found, the node containing
// deleteItem is deleted from the
// list.
public void splitAt(LinkedListClass<T> secondList, T item);
}This is the linked list class:
import java.util.NoSuchElementException;
public abstract class LinkedListClass<T> implements LinkedListADT<T>
protected class LinkedListNode<T> implements Cloneable
public T info;
public LinkedListNode<T> link;
//Default constructor
//Postcondition: info = null; link = null;
public LinkedListNode()
info = null;
link = null;
//Constructor with parameters
//This method sets info pointing to the object to
//which elem points to and link is set to point to
//the object to which ptr points to.
//Postcondition: info = elem; link = ptr;
public LinkedListNode(T elem, LinkedListNode<T> ptr)
info = elem;
link = ptr;
//Returns a copy of objects data in store.
//This method clones only the references stored in
//the node. The objects that the nodes point to
//are not cloned.
public Object clone()
LinkedListNode<T> copy = null;
try
copy = (LinkedListNode<T>) super.clone();
catch (CloneNotSupportedException e)
return null;
return copy;
//Method to return the info as a string.
//Postcondition: info as a String object is
// returned.
public String toString()
return info.toString();
} //end class LinkedListNode
public class LinkedListIterator<T>
protected LinkedListNode<T> current; //variable to
//point to the
//current node in
//list
protected LinkedListNode<T> previous; //variable to
//point to the
//node before the
//current node
//Default constructor
//Sets current to point to the first node in the
//list and sets previous to null.
//Postcondition: current = first; previous = null;
public LinkedListIterator()
current = (LinkedListNode<T>) first;
previous = null;
//Method to reset the iterator to the first node
//in the list.
//Postcondition: current = first; previous = null;
public void reset()
current = (LinkedListNode<T>) first;
previous = null;
//Method to return a reference of the info of the
//current node in the list and to advance iterator
//to the next node.
//Postcondition: previous = current;
// current = current.link;
// A refrence of the current node
// is returned.
public T next()
if (!hasNext())
throw new NoSuchElementException();
LinkedListNode<T> temp = current;
previous = current;
current = current.link;
return temp.info;
//Method to determine whether there is a next
//element in the list.
//Postcondition: Returns true if there is a next
// node in the list; otherwise
// returns false.
public boolean hasNext()
return (current != null);
//Method to remove the node currently pointed to
//by the iterator.
//Postcondition: If iterator is not null, then the
// node that the iterator points to
// is removed. Otherwise the method
// throws NoSuchElementException.
public void remove()
if (current == null)
throw new NoSuchElementException();
if (current == first)
first = first.link;
current = (LinkedListNode<T>) first;
previous = null;
if (first == null)
last = null;
else
previous.link = current.link;
if (current == last)
last = first;
while (last.link != null)
last = last.link;
current = current.link;
count--;
//Method to return the info as a string.
//Postcondition: info as a String object is returned.
public String toString()
return current.info.toString();
} //end class LinkedListIterator
//Instance variables of the class LinkedListClass
protected LinkedListNode<T> first; //variable to store the
//address of the first
//node of the list
protected LinkedListNode<T> last; //variable to store the
//address of the last
//node of the list
protected int count; //variable to store the number of
//nodes in the list
//Default constructor
//Initializes the list to an empty state.
//Postcondition: first = null, last = null,
// count = 0
public LinkedListClass()
first = null;
last = null;
count = 0;
//Method to determine whether the list is empty.
//Postcondition: Returns true if the list is empty;
// false otherwise.
public boolean isEmptyList()
return (first == null);
//Method to initialize the list to an empty state.
//Postcondition: first = null, last = null,
// count = 0
public void initializeList()
first = null;
last = null;
count = 0;
//Method to output the data contained in each node.
public void print()
LinkedListNode<T> current; //variable to traverse
//the list
current = first; //set current so that it points to
//the first node
while (current != null) //while more data to print
System.out.print(current.info + " ");
current = current.link;
}//end print
//Method to return the number of nodes in the list.
//Postcondition: The value of count is returned.
public int length()
return count;
//Method to return a reference of the object containing
//the data of the first node of the list.
//Precondition: The list must exist and must not be empty.
//Postcondition: The reference of the object that
// contains the info of the first node
// is returned.
public T front()
return first.info;
//Method to return a reference of object containing
//the data of the last node of the list.
//Precondition: The list must exist and must not be empty.
//Postcondition: The reference of the object that
// contains the info of the last node
// is returned.
public T back()
return last.info;
//Returns a copy of objects data in store.
//This method clones only the references stored in
//each node of the list. The objects that the
//list nodes point to are not cloned.
public Object clone()
LinkedListClass<T> copy = null;
try
copy = (LinkedListClass<T>) super.clone();
catch (CloneNotSupportedException e)
return null;
//If the list is not empty clone each node of
//the list.
if (first != null)
//Clone the first node
copy.first = (LinkedListNode<T>) first.clone();
copy.last = copy.first;
LinkedListNode<T> current;
if (first != null)
current = first.link;
else
current = null;
//Clone the remaining nodes of the list
while (current != null)
copy.last.link =
(LinkedListNode<T>) current.clone();
copy.last = copy.last.link;
current = current.link;
return copy;
//Method to return an iterator of the list.
//Postcondition: An iterator is instantiated and
// returned.
public LinkedListIterator<T> iterator()
return new LinkedListIterator<T>();
//Method to determine whether searchItem is in
//the list.
//Postcondition: Returns true if searchItem is found
// in the list; false otherwise.
public abstract boolean search(T searchItem);
//Method to insert newItem in the list.
//Postcondition: first points to the new list
// and newItem is inserted at the
// beginning of the list. Also,
// last points to the last node and
// count is incremented by 1.
public abstract void insertFirst(T newItem);
//Method to insert newItem at the end of the list.
//Postcondition: first points to the new list and
// newItem is inserted at the end
// of the list. Also, last points to
// the last node and
// count is incremented by 1.
public abstract void insertLast(T newItem);
//Method to delete deleteItem from the list.
//Postcondition: If found, the node containing
// deleteItem is deleted from the
// list. Also, first points to the first
// node, last points to the last
// node of the updated list, and count
// is decremented by 1.
public abstract void deleteNode(T deleteItem);
public abstract void splitAt(LinkedListClass<T> secondList, T item);
}And this is the UnorderedLinked Class with the very last method the one being Im stuck on. The SplitAt Method.
public class UnorderedLinkedList<T> extends LinkedListClass<T>
//Default constructor
public UnorderedLinkedList()
super();
//Method to determine whether searchItem is in
//the list.
//Postcondition: Returns true if searchItem is found
// in the list; false otherwise.
public boolean search(T searchItem)
LinkedListNode<T> current; //variable to traverse
//the list
boolean found;
current = first; //set current to point to the first
//node in the list
found = false; //set found to false
while (current != null && !found) //search the list
if (current.info.equals(searchItem)) //item is found
found = true;
else
current = current.link; //make current point to
//the next node
return found;
//Method to insert newItem in the list.
//Postcondition: first points to the new list
// and newItem is inserted at the
// beginning of the list. Also,
// last points to the last node and
// count is incremented by 1.
public void insertFirst(T newItem)
LinkedListNode<T> newNode; //variable to create the
//new node
newNode =
new LinkedListNode<T>(newItem, first); //create and
//insert newNode before
//first
first = newNode; //make first point to the
//actual first node
if (last == null) //if the list was empty, newNode is
//also the last node in the list
last = newNode;
count++; //increment count
//Method to insert newItem at the end of the list.
//Postcondition: first points to the new list and
// newItem is inserted at the end
// of the list. Also, last points to
// the last node and
// count is incremented by 1.
public void insertLast(T newItem)
LinkedListNode newNode; //variable to create the
//new node
newNode =
new LinkedListNode(newItem, null); //create newNode
if (first == null) //if the list is empty, newNode is
//both the first and last node
first = newNode;
last = newNode;
else //if the list is not empty, insert
//newNode after last
last.link = newNode; //insert newNode after last
last = newNode; //set last to point to the
//actual last node
count++;
}//end insertLast
//Method to delete deleteItem from the list.
//Postcondition: If found, the node containing
// deleteItem is deleted from the
// list. Also, first points to the first
// node, last points to the last
// node of the updated list, and count
// is decremented by 1.
public void deleteNode(T deleteItem)
LinkedListNode<T> current; //variable to traverse
//the list
LinkedListNode<T> trailCurrent; //variable just
//before current
boolean found;
if ( first == null) //Case 1; the list is empty
System.err.println("Cannot delete from an empty "
+ "list.");
else
if (first.info.equals(deleteItem)) //Case 2
first = first.link;
if (first == null) //the list had only one node
last = null;
count--;
else //search the list for the given info
found = false;
trailCurrent = first; //set trailCurrent to
//point to the first node
current = first.link; //set current to point to
//the second node
while (current != null && !found)
if (current.info.equals(deleteItem))
found = true;
else
trailCurrent = current;
current = current.link;
}//end while
if (found) //Case 3; if found, delete the node
count--;
trailCurrent.link = current.link;
if (last == current) //node to be deleted
//was the last node
last = trailCurrent; //update the value
//of last
else
System.out.println("Item to be deleted is "
+ "not in the list.");
}//end else
}//end else
}//end deleteNode
public void splitAt(LinkedListClass<T> secondList, T item)
LinkedListNode<T> current;
LinkedListNode<T> trailCurrent;
int i;
boolean found;
if (first==null)
System.out.println("Empty.");
first=null;
last=null;
count--;
count=0;
else
current=first;
found=false;
i=1;
while(current !=null &&!found)
if(current.info.equals(item))
found= true;
else
trailCurrent=first;
current=first;
i++;
if(found)
if(first==current)
first.link=first;
last.link=last;
count--;
count=0;
else
first.link=current;
last.link=last;
last=null;
count = count- i+1;
count = i-1;
} else {
System.out.println("Item to be split at is "
+ "not in the list.");
first=null;
last=null;
count=0;
Any help or just advice would be fine. Im not the best at Java, better at VB. Am completely stumped! Thanks so much! -
Can a Collection be traversed in reverse order?
Hi..
I am using a List of Objects to display..
When I click a Link, it has to be displayed in the reverse order..
Is there any way to do this..
Please help me..
Thanks in advance..here is the code by which you can traverse a List in
reverse order without modifying contents of the list
import java.util.*;
public class ReverseList {
public static void main(String[] args) {
List first = new ArrayList();
first.add("Java");
first.add("Is");
first.add("Easy");
ListIterator iterator = first.listIterator();
//now traverse a list in forward direction so that
you can reach at the end of the list
while(iterator.hasNext()) {
iterator.next();
//now traverse a list in reverse direction
while(iterator.hasPrevious()) {
System.out.println(iterator.previous());
For a random access list, such as ArrayList, the above is very inefficient. Instead try:
List<String> l = new ArrayList<String>();
l.add( "Java" );
l.add( "Is" );
l.add( "Easy" );
// Jump straight to the end
ListIterator<String> iterator = l.listIterator( list.size() );
// Start iterating
while( iterator.hasPrevious() ) {
System.out.println( iterator.previous() );
} -
A am with a group of students tasked with implimenting an array of linked lists to carry a set of integers (size unknown). We have a skeleton code to work from and will use some sort of hash function to find the cell that contains the list that an integer should be assigned to. There are two classes, the first is for the array and the hashing function and the second is the List class. We will be using a singly linked list and the integers will be kept in sorted order.
If for instance we are looking at the delete methods would something like the Following, inserted in the array class methods, Call upon the "List" class delete method for that particular array cell?
public void delete(int n) {
for OurListArray[ (some hash function) ] //my code
List.delete(n); //my code
If this was correct then I'd expect adding and finding and integer to be similar.
Does this make any sense?
Give me a clue so that I can try and proceed.OK, this sounds similar to the kind of thing you might do for a Radix sort, or similar (which I don't know how to do off hand). But I can give you some clues about implementing a singly linked list.
Your List class, or interface will provide methods for adding, deleting, or traversing to a particular int. Somewhere you will probably want an additional class providing the concept of a List Node, encapsulating the value (int) and a pointer to the next Node in the list.
For example:
public class LinkedList {
private Node head = null;
private Node tail = head;
public void addLast(int data) {
tail.next = new Node(data, null);
tail = tail.next;
public void addFirst(int data) {
head = new Node(data, head);
// And so on...
class Node {
int data;
Node next;
public Node(int data, Node next) {
this.data = data;
this.next = next;
}You will probably want to put in delete / remove mechanisms as well, but remember that if you delete a node, you must handle the pointer in the preceding node, or you'll magically get it back whenever you traverse the list.
Traversal mechanisms would be best put in an Iterator, but this is not a trivial structure, so perhaps you could implement this simply by maintaining a cursor on the Node you are looking at.
Essentially, you need to be able to play with references easily - almost as if they are pointers in another language.
To summarise, you have a contolling List Implementation that hides the underlying Nodes to the user. You accomplish Node insertion and deletion by playing with the Node references, but all the user sees is ints.
I'm not sure if this helps any... -
JComboBox problem when traversing using arrow keys and it is editable
Hello,
The JComboBox I am using is editable and user needs to traverse the list using arrow keys as long as user is not selecting a particular item. But this is not achievable when combobox is editable. Any suggestion to get rid of that.
regards,
RanjanHuh?import java.awt.*;
import javax.swing.*;
public class Test3 extends JFrame {
public Test3() {
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Container content = getContentPane();
JComboBox jcb = new JComboBox(new String[] {"One","Two","Three"});
jcb.setEditable(true);
content.add(jcb, BorderLayout.NORTH);
setSize(100,100);
public static void main(String[] args) { new Test3().setVisible(true); }
} -
Hi,
I created a JList and when the focus is transferred to JList, I used arrow keys to traverse the List values. For example if the list has values
1
2
3
4
When I reach 4, if I press upward key, it takes me to 3.
Is there a way where after reaching 4, the upward key takes us to 1. ie the beggining of the list. This is to read the list values in a circular way.
Please let me know if anybody know how to deal with this problem.
Regards,
VamshiIf u r at element 4 and press Upward Key u should always go to 3 but on pressing Down key u can go to 1, for this u need to write a code in java for Key pressed event and in that find if the index is last and user has pressed up key move it to first element otherwise to n-1 element.
Ankush -
I have a requirement where a user has permission for task A,task B,task C.Task A has in turn child task D and E
The end result should look like
User
List<Task> tasks;//A,B,C.......In short for every Task object in the collection the childTask must be populated with child task
Task
List<task> childTask//IF the task is A then the child task should be D and E
I know all the task(A,B,C) the user is entitled for.I am also able to travel through each child node under each task
but I am struggling to put it all together;
Please help me with the logic.To traverse a list of tasks, you simply process each task in the list. To traverse the whole tree, then, the definition of "process a task" must include at some point traversing the list of children of that task. So there's about 10 or 15 lines of code involved. Where are you having the problem?
-
Help - can't print linked list object
Hi all,
I've written a program that creates an Airplane object. I've added the Airplane object to a linked list. I am trying to test by printing the linked list..but I get the addresses of the airplane object instead of the integer variables that the Airplane object contains. How can I fix this? Here's my output showing what I am talking about:
Airplane type: 2
Airplane arrival time: 600
Airplane cleaning time: 45
Airplane take-off time: 645
[Airplane@665753]
Airplane type: 3
Airplane arrival time: 1100
Airplane cleaning time: 60
Airplane take-off time: 1160
[Airplane@665753, Airplane@ef22f8]
Airplane type: 1
Airplane arrival time: 900
Airplane cleaning time: 30
Airplane take-off time: 930
[Airplane@665753, Airplane@ef22f8, Airplane@e0cf70]
Airplane type: 1
Airplane arrival time: 1100
Airplane cleaning time: 30
Airplane take-off time: 1130
[Airplane@665753, Airplane@ef22f8, Airplane@e0cf70, Airplane@52fe85]
Airplane type: 3
Airplane arrival time: 1000
Airplane cleaning time: 60
Airplane take-off time: 1060
[Airplane@665753, Airplane@ef22f8, Airplane@e0cf70, Airplane@52fe85, Airplane@c40c80]
Airplane type: 2
Airplane arrival time: 900
Airplane cleaning time: 45
Airplane take-off time: 945
[Airplane@665753, Airplane@ef22f8, Airplane@e0cf70, Airplane@52fe85, Airplane@c40c80, Airplane@10d81b]
Airplane type: 2
Airplane arrival time: 900
Airplane cleaning time: 45
Airplane take-off time: 945
[Airplane@665753, Airplane@ef22f8, Airplane@e0cf70, Airplane@52fe85, Airplane@c40c80, Airplane@10d81b, Airplane@dbe178]
Airplane type: 3
Airplane arrival time: 1000
Airplane cleaning time: 60
Airplane take-off time: 1060
[Airplane@665753, Airplane@ef22f8, Airplane@e0cf70, Airplane@52fe85, Airplane@c40c80, Airplane@10d81b, Airplane@dbe178, Airplane@af9e22]
Airplane type: 1
Airplane arrival time: 900
Airplane cleaning time: 30
Airplane take-off time: 930
[Airplane@665753, Airplane@ef22f8, Airplane@e0cf70, Airplane@52fe85, Airplane@c40c80, Airplane@10d81b, Airplane@dbe178, Airplane@af9e22, Airplane@b6ece5]
Airplane type: 1
Airplane arrival time: 700
Airplane cleaning time: 30
Airplane take-off time: 730
[Airplane@665753, Airplane@ef22f8, Airplane@e0cf70, Airplane@52fe85, Airplane@c40c80, Airplane@10d81b, Airplane@dbe178, Airplane@af9e22, Airplane@b6ece5, Airplane@7ace8d]
Airplane@665753
import java.io.*;
import java.util.*;
public class AirPortSimulator {
public static void main(String[] args) {
LinkedList<Airplane> myEventList = new LinkedList();
//for loop to test random number generator for airplane type
for( int i = 0; i < 10; i++){
int parOne = myNumber();
System.out.println("Airplane type: " + parOne);
int parTwo = myTime();
System.out.println("Airplane arrival time: " + parTwo);
int parThree = 0;
switch(parOne){
case 1: parThree = 30;break;
case 2: parThree = 45;break;
case 3: parThree = 60;break;
System.out.println("Airplane cleaning time: " + parThree);
int parFour=0;
switch(parOne){
case 1: parFour = parTwo + 30;break;
case 2: parFour = parTwo + 45;break;
case 3: parFour = parTwo + 60;break;
System.out.println("Airplane take-off time: " + parFour);
System.out.println();
Airplane myAirplane = new Airplane(parOne, parTwo, parThree, parFour);
myEventList.addLast(myAirplane);
System.out.println(myEventList);
System.out.println();
public static int myTime(){
Random generator = new Random();
int number = generator.nextInt(16)+1;
number = number * 100;
if (number < 600){
number = number + 600;
return number;
public static int myNumber(){
Random generator = new Random();
return generator.nextInt(3)+1;
}I've written a method before that prints all the
elements of a linked list..but that method onlyheld
one integer or string...it was a "while (head !=
null) loop that traversed the list and printed
"head.info"
But i'm confused with an object that has 4integers
inside it...You don't have to write any kind of loop. The
LinkedList implementation of toString does that for
you. All you have to do is write a toString for
Airplane that prints whatever you feel is important
for a single Airplane object.
But note that since the list uses commas to separate
entries, your toString method will be clearer if you
can write it in such a way that it doesn't use
commas, or so that you can see where the output
begins and ends. For example, maybe you can wrap the
output with curly brackets.Thanks, I just had to understand what the toString method was and then how to override it. This works well:
Thank you for pointing me in the right direction.
aiki985
public String toString(){
return "{" + airplaneType + ", " + arrivalTime + ", " +
waitingTime + ", " + departureTime + "}";
} // end toString method -
Redesigning the Collections Framework
Hi!
I'm sort of an experienced Java programmer, in the sense that I program regularly in Java. However, I am not experienced enough to understand the small design specifics of the Collections Framework (or other parts of Javas standard library).
There's been a number of minor things that bugged me about the framework, and all these minor things added up to a big annoyance, after which I've decided to (try to) design and implement my own framework.
The thing is however, that since I don't understand many design specifics about the Collection Framework and the individual collection implementations, I risk coming up short with my own.
(And if you are still reading this, then I thank you for your time, because already now I know that this entry is going to be long. : ) )
Since I'm doing my Collection framework nearly from scratch, I don't have to worry too much about the issue of backwards compatibility (altough I should consider making some parts similar to the collection framework as it is today, and provide a wrapper that implements the original collection interfaces).
I also have certain options of optimizing several of the collections, but then again, there may be very specific design issues concerning performance and usability that the developers of the framework (or other more experienced Java progammers) knew about, that I don't know.
So I'm going to share all of my thoughts here. I hope this will start an interesting discussion : )
(I'm also not going to make a fuss about the source code of my progress. I will happily share it with anyone who is interested. It is probably even neccessary in order for others to understand how I've intended to solve my annoyances (or understand what these annoyances were in the first place). ).
(I've read the "Java Collections API Design FAQ", btw).
Below, I'm going to go through all of the things that I've thought about, and what I've decided to do.
1.
The Collections class is a class that consists only of static utility methods.
Several of them return wrapper classes. However the majority of them work on collections implementing the List interface.
So why weren't they built into the List interface (same goes for methods working only with the Collection interface only, etc)? Several of them can even be implemented more efficiently. For example calling rotate for a LinkedList.
If the LinkedList is circular, using a sentry node connecting the head and tail, rotate is done simply by relocating the sentry node (rotating with one element would require one single operation). The Collections class makes several calls to the reverse method instead (because it lacks access to the internal workings of a LinkedList).
If it were done this way, the Collections class would be much smaller, and contain mostly methods that return wrapped classes.
After thinking about it a while, I think I can answer this question myself. The List interface would become rather bloated, and would force an implementation of methods that the user may not need.
At any rate, I intend to try to do some sort of clean-up. Exactly how, is something I'm still thinking about. Maybe two versions of List interfaces (one "light", and the other advanced), or maybe making the internal fields package private and generally more accessible to other package members, so that methods in other classes can do some optimizations with the additional information.
2.
At one point, I realized that the PriorityQueue didn't support increase\decrease key operations. Of course, elements would need to know where in the backing data structure it was located, and this is implementation specific. However, I was rather dissapointed that this wasn't supported somehow, so i figured out a way to support this anyway, and implemented it.
Basically, I've wrapped the elements in a class that contains this info, and if the element would want to increase its key, it would call a method on the wrapping class it was contained in. It worked fine.
It may cause some overhead, but at least I don't have to re-implement such a datastructure and fiddle around so much with the element-classes just because I want to try something with a PriorityQueue.
I can do the same thing to implement a reusable BinomialHeap, FibonacciHeap, and other datastructures, that usually require that the elements contain some implementation-specific fields and methods.
And this would all become part of the framework.
3.
This one is difficult ot explain.
It basically revolves around the first question in the "Java Collections API Design FAQ".
It has always bothered me that the Collection interface contained methods, that "maybe" would be implemented.
To me it didn't make sense. The Collection should only contain methods that are general for all Collections, such as the contains method. All methods that request, and manipulate the Collection, belonged in other interfaces.
However, I also realized that the whole smart thing about the current Collection interface, is that you can transfer elements from one Collection to another, without needing to know what type of Collection you were transferring from\to.
But I still felt it violated "something" out there, even if it was in the name of convenience. If this convenience was to be provided, it should be done by making a separate wrapper interface with the purpose of grouping the various Collection types together.
If you don't know what I'm trying to say then you might have to see the interfaces I've made.
And while I as at it, I also fiddled with the various method names.
For example, add( int index, E element), I felt it should be insert( int index, E element). This type of minor things caused a lot of confusion for me back then, so I cared enough about this to change it to somthing I thought more appropriate. But I have no idea how appropriate my approach may seem to others. : )
4.
I see an iterator as something that iterates through a collection, and nothing else.
Therefor, it bothered me that the Iterator interface had an optional remove method.
I myself have never needed it, so maybe I just don't know how to appreciate it. How much is it used? If its heavily used, I guess I'm going to have to include it somehow.
5.
A LinkedList doesnt' support random access. But true random access is when you access randomly relative to the first index.
Iterating from the first to the last with a for statement isn't really random access, but it still causes bad performance in the current LinkedList implementation. One would have to use the ListIterator to achieve this.
But even here, if you want a ListIterator that starts in the middle of the list, you still need to traverse the list to reach that point.
So I've come up with LinkedList that remembers the last accessed element using the basic methods get, set, remove etc, and can use it to access elements relatively from it.
Basically, there is now an special interal "ListIterator" that is used to access elements when the basic methods are used. This gives way for several improvements (although that may depend how you look at it).
It introduces some overhead in the form of if-else statemenets, but otherwise, I'm hoping that it will generally outperform the current LinkedList class (when using lists with a large nr of elements).
6.
I've also played around with the ArrayList class.
I've implemented it in a way, that is something like a random-access Deque. This has made it possible to improvement certain methods, like inserting an element\Collection at some index.
Instead of always shifting subsequent element to the right, elements can be shifted left as well. That means that inserting at index 0 only requires a single operation, instead of k * the length of the list.
Again, this intrduces some overhead with if-else statements, but is still better in many cases (again, the List must be large for this to pay off).
7.
I'm also trying to do a hybrid between an ArrayList and a Linked list, hopefully allowing mostly constant insertion, but constant true random access as well. It requires more than twice the memory, since it is backed by both an ArrayList and a LinkedList.
The overhead introduced , and the fact that worst case random access is no better than that of a pure LinkedList (which occurs when elelements are inserted at the same index many times, and you then try to access these elements), may make this class infeasible.
It was mostly the first three points that pushed my over the edge, and made me throw myself at this project.
You're free to comment as much as you like.
If no real discussion starts, thats ok.
Its not like I'm not having fun with this thing on my own : )
I've started from scratch several times because of design problems discovered too late, so if you request to see some of the source code, it is still in the works and I would have to scurry off and add a lot of java-comments as well, to explain code.
Great. Thanks!This sort of reply has great value : )
Some of them show me that I need to take some other things into consideration. Some of them however, aren't resolved yet, some because I'm probably misunderstanding some of your arguments.
Here goes:
1.
a)
Are you saying that they're were made static, and therefor were implemented in a utility class? Isn't it the other way around? Suppose that I did put them into the List interface, that would mean they don't need to be static anymore, right?
b)
A bloated List interface is a problem. Many of them will however have a default not-so-alwyas-efficient implementation in a abstract base class.
Many of the list-algorithms dump sequential lists in an array, execute the algorithm, and dump the finished list back into a sequential list.
I believe that there are several of them where one of the "dumps" can be avoided.
And even if other algorithms would effectively just be moved around, it wouldn't neccesarily be in the name of performance (some of them cannot really be done better), but in the name of consistency\convenience.
Regarding convenience, I'm getting the message that some may think it more convenient to have these "extra" methods grouped in a utility class. That can be arranged.
But when it comes to consistency with method names (which conacerns usability as well), I felt it is something else entirely.
For example take the two methods fill and replaceAll in the Collections class. They both set specific elements (or all of them) to some value. So they're both related to the set method, but use method names that are very distinguished. For me it make sense to have a method called setAll(...), and overload it. And since the List interface has a set method, I would very much like to group all these related methods together.
Can you follow my idea?
And well, the Collections class would become smaller. If you ask me, it's rather bloated right now, and supports a huge mixed bag of related and unrelated utitlity methods. If we should take this to the extreme, then The Collections class and the Arrays class should be merged.
No, right? That would be hell : )
2,
At a first glance, your route might do the trick. But there's several things here that aren't right
a)
In order to delete an object, you need to know where it is. The only remove method supported by PriorityQueue actually does a linear search. Increase and decrease operations are supposed to be log(n). Doing a linear search would ruin that.
You need a method something like removeAt( int i), where i would be the index in the backing array (assuming you're using an array). The elemeny itself would need to know that int, meaning that it needs an internal int field, even though this field only is required due to the internal workings of PriorityQueue. Every time you want to insert some element, you need to add a field, that really has nothing to with that element from an object-oriented view.
b)
Even if you had such a remove method, using it to increase\decrease key would use up to twice the operations neccesary.
Increasing a key, for example, only requires you to float the element up the heap. You don't need to remove it first, which would require an additional log(n) operations.
3.
I've read the link before, and I agree with them. But I feel that there are other ways to avoid an insane nr of interfaces. I also think I know why I arrive at other design choices.
The Collection interface as it is now, is smart because it can covers a wide range of collection types with add and remove methods. This is useful because you can exchange elements between collections without knowing the type of the collection.
The drawback is of course that not all collection are, e.g modifiable.
What I think the problem is, is that the Collection interface is trying to be two things at once.
On one side, it wants to be the base interface. But on the other side, it wants to cast a wide net over all the collection types.
So what I've done is make a Collection interface that is infact a true base interface, only supporting methods that all collection types have in common.
Then I have a separate interface that tries to support methods for exchanging elements between collections of unknown type.
There isn't neccesarily any performance benefit (actually, it may even introduces some overhead), but in certainly is easier to grasp, for me at least, since it is more logically grouped.
I know, that I'm basically challenging the design choices of Java programmers that have much more experience than me. Hell, they probably already even have considered and rejected what I'm considering now. In that case, I defend myself by mentioning that it isn't described as a possiblity in the FAQ : )
4.
This point is actually related to point 3., becausue if I want the Collection interface to only support common methods, then I can't have an Iterator with a remove method.
But okay....I need to support it somehow. No way around it .
5. 6. & 7.
The message I'm getting here, is that if I implement these changes to LinkedList and ArrayList, then they aren't really LinkedList and ArrayList anymore.
And finally, why do that, when I'm going to do a class that (hopefully) can simulate both anyway?
I hadn't thought of the names as being the problem.
My line of thought was, that okay, you have this arraylist that performs lousy insertion and removal, and so you avoid it.
But occasionally, you need it (don't ask me how often this type of situation arises. Rarely?), and so you would appreciate it if performed "ok". It would still be linear, but would often perform much better (in extreme cases it would be in constant time).
But these improvements would almost certainly change the way one would use LinkedList and ArrayList, and I guess that requires different names for them.
Great input. That I wouldn't have thought of. Thanks.
There is however some comments I should comment:
"And what happens if something is suibsequently inserted or removed between that element and the one you want?"
Then it would perform just like one would expect from a LinkedList. However if that index were closer to the last indexed position, it would be faster. As it is now, LinkedList only chooses either the first index or the last to start the traversal from.
If you're working with a small number of elements, then this is definitely not worth it.
"It sounds to me like this (the hybrid list) is what you really want and indeed all you really need."
You may be right. I felt that since the hybrid list would use twice as much memory, it would not always be the best choice.
I going to think about that one. Thanks. -
I have a school project that I have almost completed, but I am totally stuck on one part.
The overall project is to write a program that reads in 2 polynomials from the user, sorts them in to 2 linked lists and then traverses those lists and adds the 2 polynomials, saving the sum in a 3rd polynomial. I have completed the code for the reading and list sorting, but I am stuck on traversing the list and adding the polynomials.
These are my guidelines:
Set up traversing references to termNodes for both polynomials p and q that point to the first
terms of each and advance through each. Set up reference to the sum r that always points to the
last added term.
If the exponent of p?s term is equal to the exponent of q?s term, add the coefficients and append
this new term to polynomial r (insert it ?after? the traversing reference of r and update this traversing
reference to this latest term.) Advance both p?s and q?s traversing references.
If the exponent of p?s term is less than the exponent of q?s term, add a copy of q?s term to r. Advance q?s traversing reference.
If the exponent of p?s term is greater than the exponent of q?s term, add a copy of p?s term to r.
Advance p?s traversing reference.
When one (or both) of p?s and q?s traversing pointers is null, write two loops that add a copy of the
remaining terms from p or q (you do not know which traversal is complete, so two loops are
required) to r.
I am just totally lost on this. Any code, pointers, anything that can point me in the right direction would be much appreciated.
If it helps, my other code is below
package linkedList;
public class termNode implements Comparable
private int coefficient;
private int exponent;
private termNode next;
//CONSTRUCTOR WITH PARAMETERS
public termNode(int c, int e)
coefficient = c;
exponent = e;
next = null;
//COPY CONSTRUCTOR
public termNode(termNode otherNode)
coefficient = otherNode.coefficient;
exponent = otherNode.exponent;
//OVERRIDE toString AND RETURN VALUES
public String toString()
if (exponent == 0)
return coefficient + " ";
else if (exponent == 1)
return coefficient + "x ";
else
return coefficient + "x^" + exponent + " ";
//COMPARE EXPONENTS: RETURN 0 IF EQUAL, NEGATIVE IF THIS OBJECT IS LESS THAN
//OTHER OBJECT AND POSITIVE IF THIS OBJECT IS GREATER THAN OTHER OBJECT
public int compareTo (Object other)
if (exponent==((termNode) other).exponent)
return 0;
else if (exponent < ((termNode) other).exponent)
return -1;
else
return 1;
//MUTATOR METHOD FOR COEFFICIENT
public void setCoefficient(int c)
coefficient = c;
public int getCoefficient()
return coefficient;
//MUTATOR METHOD FOR EXPONENT
public void setExponent(int e)
exponent = e;
public int getExponent()
return exponent;
//MUTATOR METHOD FOR NEXT
public void setNext(termNode n)
next = n;
public termNode getNext()
return next;
package linkedList;
import java.util.Scanner;
public class polynomial
private termNode head;
//DEFAULT CONSTRUCTOR CREATES EMPTY LIST
public polynomial()
head = null;
//READ INPUT FROM USER
public void readPolynomial()
int a = 0;
int b = 1;
Scanner kbInput = new Scanner(System.in);
System.out.println("Enter 0 and 0 to end.");
System.out.print("coefficient: ");
kbInput.skip("\\s*");//SKIPS LEADING WHITE SPACE
a = kbInput.nextInt();//READS FIRST VALUE IN TO a
kbInput.nextLine(); //SKIPS REMAINDER OF INPUT LINE
System.out.print("exponent: ");
kbInput.skip("\\s*");//SKIPS LEADING WHITE SPACE
b = kbInput.nextInt();//READS SECOND VALUE IN TO b
kbInput.nextLine(); //SKIPS REMAINDER OF INPUT LINE
while (a!=0)
termNode newTerm = new termNode(a,b);
insert(newTerm);
System.out.println("Enter 0 and 0 to end.");
System.out.print("coefficient: ");
kbInput.skip("\\s*");//SKIPS LEADING WHITE SPACE
a = kbInput.nextInt();//READS FIRST VALUE IN TO COEFFICIENT
kbInput.nextLine(); //SKIPS REMAINDER OF INPUT LINE
System.out.print("exponent: ");
kbInput.skip("\\s*");//SKIPS LEADING WHITE SPACE
b = kbInput.nextInt();//READS SECOND VALUE IN TO EXPONENT
kbInput.nextLine(); //SKIPS REMAINDER OF INPUT LINE
public void insert(termNode newNode)
termNode prev = null;
termNode cur = head;//CUR POINTS TO FIRST ITEM IN LIST (HEAD)
while (cur!=null && (newNode.compareTo(cur)>0))//TRAVERSE LIST WHILE CUR IS NOT NULL AND
{ //newNode EXPONENT IS GREATER THAN cur EXPONENT
prev = cur;
cur = cur.getNext();
if (prev==null)//INSERT AT BEGINNING OF LIST
newNode.setNext(head);
head = newNode;
else//INSERT IN LIST BASED ON PREVIOUS TRAVERSING
newNode.setNext(cur);
prev.setNext(newNode);
//System.out.println(cur.getNext());
//DISPLAY "0" FOR EMPTY LIST, OTHERWISE TRAVERSE AND DISPLAY POLYNOMIAL
public void display()
if (head==null)
System.out.println("0");
else
for (termNode cur=head; cur!=null; cur = cur.getNext())
System.out.print(cur);
}My first bit of advice is to lose those awful star-boxed comments. Atrocious.
Just saw the second class. You have, by a wide margin, the very worst commenting style I've ever seen.
Wait for it - "My teacher tells me we have to comment our code or s/he'll take off points, so I have to keep them." Oy.
You aren't following the Sun standards for Java coding, either. I'd recommend learning them.
The rest ain't so bad.
So your two problems - list traversal and addition. We'll start with the second one. Do you know how to add two polynomials? Do you know the rules for adding two monomials? If I gave you these, what would the answer be?
p1(x) = 4x^2
p2(x) = 5x^3
p1(x) + p2(x) = ?
How 'bout
p3(x) = 5x^2 + 4
p4(x) = 10x^100 - x^2
p3(x) + p4(x) = ?
If you can figure these out, the coding should be clearer.
As for the list, your "next" and "head" data members lead me to believe that you intend to do your own linked list. Do you know how to do that? Why aren't you considering the Java collections?
% -
Do I need to declare a transaction in this case?
I am struggling to understand when it is necessary to declare my own transaction to ensure the data is properly updated.
For example, in the following code, which is part of a java bean in the EJB project, KeyFacade is a stateless session bean tied to the entity "Key". it is a standard EJB created with the netBeans 5.5 wizard. I have changed no defaults.
Do I need to declare a transaction, commit the transaction and close it when I use the "KeyFacade.edit(key);" in order to ensure the database is updated? Or is it automatically done because the .edit() method uses the entityManager and the persistence is container managed?
Would it make a difference if this bean was part of a WAR project?
public BigInteger getNextKey(String tableName){
KeyFacadeLocal KeyFacade = this.lookupKeyFacade();
Key key = KeyFacade.findByTablename(tableName);
long nextKey = key.getKeyvalue();
BigInteger BINextKey =BigInteger.valueOf((int)nextKey);
// now update the table by incrementing the key value by 1
long incrementKey = nextKey + 1;
key.setKeyvalue(incrementKey);
KeyFacade.edit(key);
return BINextKey;
}808239 wrote:
I have a Map<Integer, List<T>> data, and all the lists are initialized using Collections.synchronizedList().Seems like overkill to me. Your Map also looks like a Multimap, of which there are several existing implementations.
When I do the traversal, I want to traverse ALL lists in the map at the same timeI suspect not. What you want to do is to traverse each one in sequence.
so I have to sync all lists as shown in the API doc as follows: ...Seems like overkill to me, and will probably result in a very slow Map (not that there's any problem with that if it's the right thing to do; in this case, I suspect it isn't).
Is this approach ok?What are you trying to achieve? If you need full consistency for your iterators (ie, a snapshot of the entire Map at the time the iterator is created), you have a two choices (assuming you don't want to deal with update journals):
1. Lock the Map.
2. Clone the Map (and your clone() method should be synchronized).
Of the two, the second seems best to me, but neither is all that wonderful.
However, if all you need is weak consistency - that is to say, what you return reflects the state of the Map when Iterator.next() is called - all you really need to do is make sure that your Lists are synchronized when you do the read.
Since the List updates are the responsibility of your Map (I'm still presuming this is some sort of Multimap implementation), there's no real need to synchronize them; just synchronize the Map's own update methods.
I'd also suggest that you make sure your getValue() method hands back an [url http://download.oracle.com/javase/6/docs/api/java/util/Collections.html#unmodifiableList%28java.util.List%29]unmodifiable List to clients; otherwise they could start adding or removing values themselves.
HIH
Winston
Maybe you are looking for
-
Error code 265: The certificate chain was issued by an authority that is not trusted.
We are in the process of trying to set up a wireless network that uses NPS servers to authenticate domain users with computers that are not on our domain (BYOD). We are using a valid, wildcard SSL (with intermediate certificates) to authenticate via
-
Related Topics: Is it possible to change the order of topics?
Hi, Is it possible to change the order of Related Topics? I need to change the order of topics (that is, I don't want the topics alphabeticized.) Thanks, FMnRH
-
Using CS4 intel mac. url_btn.addEventListener (MouseEvent.CLICK, clickUrl_btn); function clickUrl_btn (evtObj: MouseEvent) { navigateToURL(new URLRequest); URLRequest("http://www.google.com"); I get the following message, but no errors. WARNING: Acti
-
Display corruption with ATI Radeon X800 XT
I installed an ATI Radeon X800XT card and my 23" Apple display got so corrupted I had to remove the card and get back to my old tested ATI Radeon 9650. The symptoms were as follows: soon after startup, a few white pixels appeared near the center of t
-
hi guys, one of our client using oracle 9i R2 on windows server 2003 platform. they used to make export backup.when they called me and show me that when they import a schema, import hangs at one large table (i think containing more that 4000,000 rows