Question

I have a problem sorting the contents of a 2D integer array (not ArrayList) in Java. My problem array path_info[ ][ ] looks something like this:

Node_x Node_y Path_ID Port_x Port_y
  4      6      500     3       2
  6      8      500     3       2      
  4      9      501     2       3
  9      3      501     2       2      
  2      3      502     3       2      
  1      5      503     2       3 
  5      2      503     2       2

Each row means: node_x to node_y on Path_ID through Port_x to Port_y. Please note, each path can be one or more rows in the table.

This array is the resultant array from a routing algorithm to reach node 1 from node 8 on an undirected unweighted graph.

To reach from a source node to a destination node; for example node 1 from node 8 in the table, the path_IDs are 500, 501, 502 and 503 (PATH_IDs already sorted in column Path_ID). The problem is that I want this array to be sorted in such a way that the source node is the first node of the column “Node_x” and the destination node is the last node .of the column “Node_y”. And all the intermediate rows and columns sorted appropriately.

The resultant array should look like this (when source node is 8 and destination node is 1):

Node_x Node_y Path_ID Port_x Port_y
  8      6      500     2      3
  6      4      500     2      3     
  4      9      501     2      3
  9      3      501     2      2
  3      2      502     2      3
  2      5      503     2      2
  5      1      503     3      2

I have not started writing code yet so do not have a snippet to paste. I am still trying to figure out how to achieve this. Could someone please help me?

Answer 1

Assuming your algorithm worked correctly, you shouldn’t ever be visiting the same node more than once. So you can just greedily look for the right nodes, but you need a good data structure so you don’t loop incessantly. This code assumes that path_info[index][0] is node_x, and path_info[index][1] is node_y. Try something like this, which runs in O(n) time for each loop:

import java.util.*;

public class GraphSorter {
  public static void main(String[] args) {
    int[][] graph = new int[][]{{9, 3}, {6, 4}, {3, 2}, {8, 6}, {5, 1}, {4, 9}, {2, 5} }; 
    LinkedList<int[]> myList = path(graph, 8);
    for (int[] edge : myList) {
      System.out.println(Arrays.toString(edge));
    }
  }

  public static LinkedList<int[]> path(int[][] path_info, int source) {
    HashMap<Integer, int[]> nodeXmap = new HashMap<Integer, int[]>();
    HashMap<Integer, int[]> nodeYmap = new HashMap<Integer, int[]>();
    LinkedList<int[]> foundPath = new LinkedList<int[]>();

    for(int i = 0; i < path_info.length; i++) {
      // We already found an edge with this node_x edge, turn it around
      if(nodeXmap.containsKey(path_info[i][0])) {
        int tmp = path_info[i][0];
        path_info[i][0] = path_info[i][1];
        path_info[i][1] = tmp;
      }
      nodeXmap.put(path_info[i][0], path_info[i]);
      nodeYmap.put(path_info[i][1], path_info[i]);
    }

    int current = source;
    // Use our maps to lookup where the next edge exists in our path,
    // since our input is guaranteed to be unique
    for(int i = 0; i < path_info.length; i++) {
      int[] currentEdge = nodeXmap.get(current);
      if (currentEdge == null) {
        currentEdge = nodeYmap.get(current);
        current = currentEdge[0];
      } else {
        current = currentEdge[1];
      }
      foundPath.add(currentEdge);
      nodeXmap.remove(currentEdge[0]);
      nodeYmap.remove(currentEdge[1]);
    }

    return foundPath;
  }
}