# Is it possible to use argsort in descending order

Consider the following code:

```
avgDists = np.array([1, 8, 6, 9, 4])
ids = avgDists.argsort()[:n]
```

This gives me indices of the `n`

smallest elements. Is it possible to use this same `argsort`

in descending order to get the indices of `n`

highest elements ?

If you negate an array, the lowest elements become the highest elements and vice-versa. Therefore, the indices of the `n`

highest elements are:

```
(-avgDists).argsort()[:n]
```

Another way to reason about this, as mentioned in the comments, is to observe that the big elements are coming *last* in the argsort. So, you can read from the tail of the argsort to find the `n`

highest elements:

```
avgDists.argsort()[::-1][:n]
```

Both methods are *O(n log n)* in time complexity, because the `argsort`

call is the dominant term here. But the second approach has a nice advantage: it replaces an *O(n)* negation of the array with an *O(1)* slice. If you're working with small arrays inside loops then you may get some performance gains from avoiding that negation, and if you're working with huge arrays then you can save on memory usage because the negation creates a copy of the entire array.

Note that these methods do not always give equivalent results: if a stable sort implementation is requested to `argsort`

, e.g. by passing the keyword argument `kind='mergesort'`

, then the first strategy will preserve the sorting stability, but the second strategy will break stability (i.e. the positions of equal items will get reversed).

From: stackoverflow.com/q/16486252