1) Assuming the data in 2 dim array. (2 Columns: FROM 
destination & TO destination)
2) Sort the array (any standard sorting logic) using column 
1 i.e. FROM destination.
3) Take "TO" destination value of row 1 and use binary 
search to search its match in "FROM" destination column 
from row 2 to n
	If match found, adjust that row as row 2. (Swap 
pointers in place of physical data)
		Take "TO" destination value of row 2 and 
use binary search to search its match in "FROM" destination 
column from row 3 to n
		continue this logic till as long as a match 
is found. 
		
		if match not found. 
		Resort the remaining unadjusted rows 
using "TO destination" column.
			Take "From" destination value of 
row 1 and use binary search to search its match in "To" 
column in all unadjusted rows. 
			Match must be found otherwise data 
incorrect. adjust that row as row -1. (Swap pointers in 
place of physical data)
			Continue this till end of the 
array. 
			
			Now you have the sorted list. 


I am sure there can better ways to achieve the same.

actually, you have a trip going in and out of each city 
except the final to (sink) and from (source) cities. the 
source and the sink appear only once in the table, the 
source in the first column, sink in the second. this can be 
found by reading the table once. 

then each city must appear exactly once in the two columns.
so you can defenitely take no wrong trip and get stuck so 
simplest thing to do is to start looking for the only 
possible next flight in the table, starting from original 
source. this will take you to your destination in n^2 
complexity. 

so maybe we can use some clever sorting knowing the maximum 
letters in each city and sorting them alphabetically or we 
can use some hashmap. one of these might do it in nlogn 
probably but a bit dont feel like thinking too much. 

if the flights are sorted you can definitely do it in nlogn 
since you will use binary search to find the next flight in 
the sorted array.which is n times logn.

hope this helped.