Sorting an array is a common task in computer programming and is used in a variety of applications. Sorting is the process of arranging elements of an array in a particular order, either ascending or descending. In Python, the inbuilt "sort()" function is used to sort arrays, but sometimes you may need to sort arrays without using the built-in function. This article will provide you with a detailed explanation of how to sort arrays without using the inbuilt sort function in Python, along with code examples to help you understand the concepts better.

There are several algorithms that can be used to sort arrays without using the built-in sort function in Python. Some of the most commonly used algorithms are:

- Bubble sort
- Insertion sort
- Selection sort
- Quick sort
- Merge sort

Each of these algorithms has its own advantages and disadvantages, and the choice of algorithm depends on the specific requirements of your application. In this article, we will focus on the first three algorithms, which are the most basic sorting algorithms.

- Bubble Sort:

Bubble sort is a simple sorting algorithm that compares adjacent elements of the array and swaps them if they are in the wrong order. This process is repeated until the array is sorted. The algorithm gets its name from the way the elements "bubble" to the top of the array as they are sorted. The time complexity of the bubble sort algorithm is O(n^2), making it inefficient for large arrays. However, it is easy to understand and implement, making it a good choice for small arrays or educational purposes.

Here is the Python code for the bubble sort algorithm:

```
def bubbleSort(arr):
n = len(arr)
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j]
return arr
```

- Insertion Sort:

Insertion sort is another simple sorting algorithm that is similar to how we sort a deck of cards. The algorithm maintains a sorted sublist in the lower portion of the array, and the unsorted sublist in the higher portion of the array. At each iteration, the algorithm selects an element from the unsorted sublist and inserts it into the correct position in the sorted sublist. The time complexity of the insertion sort algorithm is O(n^2), making it inefficient for large arrays. However, it is efficient for small arrays or arrays that are already partially sorted.

Here is the Python code for the insertion sort algorithm:

```
def insertionSort(arr):
for i in range(1, len(arr)):
key = arr[i]
j = i-1
while j >= 0 and key < arr[j] :
arr[j + 1] = arr[j]
j -= 1
arr[j + 1] = key
return arr
```

- Selection Sort:

Selection sort is another simple sorting algorithm that works by repeatedly finding the minimum element from the unsorted portion of the array and swapping it with the first element of the unsorted portion. The time complexity of the selection sort algorithm is O(n^2), making it inefficient for large arrays. However, it is simple to understand and implement, making it a good choice for small arrays or educational purposes.

Here is the Python code for the selection sort algorithm:

```
4. Quick Sort:
Quick sort is a divide-and-conquer algorithm that works by selecting a pivot element from the array and partitioning the other elements into two sub-arrays, according to whether they are less than or greater than the pivot. The sub-arrays are then sorted recursively. Quick sort is one of the most efficient sorting algorithms, with a time complexity of O(n log n) on average. However, it can also perform poorly if the pivot is not chosen carefully, leading to an O(n^2) time complexity.
Here is the Python code for the quick sort algorithm:
```

def quickSort(arr, low, high):

if low < high:

pi = partition(arr, low, high)

quickSort(arr, low, pi-1)

quickSort(arr, pi+1, high)

return arr

def partition(arr, low, high):

pivot = arr[high]

i = low-1

for j in range(low, high):

if arr[j] <= pivot:

i = i+1

arr[i], arr[j] = arr[j], arr[i]

arr[i + 1], arr[high] = arr[high], arr[i + 1]

return i + 1

```
5. Merge Sort:
Merge sort is another divide-and-conquer algorithm that works by dividing the array into two halves, sorting each half recursively, and then merging the two sorted halves into one sorted array. The time complexity of the merge sort algorithm is O(n log n), making it one of the most efficient sorting algorithms. The main disadvantage of the merge sort algorithm is that it requires additional memory to store the sub-arrays, making it less suitable for memory-constrained systems.
Here is the Python code for the merge sort algorithm:
```

def mergeSort(arr):

if len(arr) > 1:

mid = len(arr)//2

L = arr[:mid]

R = arr[mid:]

mergeSort(L)

mergeSort(R)

i = j = k = 0

while i < len(L) and j < len(R):

if L[i] < R[j]:

arr[k] = L[i]

i += 1

else:

arr[k] = R[j]

j += 1

k += 1

while i < len(L):

arr[k] = L[i]

i += 1

k += 1

while j < len(R):

arr[k] = R[j]

j += 1

k += 1

return arr

```
In conclusion, sorting arrays is a common task in computer programming and there are several algorithms that can be used to sort arrays without using the built-in sort function in Python. The choice of algorithm depends on the specific requirements of your application, such as time and memory constraints, the size of the array, and the degree of sorting. Each of the algorithms discussed in this article has its own advantages and disadvantages, and it is important to understand them before choosing the best algorithm for your application.
## Popular questions
1. What is the purpose of sorting an array in Python?
The purpose of sorting an array in Python is to arrange its elements in a specific order, such as ascending or descending. Sorting arrays can be useful in many different applications, such as searching for elements in an array, eliminating duplicates, and making data easier to visualize and analyze.
2. What are some algorithms for sorting arrays in Python without using the built-in `sort` function?
There are several algorithms for sorting arrays in Python without using the built-in `sort` function, including bubble sort, selection sort, insertion sort, quick sort, and merge sort. Each algorithm has its own advantages and disadvantages, and the choice of algorithm depends on the specific requirements of the application.
3. How does bubble sort work?
Bubble sort works by repeatedly comparing adjacent elements in an array and swapping them if they are in the wrong order. The process is repeated until all elements in the array are in the correct order. Bubble sort has a time complexity of O(n^2), making it inefficient for large arrays.
4. What is the time complexity of the merge sort algorithm?
The time complexity of the merge sort algorithm is O(n log n). This makes it one of the most efficient sorting algorithms, but it also requires additional memory to store the sub-arrays, making it less suitable for memory-constrained systems.
5. What are the advantages and disadvantages of using quick sort to sort an array in Python?
The main advantage of using quick sort to sort an array in Python is its efficiency, with a time complexity of O(n log n) on average. The main disadvantage of quick sort is that it can perform poorly if the pivot is not chosen carefully, leading to an O(n^2) time complexity. It is important to understand the strengths and weaknesses of quick sort before choosing it as the sorting algorithm for your application.
### Tag
Algorithms
```