1. def insertion_sort(A, r = False):
2.         for i in range(1,len(A)):
3.                 k = A[i]
4.                 j = i - 1
5.                 while j>=0 and ( (A[j] > k and r) or (A[j] < k and not r ) ):
6.                         A[j + 1] = A[j]
7.                         j = j - 1
8.                 A[j + 1] = k
9.         return A
10.        
11. def bubble_sort(A, r = False):
12.         for i in range(len(A)):
13.                 print(A)
14.                 for j in range(len(A) - i - 1):
15.                         if A[j] > A[j+1]:
16.                                 t = A[j]
17.                                 A[j] = A[j+1]
18.                                 A[j+1] = t
19.         return A
20.        
21.        
22. def quick_sort(A, p, r):
23.         def partition(p, r):
24.                 x = A[p]
25.                 while True:
26.                         while A[p] < x:
27.                                 p = p + 1
28.                         while A[r] > x:
29.                                 r = r - 1
30.                         if p < r:
31.                                 t = A[r]
32.                                 A[r] = A[p]
33.                                 A[p] = t
34.                                 p = p + 1
35.                                 r = r - 1
36.                         else:
37.                                 return r
38.         if p < r:
39.                 q = partition(p, r)
40.                 quick_sort(A, p, q)
41.                 quick_sort(A, q+1, r)
42.                
43. A = [4,2,1,6,7]
44. quick_sort(A, 0, len(A) - 1)
45. print(A)
46. #print(insertion_sort(A, False))
47.  
48. #print(bubble_sort(A))