Java通过特定值存储int矩阵中的值的更好方法

Question

I have an matrix of int[][] and I want to store coords in different arrays according to it's values in the matrix. I think that my solution works but it's not very performant...

    public ArrayList<ArrayList<Coords>> storeValues(int[][] labels) {
    int max = getMaxValue(labels);
    ArrayList<ArrayList<Coords>> collection = new ArrayList<ArrayList<Coords>>();
    ArrayList<Coords> coords;

    while (max > 0) {
        coords = new ArrayList<Coords>();
        for (int x = 0; x < labels.length; x++) {
            for (int y = 0; y < labels[0].length; y++) {
                if (max == labels[x][y]) {
                    coords.add(new Coords(x,y));
                }
            }
        }
        collection.add(coords);
        --max;
    }
    return collection;
}

private int getMaxValue(int[][] labels) {
    int max = labels[0][0];
    for (int tabValue[] : labels) {
        for (int value : tabValue) {
            if (max < value) {
                max = value;
            }
        }

    }
    return max;
}

For exemple :
My matrix containt

[ [ 0, 0, 0 ],  
  [ 1, 1, 1 ],  
  [ 1, 2, 2 ],   
  [ 2, 2, 5 ] ]  

Expected result

ArrayList{ 
  ArrayList{ Coord[0,0], Coord[1,0], Coord[2,0] }, // list of 0 value  
  ArrayList{ Coord[0,1], Coord[1,1], Coord[2,1], Coord[0,3] }, // list of 1 value
  ...
}

Answer 1

Your goal should be to iterate as little as possible. You can actually do it in one single (nested) iteration, if you use a Map for building up your desired data structure. Most helpful here is a TreeMap , because it automatically sorts by key..

The logic is, instead of nested lists, build up a new TreeMap<Integer, ArrayList<Coords>> . The Integer-key is your value, and the arrayList is the list of Coords for that value.

You iterate over the matrix as before, but without calculation of max . This saves you the whole getMaxValue method and the outer while loop. For each value, you first check if the TreeMap has an entry with that key. If yes, add your new Coord to map.get(val). If no, create a new ArrayList<Coord> , add your Coord to that list, and put it into the map.

If you absolutely must have ArrayList> as return type, you can simply convert the map's valueSet at the end with return new ArrayList<ArrayList<Coord>>(map.values())

Answer 2

I would agree that your current algorithm might not perform well. If you say your matrix has dimension M*N , a runtime analysis might look like:

max_val = get_max_val(); // O(M*N)
for i from max_val to 0: // O(max_val)
    // O(M*N)
    for x from 0 to M:
        for y from 0 to N:
            do_stuff;

In other words, this works out to O(M*N*max_val) . This is dangerous if your max_val is very large; especially since the actual algorithm doesn't have to depend on what the values are (just which ones are the same).

An alternative algorithm which only depends on M and N :

HashMap<Integer, ArrayList<Coords>> coordsMap = new HashMap<Integer, ArrayList<Coords>>();
for (int i = 0; i < labels.length; i++) {
    for (int j = 0; j < labels[i].length; j++) {
        if (coordsMap.containsKey(labels[i][j])) {
            ArrayList<Coords> coords = coordsMap.get(labels[i][j]);
            coordsMap.put(labels[i][j], coords.add(new Coords(i, j));
        }
    }
}

// collect results
ArrayList<ArrayList<Coords>> coordsList = new ArrayList<ArrayList<Coords>>();
for (Integer label : coordsMap.keySet()) {
    coordsList.add(coordsMap.get(label));
}
return coordsList;

The runtime on this is M*N*(HashMap get/put time) .

If you want to have an ArrayList for every value from 0 to max_val , where an absence of coordinates with that label is represented by an empty ArrayList, you could change the // collect results portion to look something like:

// collect results
for (int i = 0; i < max_val; i++) {
    if (coordsMap.containsKey(i)) {
        coordsList.add(coordsMap.get(i));
    }
    else {
        coordsList.add(new ArrayList<Coords>());
    }
}

As Marco13's comment on your question suggests, the actual performance will likely depend somewhat on how your data actually looks.

Answer 3

When the values are already sorted, the solution is rather simple: Just walk through the matrix (in the sorted order), and always create a new list when you encounter a new value.

When the values are not sorted, then you can create a list of coordinates, sort these by the corresponding value, and then apply the same method to it like for the sorted case.

Both versions are implemented here:

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class SortMatrixCoordinates
{
    static class Coords
    {
        int x;
        int y;
        Coords(int x, int y)
        {
            this.x = x;
            this.y = y;
        }
        @Override
        public String toString()
        {
            return "("+x+","+y+")";
        }
    }

    public static void main(String[] args)
    {
        runWithSortedMatrix();
        runWithUnsortedMatrix();
    }

    private static void runWithSortedMatrix()
    {
        int labels[][] = new int[][]{
            { 0, 0, 0 },  
            { 1, 1, 1 },  
            { 1, 2, 2 },   
            { 2, 2, 5 } };

        System.out.println("Result with sorted matrix:");
        List<List<Coords>> result = storeValues(labels);
        for (List<Coords> list : result)
        {
            System.out.println(list);
        }
    }

    private static void runWithUnsortedMatrix()
    {
        int labels[][] = new int[][]{
            { 0, 0, 0 },  
            { 3, 3, 3 },  
            { 3, 2, 2 },   
            { 2, 2, 1 } };

        System.out.println("Result with unsorted matrix:");
        List<List<Coords>> result = storeValuesSorting(labels);
        for (List<Coords> list : result)
        {
            System.out.println(list);
        }
    }

    public static List<List<Coords>> storeValues(final int[][] labels)
    {
        List<List<Coords>> result = new ArrayList<List<Coords>>();
        List<Coords> coords = null;
        int previousValue = 0;
        for (int x = 0; x < labels.length; x++) 
        {
            for (int y = 0; y < labels[0].length; y++) 
            {
                int value = labels[x][y];
                if ((x == 0 && y == 0) || previousValue != value)
                {
                    coords = new ArrayList<Coords>();
                    result.add(coords);
                }
                coords.add(new Coords(x,y));
                previousValue = value;
            }
        }
        return result;
    }


    public static List<List<Coords>> storeValuesSorting(final int[][] labels) 
    {
      List<Coords> sortedCoords = new ArrayList<Coords>();
      for (int x = 0; x < labels.length; x++) 
      {
          for (int y = 0; y < labels[0].length; y++) 
          {
              sortedCoords.add(new Coords(x,y));
          }
      }
      Collections.sort(sortedCoords, new Comparator<Coords>()
      {
          @Override
          public int compare(Coords c0, Coords c1)
          {
              int v0 = labels[c0.x][c0.y];
              int v1 = labels[c1.x][c1.y];
              return Integer.compare(v0, v1);
          }

      });
      List<List<Coords>> result = new ArrayList<List<Coords>>();
      List<Coords> coords = null;
      int previousValue = 0;
      for (int i=0; i<sortedCoords.size(); i++) 
      {
          Coords c = sortedCoords.get(i);          
          int value = labels[c.x][c.y];
          if (i == 0 || previousValue != value)
          {
              coords = new ArrayList<Coords>();
              result.add(coords);
          }
          coords.add(c);
          previousValue = value;
      }
      return result;
    }

}