# Sorting Algorithms¶

That has a paragraph about a main subject and is set when the ‘=’ is at least the same length of the title itself.

## Merge Sort¶

This is the basic method i should master, the top-down merge_sort implementation:

```def merge_sort(nums):
def merge(leftnums, rightnums):
i,j = 0,0
res = []
while(i<len(leftnums) and j <len(rightnums)):
if leftnums[i]<rightnums[j]:
res.append(leftnums[i])
i += 1
else:
res.append(rightnums[j])
j += 1
while(i<len(leftnums)):
res.append(leftnums[i])
i += 1
while (j < len(rightnums)):
res.append(rightnums[j])
j += 1
return res
if len(nums)==1:
return nums

mid = len(nums)/2
leftnums = merge_sort(nums[:mid])
rightnums = merge_sort(nums[mid:])
return merge(leftnums, rightnums)

i write megersort, buble sort, insertion sort and selection sort today.

however, computer crashes!!! damn!
```

## Quick Sort¶

This function takes last element as pivot, places the pivot element at its correct position in sorted array, and places all smaller (smaller than pivot) to left of pivot and all greater elements to right of pivot.

Implementation:

```def partition(arr,low,high):
i = ( low-1 )         # index of smaller element
pivot = arr[high]     # pivot

for j in range(low , high):

# If current element is smaller than or
# equal to pivot
if   arr[j] <= pivot:

# increment index of smaller element
i = i+1
arr[i],arr[j] = arr[j],arr[i]

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

# The main function that implements QuickSort
# arr[] --> Array to be sorted,
# low  --> Starting index,
# high  --> Ending index

# Function to do Quick sort
def quickSort(arr,low,high):
if low < high:

# pi is partitioning index, arr[p] is now
# at right place
pi = partition(arr,low,high)

# Separately sort elements before
# partition and after partition
quickSort(arr, low, pi-1)
quickSort(arr, pi+1, high)
```