# Variations in different Sorting techniques in Python

• Difficulty Level : Medium
• Last Updated : 17 Nov, 2020

These are all different types for sorting techniques that behave very differently. Let’s study which technique works how and which one to use.

Let ‘a’ be a numpy array

• a.sort()
(i) Sorts the array in-place & returns None
(ii) Return type is None
(iii) Occupies less space. No copy created as it directly sorts the original array
(iv) Faster than sorted(a)

 `# Python code to sort an array in-place``# using a.sort``import` `numpy as np`` ` `# Numpy array created``a ``=` `np.array([``9``, ``3``, ``1``, ``7``, ``4``, ``3``, ``6``])`` ` `# unsorted array print``print``(``'Original array:\n'``, a)`` ` `# Return type is None``print``(``'Return type:'``, a.sort())`` ` `# Sorted array output``print``(``'Original array sorted->'``, a)`

```OUTPUT: For a.sort()
Original array:
[9 3 1 7 4 3 6]
Return type: None
Original array sorted-> [1 3 3 4 6 7 9]
```
• sorted(a)
(i) Creates a new list from the old & returns the new one, sorted
(ii) Return type is a list
(iii) Occupies more space as copy of original array is created and then sorting is done
(iv) Slower than a.sort()

 `# Python code to create a sorted copy using``# sorted()``import` `numpy as np`` ` `# Numpy array created``a ``=` `np.array([``9``, ``3``, ``1``, ``7``, ``4``, ``3``, ``6``])`` ` `# unsorted array print``print``(``'Original array:\n'``, a)``b ``=` `sorted``(a)`` ` `# sorted list returned to b, b type is``#  ``print``(``'New array sorted->'``, b)`` ` `# original array no change``print``(``'Original array->'``, a)`

```OUTPUT:a.sorted()
Original array:
[9 3 1 7 4 3 6]
New array sorted-> [1, 3, 3, 4, 6, 7, 9]
Original array-> [9 3 1 7 4 3 6]
```
• np.argsort(a)
(i) Returns the indices that would sort an array
(ii) Return type is numpy array
(iii) Occupies space as a new array of sorted indices is returned

 `# Python code to demonstrate working of np.argsort``import` `numpy as np`` ` `# Numpy array created``a ``=` `np.array([``9``, ``3``, ``1``, ``7``, ``4``, ``3``, ``6``])`` ` `# unsorted array print``print``(``'Original array:\n'``, a)`` ` `# Sort array indices``b ``=` `np.argsort(a)``print``(``'Sorted indices of original array->'``, b)`` ` `# To get sorted array using sorted indices``# c is temp array created of same len as of b``c ``=` `np.zeros(``len``(b), dtype ``=` `int``)``for` `i ``in` `range``(``0``, ``len``(b)):``    ``c[i]``=` `a[b[i]]``print``(``'Sorted array->'``, c)`

```OUTPUT:np.argsort(a)
Original array:
[9 3 1 7 4 3 6]
Sorted indices of original array-> [2 1 5 4 6 3 0]
Sorted array-> [1 3 3 4 6 7 9]
```
• np.lexsort((b, a))
(i) Perform an indirect sort using a sequence of keys
(ii) Sort by a, then by b
(iii) Return type ndarray of ints Array of indices that sort the keys along the specified axis
(iv) Occupies space as a new array of sorted indices pair wise is returned.

 `# Python code to demonstrate working of ``# np.lexsort()``import` `numpy as np`` ` `# Numpy array created``a ``=` `np.array([``9``, ``3``, ``1``, ``3``, ``4``, ``3``, ``6``]) ``# First column``b ``=` `np.array([``4``, ``6``, ``9``, ``2``, ``1``, ``8``, ``7``]) ``# Second column``print``(``'column a, column b'``)``for` `(i, j) ``in` `zip``(a, b):``    ``print``(i, ``' '``, j)`` ` `ind ``=` `np.lexsort((b, a)) ``# Sort by a then by b``print``(``'Sorted indices->'``, ind)`

```OUTPUT:np.lexsort((b, a))
column a, column b
9   4
3   6
1   9
3   2
4   1
3   8
6   7
Sorted indices-> [2 3 1 5 4 6 0]
```

This article is contributed by SHAURYA UPPAL. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

My Personal Notes arrow_drop_up