添加了python版本代码

为数据结构和算法文件夹下的代码增加了python语言版本

animation-simulation/数据结构和算法/归并排序.md

@@ -54,6 +54,8 @@
 
 下面我们看代码吧。
 
+Java Code:
+
 ```java
 class Solution {
     public int[] sortArray(int[] nums) {
@@ -90,6 +92,48 @@ class Solution {
 }
 ```
 
+Python Code:
+
+```python
+from typing import List
+class Solution:
+    def sortArray(self, nums: List[int])->List[int]:
+        self.mergeSort(nums, 0, len(nums) - 1)
+        return nums
+
+    def mergeSort(self, arr: List[int], left: int, right: int):
+        if left < right:
+            mid = left + ((right - left) >> 1)
+            self.mergeSort(arr, left, mid)
+            self.mergeSort(arr, mid + 1, right)
+            self.merge(arr, left, mid, right) 
+    
+    # 归并
+    def merge(self, arr: List[int], left: int, mid: int, right: int):
+        # 第一步，定义一个新的临时数组
+        temparr = [0] * (right - left + 1)
+        temp1 = left
+        temp2 = mid + 1
+        index = 0
+        # 对应第二步，比较每个指针指向的值，小的存入大集合
+        while temp1 <= mid and temp2 <= right:
+            if arr[temp1] <= arr[temp2]:
+                temparr[index] = arr[temp1]
+                index += 1
+                temp1 += 1
+            else:
+                temparr[index] = arr[temp2]
+                index += 1
+                temp2 += 1
+        # 对应第三步，将某一集合的剩余元素存到大集合中
+        if temp1 <= mid:
+            temparr[index: index + mid - temp1 + 1] = arr[temp1: temp1 + mid - temp1 + 1]
+        if temp2 <= right:  
+            temparr[index: index + right - temp2 + 1] = arr[temp2: temp2 + right - temp2 + 1]
+        
+        # 将大集合的元素复制回原数组
+        arr[left: left + right- left + 1] = temparr[0: right - left + 1]
+```
 **归并排序时间复杂度分析**
 
 我们一趟归并，需要将两个小集合的长度放到大集合中，则需要将待排序序列中的所有记录扫描一遍所以时间复杂度为O(n)。归并排序把集合一层一层的折半分组，则由完全二叉树的深度可知，整个排序过程需要进行 logn（向上取整）次,则总的时间复杂度为 O(nlogn)。另外归并排序的执行效率与要排序的原始数组的有序程度无关，所以在最好，最坏，平均情况下时间复杂度均为 O(nlogn) 。虽然归并排序时间复杂度很稳定，但是他的应用范围却不如快速排序广泛，这是因为归并排序不是原地排序算法，空间复杂度不为 O(1)，那么他的空间复杂度为多少呢？
@@ -134,6 +178,8 @@ class Solution {
 
 注：递归法和迭代法的 merge函数代码一样。
 
+Java Code:
+
 ```java
 class Solution {
     public int[] sortArray (int[] nums) {
@@ -162,7 +208,7 @@ class Solution {
     }
      public void merge (int[] arr,int left, int mid, int right) {
         //第一步，定义一个新的临时数组
-        int[] temparr = new int[right -left + 1];
+        int[] temparr = new int[right - left + 1];
         int temp1 = left, temp2 = mid + 1;
         int index = 0;
         //对应第二步，比较每个指针指向的值，小的存入大集合
@@ -182,3 +228,55 @@ class Solution {
 }
 ```
 
+Python Code:
+
+```python
+from typing import List
+class Solution:
+    def sortArray(self, nums: List[int])->List[int]:
+        # 代表子集合大小，1，2，4，8，16.....
+        k = 1
+        leng = len(nums)
+        while k < leng:
+            self.mergePass(nums, k, leng)
+            k *= 2
+            print(nums)
+        return nums
+
+    def mergePass(self, array: List[int], k: int, leng: int):
+        i = 0
+        while i < leng - 2 * k:
+            # 归并
+            self.merge(array, i, i + k - 1, i + 2 * k - 1)
+            i += 2 * k
+        
+        # 归并最后两个序列
+        if i + k < leng:
+            self.merge(array, i, i + k - 1, leng - 1)
+
+    # 归并
+    def merge(self, arr: List[int], left: int, mid: int, right: int):
+        # 第一步，定义一个新的临时数组
+        temparr = [0] * (right - left + 1)
+        temp1 = left
+        temp2 = mid + 1
+        index = 0
+        # 对应第二步，比较每个指针指向的值，小的存入大集合
+        while temp1 <= mid and temp2 <= right:
+            if arr[temp1] <= arr[temp2]:
+                temparr[index] = arr[temp1]
+                index += 1
+                temp1 += 1
+            else:
+                temparr[index] = arr[temp2]
+                index += 1
+                temp2 += 1
+        # 对应第三步，将某一集合的剩余元素存到大集合中
+        if temp1 <= mid:
+            temparr[index: index + mid - temp1 + 1] = arr[temp1: temp1 + mid - temp1 + 1]
+        if temp2 <= right:  
+            temparr[index: index + right - temp2 + 1] = arr[temp2: temp2 + right - temp2 + 1]
+        
+        # 将大集合的元素复制回原数组
+        arr[left: left + right- left + 1] = temparr[0: right - left + 1]
+```