归并排序，快速排序

Author: tianqing.liang

README.md

@@ -1,6 +1,7 @@
 # AlgorithmAndDataArchitecture
 
-<h3>使用Flutter的Dart语言重写数据结构与算法</h3>
+<h3>使用Python、Flutter的Dart语言重写数据结构与算法</h3>
+
 
 1. **[Dart,Python]线性搜索**
 2. **[Dart,Python]选择排序**
@@ -9,7 +10,7 @@
 5. 链表，链表实现栈，链表实现队列
 6. 递归
 7. 归并排序
-8. 快速排序
+8. **[Dart,Python]快速排序**
 9. 二分搜索
 10. 二分搜索树
 11. 集合 和 映射

python/linkedlist.py

@@ -0,0 +1,154 @@
+class __Node(object):
+    
+    def __init__(self,value=None,next=None):
+        self.value = value;
+        self.next = next;
+    
+    def __str__(self):
+        return self.value;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# class LinkedList<T> {
+#   _Node? _dummyHead;
+#   late int _size;
+
+#   LinkedList() {
+#     _dummyHead = new _Node.withEmpty();
+#     _size = 0;
+#   }
+
+#   int getSize() {
+#     return _size;
+#   }
+
+#   bool isEmpty() {
+#     return _size == 0;
+#   }
+
+#   remove(int index){
+#     if (index < 0 || index > _size) {
+#       throw Exception("Remove Failed,Illegal index");
+#     }
+#     _Node? prev = _dummyHead;
+#     for(var i =0;i<index ;i++){
+#       prev = prev?.next;
+#     }
+#     _Node? retNode = prev!.next;
+#     prev.next = retNode!.next;
+#     retNode.next = null;
+#     _size --;
+#     return retNode.t;
+#   }
+
+#   //从链表中删除第一个元素，返回删除元素
+#   T? removeFirst(){
+#     remove(0);
+#   }
+#   //从链表中删除第一个元素，返回删除元素
+#   T? removeLast(){
+#     remove(_size -1);
+#   }
+
+
+#   //在链表的index位置添加新的元素e
+#   add(int index, T t) {
+#     if (index < 0 || index > _size) {
+#       throw Exception("Add Failed,Illegal index");
+#     }
+# //      if(index == 0){
+# //         addFirst(t);
+# //      }else{
+#     _Node? prev = _dummyHead;
+#     for (var i = 0; i < index; i++) {
+#       prev = prev?.next;
+#     }
+#     _Node _node = new _Node.wihtHead(t);
+#     _node.next = prev?.next;
+#     prev?.next = _node;
+#     _size++;
+# //      }
+#   }
+
+#   addLast(T t) {
+#     add(_size, t);
+#   }
+
+#   addFirst(T t) {
+# //      _Node _node =new _Node.head(t);
+# //      _node.next = _head;
+# //      _head = _node;
+#     add(0, t);
+#   }
+
+#   //获取链表第index位置的元素
+#   T get(int index){
+#     if (index < 0 || index > _size) {
+#       throw Exception("Get Failed,Illegal index");
+#     }
+#     _Node? cur = _dummyHead!.next;
+#     for(var i=0;i<index;i++){
+#       cur = cur!.next;
+#     }
+#     return cur!.t;
+#   }
+
+#   T getFirst(){
+#     return get(0);
+#   }
+#   T getLast(){
+#     return get(_size-1);
+#   }
+#   set(int index,T t){
+#     if (index < 0 || index > _size) {
+#       throw Exception("Set Failed,Illegal index");
+#     }
+#     _Node? cur = _dummyHead!.next;
+#     for(var i =0;i<index;i++){
+#       cur = cur!.next;
+#     }
+#     cur!.t= t;
+#   }
+
+#   bool contains(T t){
+#     _Node? cur = _dummyHead!.next;
+#     for(var i =0;i<_size-1;i++){
+#       if(cur!.t.compareTo(t)){
+#         return true;
+#       }
+#       cur = cur.next;
+#     }
+#     return false;
+#   }
+
+#   @override
+#   String toString() {
+#     StringBuffer res =new StringBuffer();
+#     for(_Node? cur = _dummyHead!.next ; cur != null ; cur = cur.next){
+#       res.write(cur);
+#       res.write("->");
+#     }
+#     res.write("NULL");
+#     return res.toString();
+#   }
+# }
+
+

python/multiSort.py

@@ -66,22 +66,75 @@ def shellSort(sortList):
                 j = j- dist
         dist = dist//2
     return sortList
+
+#快速排序
+def quickSort(sortList,left,right):
+    if left<right:
+        q = partition(sortList,left,right)
+        quickSort(sortList,left,q-1)
+        quickSort(sortList, q+1, right)
+
+def partition(sortList,left,right):
+    i = left-1
+    pivot  = sortList[right]
+    for j in range(left,right):
+        if sortList[j] <= pivot:
+            i +=1
+            sortList[i],sortList[j] = sortList[j],sortList[i]
+    sortList[i+1],sortList[right] = sortList[right],sortList[i+1]
+    return i +1    
+
+# 归并排序
+def merge(arr1, arr2): 
+    result = []
+    while arr1 and arr2:
+        if arr1[0] < arr2[0]:
+            result.append(arr1.pop(0))
+        else:
+            result.append(arr2.pop(0))
+    if arr1:
+        result += arr1
+    if arr2:
+        result += arr2
+    return result
+
+def merge_sort(arr):
+    if len(arr) <= 1:
+        return arr
+    mid = len(arr) // 2
+    return merge(merge_sort(arr[:mid]), merge_sort(arr[mid:]))
+
 # 计算结果，计算时间
 def caculateResultAndTime(name,fuction,randomseed):
-    print("--------------------",name)
+    print("--------------------",name,'\n')
     random.seed(randomseed)
-    sortList = [random.randint(0,100) for _ in range(10)]
+    sortList = [random.randint(0,100) for _ in range(30)]
     print("原始数据：",sortList)
     startTime = time.perf_counter()
     fuction(sortList)
     endTime = time.perf_counter()
-    print("排序结果:",sortList,' 花费时间：',endTime-startTime)
+    print("排序结果:",sortList,'\n花费时间：',endTime-startTime)
+    print("-------------------- 结束\n")
 
 if __name__ == '__main__':
     caculateResultAndTime("希尔排序",shellSort,88)
     caculateResultAndTime("插入排序",insertionSort,89)
     caculateResultAndTime("冒泡排序",bubble_sort,90)
     caculateResultAndTime("选择排序",selectionSort,91)
+    caculateResultAndTime("归并排序",selectionSort,93)
+
+    print("--------------------快速排序")
+    random.seed(92)
+    sortList = [random.randint(0,100) for _ in range(15)]
+    print("原始数据：",sortList)
+    startTime = time.perf_counter()
+    quickSort(sortList, 0, len(sortList)-1)
+    endTime = time.perf_counter()
+    print("排序结果:",sortList,' 花费时间：',endTime-startTime)
+    print("-------------------- 结束\n")
+
+
+