Ttykuu

I have this sample data:

let trips = [
 
 from: "DEN",
 to: "JFK"
 ,
 
 from: "SEA",
 to: "DEN"
 ,
 
 from: 'JFK',
 to: 'SEA'
 ,
];

and my origin is 'JFK', I want to sort the list by how I have traveled. So for instance, this should be the end result:

let trips = [
 
 from: 'JFK',
 to: 'SEA'
 ,
 
 from: "SEA",
 to: "DEN"
 ,
 
 from: "DEN",
 to: "JFK"
 ,
];

My solution works but it's not very well written, but I tried!

function sortByLinked(trips, origin = 'JFK') 
 let sortedArray = [];

 let first = trips.filter(trip => trip.from === origin)[0];
 sortedArray.push(first);

 for(var i = 0; i < trips.length; i++) 
 if(sortedArray[0].to === trips[i].from) 
 sortedArray.push(trips[i]);
 
 

 for(var i = 0; i < trips.length; i++) 
 if(sortedArray[1].to === trips[i].from) 
 sortedArray.push(trips[i]);
 
 

 return sortedArray;


sortByLinked(trips) 

Your solution only works if there's exactly 3 trips. After you find the first trip, put it at the front of the array and then find each subsequent one but instead of using a for loop like you're doing there are other ways to find the next trip like using Array.map() or Array.filter().

Here's one way to sort it in place and can handle any number of trips greater than 1.

function sortByLinked(trips, origin = 'JFK') 

 // this will be useful
 function swap(array, index1, index2)
 let temp = array[index1];
 array[index1] = array[index2];
 array[index2] = temp;
 

 // find first one
 let first = trips.filter(trip => trip.from === origin)[0];

 // put him in the front of the list
 swap(trips, trips.map(trip => trip.from).indexOf(first.from), 0);

 // sort it in place
 for(let i=1; i<trips.length; i++)
 swap(trips, i, trips.map(trip => trip.from).indexOf(trips[i-1].to));
 

It would be good if your function could work for more than 3 trips.

And for larger chains of trips it becomes important to make it efficient. It is not efficient to search for the next trip by scanning the whole array. This will make the solution have O(n²) time complexity. So I would suggest creating a Map first, so that you can access a trip by its from property in constant time:

function sortByLinked(trips, origin = "JFK") 
 const map = new Map(trips.map(trip => [trip.from, trip]));
 const result = [];
 for (let trip; trip = map.get(origin); origin = trip.to) 
 result.push(trip);
 map.delete(origin);
 
 return result;


const trips = [from: "DEN",to: "JFK",from: "SEA",to: "DEN",from: 'JFK', to: 'SEA'];
const sorted = sortByLinked(trips, "JFK");
console.log(sorted);