add some sort codes

code@xukaixuan/basic_theory/sort/bubble_sort.py

@@ -0,0 +1,19 @@
+def bubble_sort(arr):
+    swapped = True
+    x = -1
+    while swapped:
+        swap = False
+        x += 1
+        for i in range(1, n - x):
+            if arr[i - 1] > arr[i]:
+                arr[i - 1], arr[i] = arr[i], arr[i - 1]
+                swapped = True
+
+    return arr
+
+
+def test():
+    print(bubble_sort([1, 3, 4, 6, 0, 1, 4, 2]))
+
+
+test()

code@xukaixuan/basic_theory/sort/insert_sort.py

@@ -0,0 +1,14 @@
+def insert_sort(arr):
+    """
+    每次循环迭代中，插入排序从数组中删除一个元素。
+    然后再一个已经有序的数组中找到该元素的位置，并将其插入其中。
+    """
+    for i in range(len(arr)):
+        cur = arr[i]
+        pos = i
+
+        while pos >0 and arr[pos-1] > cur:
+            arr[pos] = arr[pos-1]
+            pos = pos -1
+        arr[pos] = cur
+    return arr

code@xukaixuan/basic_theory/sort/merge_sort.py

@@ -0,0 +1,24 @@
+"""
+
+"""
+def merge_sort(arr):
+    if len(arr)<= 1:
+        return arr
+    mid  = len(arr)//2
+    left,right = merge_sort(arr[:mid]),merge_sort(arr[mid:])
+    return merge(left,right,arr.copy())
+
+def merge(left,right,merged):
+    l_cur,r_cur = 0,0
+    while l_cur<len(left) and r_cur <len(right):
+        if left[l_cur]<= right[r_cur]:
+            merged[l_cur+r_cur] = left[l_cur]
+            l_cur+=1
+        else:
+            merged[l_cur+r_cur] = right[r_cur]
+            r_cur+=1
+        for l_cur in range(l_cur,len(left)):
+            merged[l_cur+r_cur]=left[l_cur]
+        for r_cur in range(r_cur,len(right)):
+            merged[l_cur+r_cur]=right[r_cur]
+    return merged

code@xukaixuan/basic_theory/sort/quick_sort.py

@@ -0,0 +1,22 @@
+def partition(array, begin, end):
+    # 选取数组最后一位元素作为中转元素
+    pivot = array[end]
+    i = begin
+    for j in range(begin, end):
+        if array[j] < pivot:
+            array[i], array[j] = array[j], array[i]
+            i += 1
+    array[i], array[end] = array[end], array[i]
+    return i
+
+
+def quick_sort_recursion(array, begin, end):
+    if begin >= end:
+        return
+    pivot_idx = partition(array, begin, end)
+    quick_sort_recursion(array,begin,pivot_idx-1)
+    quick_sort_recursion(array,pivot_idx+1,end)
+
+
+def quick_sort(arrar):
+    return quick_sort_recursion(arrar,0,len(arrar)-1)

code@xukaixuan/basic_theory/sort/readme.md

@@ -0,0 +1,27 @@
+# 排序算法
+## 冒泡排序
+ + 冒泡排序属于原地排序算法，空间复杂度为**O(1)**
+ + 冒泡排序属于**稳定排序**（相同值时，两元素的相对位置不变）
+ + 时间复杂度为**O(n<sup>2</sup>)**
+## 插入排序
+  + 插入排序是原地排序，空间复杂度为O(1)
+  + 插入排序属于**稳定排序**
+  + 插入排序时间复杂度为**O(n<SUP>2)**
+
+## 选择排序
++ 选择排序属于原地排序，空间复杂度为**O(1)**
++ 选择排序**不属于稳定排序**
++ 选择排序的时间复杂度为为**O(n<SUP>2)**
+
+## 归并排序
++ 归并排序是稳定的排序算法
++ 归并排序的时间复杂度为O(nlogn)
++ 空间复杂度为O(n)
+
+## 快速排序
++ 原地排序算法，空间复杂度为O(1)_优于归并排序_
++ 时间复杂度为O(nlogn)
++ 稳定排序算法
+
+
+归并排序，与快速排序都是用分治思想，其区别可参考 ![归并排序与快速排序区别](归并与快速排序区别示意图.jpg)

code@xukaixuan/basic_theory/sort/select_sort.py

@@ -0,0 +1,10 @@
+def select_sort(arr):
+    for i in range(len(arr)):
+       minum = i
+       for j in range(i+1,len(arr)):
+           if arr[j] < arr(minum):
+               minum = j
+        arr[minum] ,arr[i] = arr[i],arr[minum]
+     return arr
+
+print(select_sort([0,1,8,3,4,6,3,5]))