Javascript sorting algorithm

There is an easy way to solve your problem if the array is valid (all team have exactly the same disciplines) and if we assume that it's initially sorted the way it looks in your question; if not a simple sort() could ensure that:

// Ensure that the array is initially sorted by teams and each team by discipline.sortOrder
schedule.sort((a, b) => (a.team.id == b.team.id) 
    ? a.discipline.sortOrder - b.discipline.sortOrder 
    : a.team.id - b.team.id
)

Then all you need now is loop over the array one time the following way:

// Loop wisely over the array and constructe the sorted one 
const disciplineCount = 3, // <- because in your example there are 0, 1 and 2
      size = schedule.length
let i = 0,
    step = 1,
    sorted = []

while (step <= size) {
    sorted.push(schedule[i])
    i = (step % disciplineCount == 0)
        ? i + 1
        : (i + disciplineCount + 1) % size
    step ++
}

Now sorted will contain your desired result.

Note that disciplineCount value should be dynamic depending on your array !

Hope this helps :D

I think this should work, but with constraints:

function sortResults (results) {
  const maxSortOrder = results.reduce((maxSoFar, { discipline: { sortOrder } }) => Math.max(maxSoFar, sortOrder), 0)

  const defaultTeam = { team: { id: '*****' }, discipline: { sortOrder: -1 } } // this is just to ensure a match the first time round
  const sortedResults = results.reduce(({ array, remaining, previous }) => {
    const nextSortOrder = (previous.discipline.sortOrder + 1) % (maxSortOrder + 1)
    const nextResultInd = remaining.findIndex(({ team: { id }, discipline: { sortOrder } }) => {
      return id !== previous.team.id && sortOrder === nextSortOrder
    })

    if (nextResultInd === -1) throw new Error('Result set cannot be sorted as required')

    previous = remaining.splice(nextResultInd, 1)[0]
    array.push(previous)

    return { array, remaining, previous }
  }, { array: [], remaining: results.slice(0), previous: defaultTeam })

  return sortedResults.array
}

It's inflexible in terms of sort order, so that if you've just had discipline 0 then you must have discipline 1 next, which if there's only one team to go and they only have discipline 2 still to do will result in an error when realistically you could just skip over discipline 1 in that case. However, I think it should be easy to relax this constraint based on your requirements, but I'll let you do that.