Algorithms Tips (4) – Basic Data Structure

Here we record some basic data structures which are easily involved in coding.

  • PriorityQueue
    Sometimes, we want to sort hashmap by its value, we can introduce PriorityQueue to override its compare function to reach the goal. (Laster, I will add more compare function to popular PriorityQueue’s field.)

     Map<Integer, Integer> tweets = new HashMap();
     PriorityQueue<Integer> pq = new PriorityQueue<Integer>(new Comparator<Integer>(){
       public int compare(Integer a, Integer b) {
         return tweets.get(b) - tweets.get(a);
         // tweets.get(a)-tweets.get(b) is increasing/ascending
         // tweets.get(b)-tweets.get(a) is downing trend
     pq.poll(); //return head and delete head 
     pq.peek(); // return head
  • Set
    If we want to add unique value to the output, we can use set as an intermedium variable to help to check during adding process.

    Set set = new HashSet();
    Iterator iterator = set.iterator();
    while(iterator.hasNext()) {
      String elem =;
  • TreeMap
    A TreeMap provides an efficient means of sorting key/value pairs in sorted order and allows rapid retrieval. Its elements will be sorted in an ascending key order.

    TreeMap tm = new TreeMap();
    tm.put("a", 2);
    tm.put("b", 1);
    tm.get("a"); // return 2
    tm.lastKey(); // return "b"
    tm.firstKey(); // return "a"
    TreeMap<Integer, HashSet> t = new TreeMap();
    // if HashSet's size is zero, we need to use t.remove(key) to 
    remove this element in TreeMap. Because its null value will 
    influence TreeMap's firstKey and lastKey result.
  • List
    Arrays.asList("a", "b");// initialize List with values
    // List to Array
    lists.toArray(new String[lists.size()]);

    For recursion method, we might need to copy the last result to current result. For example, for f(i-1), its result is left (List<Integer>) and for f(i), its result is to merge left with current value.
    Wrong version:

     List<List<Integer>> rec = new ArrayList<List<Integer>>():
     for(List<Integer> left: lefts) {

    Right version:

     List<List<Integer>> rec = new ArrayList<List<Integer>>():
     for(List<Integer> left: lefts) {
       ArrayList<Integer> elem = new ArrayList<Integer>(left);

    The problem of the wrong version is that it will change left’s content. For example, if left=[[], [1]] and nums[1]=2, the wrong version’s output is [[2],[1,2],[2],[1,2]]. For the right version, it creates a new ArrayList to physically build a new list, so later add method won’t change original content. So the right output is [[], [1], [2], [1,2]].

  • Stack
    Stack<String> s = new Stack();
  • String
    int integer = 1;
    String t = String.valueOf(integer);

The string is very common, so the only special point is to convert to char[] when needed.

  •  char[] arr = str.toCharArray();
     String t = String.valueOf(arr);
     String t1 = new String(arr);



Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s