Use an HashMap, an TreeMap or just an array?

Question

Hi,
i have a fixed size of graph nodes, lets say 100.000.
Each of these nodes should have an own id, where i just would take the node number - if i increment on these nodes - as such an id.
Suggestion a)
If i safe them to an HashMap, the key is the id as
nodeCounter = 0;
HashMap h = new HashMap(100.000);
h.put(new Integer(nodeCounter++), nodeInstance);
//...put in  all nodes-> To search for a node would be constant time O(1)
-> What about insertion, also O(1)?
Suggestion b)
if i safe it to a TreeMap i would have also the key as the id and put in all
the nodes. Since the key is just an unique Integer from 1-100.000 a
comparator can be used to keep the RedBlackTree sorted.
-> To search for a node would cost O(log(n))
-> To insert a node would cost O(log(n))
Suggestion c)
Since a node is just represented on screen by his id and a fixed String as Node"+"1" -> "Node 1" i thought of using an simple array to safe the nodes, since each index of the array is just the id of the node.
-> To find a node costs O(1)
-> To insert a node is dynamically not possible
My preferring suggestion is a)
but only if the insertion an finding of an node is both constant O(1).
Is it an advantage for a TreeMap to keep
the elements sorted, compared to a HashMap which keeps them unordered?
What do you think?
Do you have any good advice for me or any other good alternative how to solve this problem? By reaching best performance?
Thanks a lot for your answer!
Message was edited by:
Cinimood

Answer 1

ok, thanks for your answer - i will describe the whole problem i want to solve:
given is an undirected graph of nodes, let�s say a network graph.
This graph contains about 1000 nodes(less or 2000 or 3000 is also possible), where the nodes are linked by each other -
could be a full mesh in the worst case. Each link is assigned a weight.
The features this graph should provide are:
- adding a node when the graph is already created i.e. represented by the datastructure.
- searching for a link between two nodes
To represent a graph by a datastructure is best by using an adjacency matrix or an adjacency list.
Searching for a link between two nodes the adjancency matrix provides best performance by just O(1). But the adjacency
matrix needs memory by O((n^2)/2) -> divided by 2, because the graph is undirected, O(n^2) in a directed graph.
ok, using an array like:
Node nodes[] = new Nodes[1000]; is of course best to retreive each node by just his id which is equivalent to his index -> node[1] has id 1.
but if i�m using an array, i cannot add another node dynamically.
(Note: I need Node instances because each node holds its x and y coords for displaying, which is not important
now.)
Now, i think of a solution like this - with focus on adjacency matrix and HashMap without regarding adjacency list:
use an adjacency matrix for searching for the specific link between two nodes because of the good performance of O(1). Because the graph is undirected i only need the upper(or lower) part of the diagonal of the matrix,
thus O((n^2)/2) memory.
use a HashMap for the nodes, where the key of the node entry for the HashMap is just his ID:nodeMap.put(new Integer(nodeCounter++), nodeInstance);use a HashMap for the links between the nodes, where a link is represented by the class Link which holds just the weight.
To identify the link, use an ID which consists of the concatenation row+column of the adjacency matrix e.g.
row = 1, column = 2 -> ID = 12
linkMap.put(new Integer(row+column), new Link(weight));-> if i want to insert a weighted link between node 2 and node 5 i just modify the Link object in the linkMap which has the
key 2+5 -> 25.
That�s what i want to do and what makes me thinking all the time of good performance,
because a lot of nodes might exist and searching, deleting and inserting must be quick.