Modify

.vscode/launch.json

@@ -0,0 +1,15 @@
+{
+    // 使用 IntelliSense 了解相关属性。 
+    // 悬停以查看现有属性的描述。
+    // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python: 当前文件",
+            "type": "python",
+            "request": "launch",
+            "program": "${file}",
+            "console": "integratedTerminal"
+        }
+    ]
+}

0.1.算法效率衡量.py

@@ -9,9 +9,9 @@
     for b in range(1001):
         c = 1000 - a - b
         if a**2 + b**2 == c**2:
-            print("a:%d, b:%d, c:%d " %(a,b,c))
+            print("a:%d, b:%d, c:%d " % (a, b, c))
 end_time = time.time()
-print("time:%f" %(end_time-start_time))  # 1.31
+print("time:%f" % (end_time-start_time))  # 1.31
 
 print("*"*30)
 # 第二次尝试
@@ -20,8 +20,8 @@
     for b in range(1001-a):
         c = 1000 - a - b
         if a**2 + b**2 == c**2:
-            print("a:%d, b:%d, c:%d " %(a,b,c))
+            print("a:%d, b:%d, c:%d " % (a, b, c))
 end_time = time.time()
-print("time:%f" %(end_time-start_time))  # 0.69
+print("time:%f" % (end_time-start_time))  # 0.69
 
-# 时间复杂度： T(n) = O(n*n*(1+1)) = O(n*n) = O(n2)
+# 时间复杂度： T(n) = O(n*n*(1+1)) = O(n*n) = O(n2)

1.0.Python内置类型性能分析.md

@@ -1,7 +1,10 @@
 # Python内置类型性能分析
+
 ## timeit模块
+
 timeit模块可以用来测试一小段Python代码的执行速度。
-```py
+
+``` py
 class timeit.Timer(stmt='pass', setup='pass', timer=<timer function>)
 ```
 
@@ -12,22 +15,30 @@ stmt参数是要测试的代码语句（statment）；
 setup参数是运行代码时需要的设置；
 
 timer参数是一个定时器函数，与平台有关。
-```
+
+``` 
 timeit.Timer.timeit(number=1000000)
 
 ```
+
 Timer类中测试语句执行速度的对象方法。number参数是测试代码时的测试次数，默认为1000000次。方法返回执行代码的平均耗时，一个float类型的秒数。
 
 # list内置操作的时间复杂度
+
 ![1.0](image/1.0.png)
 
 # dict内置操作的时间复杂度
+
 ![1.1](image/1.1.png)
 
 ## Python的内置数据结构
+
 Python给我们提供了很多现成的数据结构类型，这些系统自己定义好的，不需要我们自己去定义的数据结构叫做Python的内置数据结构，比如列表、元组、字典。
+
 ## Python的扩展数据结构
+
 而有些数据组织方式，Python系统里面没有直接定义，需要我们自己去定义实现这些数据的组织方式，这些数据组织方式称之为Python的扩展数据结构，比如栈，队列等。
+
 ## 算法与数据结构的区别
 
 数据结构只是静态的描述了数据元素之间的关系。

1.1.Python内置类型性能分析.py

@@ -1,21 +1,26 @@
 # _*_ conding: UTF-8 _*_
 from timeit import Timer
 
+
 def test1():
-    l = []
+    L = []
     for i in range(1000):
-        l = l + [i]
+        L = L + [i]
+
 
 def test2():
-    l = []
+    L = []
     for i in range(1000):
-        l.append(i)
+        L.append(i)
+
 
 def test3():
-    l = [i for i in range(1000)]
+    L = [i for i in range(1000)]
+
 
 def test4():
-    l = list(range(1000))
+    L = list(range(1000))
+
 
 t1 = Timer("test1()", "from __main__ import test1")
 print("concat ", t1.timeit(number=1000), "seconds")
@@ -27,14 +32,14 @@ def test4():
 print("comprehension ", t3.timeit(number=1000), "seconds")
 
 t4 = Timer("test4()", "from __main__ import test4")
-print("list range ", t4.timeit(number=1000), "seconds")
+print("List range ", t4.timeit(number=1000), "seconds")
 
 
 """结果：
 concat  1.421693535000486 seconds
 append  0.1010527379994528 seconds
 comprehension  0.036659903999861854 seconds
-list range  0.018424673000481562 seconds
+List range  0.018424673000481562 seconds
 """
 
 print("*"*30)
@@ -46,15 +51,15 @@ def test4():
 pop_end = Timer("x.pop()", "from __main__ import x")
 print("pop_end ", pop_end.timeit(number=1000), "seconds")
 
-list_append = Timer("x.append(1)", "from __main__ import x")
-print("list_append(从后边插入) ", list_append.timeit(number=1000), "seconds")
+List_append = Timer("x.append(1)", "from __main__ import x")
+print("List_append(从后边插入) ", List_append.timeit(number=1000), "seconds")
 
-list_insert = Timer("x.insert(0,1)", "from __main__ import x")
-print("list_insert(从前边插入) ", list_insert.timeit(number=1000), "seconds")
+List_insert = Timer("x.insert(0,1)", "from __main__ import x")
+print("List_insert(从前边插入) ", List_insert.timeit(number=1000), "seconds")
 
 """
 pop_zero  3.0994806850003442 seconds
 pop_end  0.0001244389995918027 seconds
-list_append(从后边插入)  9.197799954563379e-05 seconds
-list_insert(从前边插入)  3.44098534800014 seconds
-"""
+List_append(从后边插入)  9.197799954563379e-05 seconds
+List_insert(从前边插入)  3.44098534800014 seconds
+"""

2.1单链表.py

@@ -6,14 +6,17 @@ class SingleNode(object):
     """
     单链表的节点
     """
-    def __init__(self,item):
+
+    def __init__(self, item):
         # _item 存放数据元素
         self.item = item
         # _next 是下一个节点的标示
         self.next = None
 
+
 class SingleLinkList(object):
     """单链表"""
+
     def __init__(self):
         self._head = None
 
@@ -41,7 +44,7 @@ def travel(self):
             cur = cur.next
         print("")
 
-    def add(self,item):
+    def add(self, item):
         """头部添加元素"""
         # 先创建一个保存item值的节点
         node = SingleNode(item)
@@ -85,7 +88,7 @@ def insert(self, pos, item):
             # 将插入位置的前一个节点的next指向新节点
             pre.next = node
 
-    def remove(self,item):
+    def remove(self, item):
         """删除节点"""
         cur = self._head
         pre = None
@@ -114,17 +117,17 @@ def search(self, item):
             cur = cur.next
         return False
 
+
 if __name__ == "__main__":
     ll = SingleLinkList()
     ll.add(1)
     ll.add(2)           # 头部添加
     ll.append(3)        # 尾部添加
-    ll.insert(2,4)      # 指定位置插入
+    ll.insert(2, 4)      # 指定位置插入
     print("length:", ll.length())
     ll.travel()         # 遍历链表
-    print(ll.search(3)) # 搜索链表是否存在3
-    print(ll.search(5)) # 搜索链表是否存在5
+    print(ll.search(3))  # 搜索链表是否存在3
+    print(ll.search(5))  # 搜索链表是否存在5
     ll.remove(5)        # 删除链表中的item：1
-    print("length:",ll.length())
+    print("length:", ll.length())
     ll.travel()
-

2.2单项循环链表.py

@@ -6,12 +6,14 @@ class Node(object):
     """
     单链表的节点
     """
-    def __init__(self,item):
+
+    def __init__(self, item):
         # _item 存放数据元素
         self.item = item
         # _next 是下一个节点的标示
         self.next = None
 
+
 class SinCycLinkedlist(object):
     """单项循环链表"""
 
@@ -45,7 +47,7 @@ def travel(self):
             print(cur.item)
         print("")
 
-    def add(self,item):
+    def add(self, item):
         """头部添加节点"""
         node = Node(item)
         if self.is_empty():
@@ -144,6 +146,7 @@ def search(self, item):
                 return True
         return False
 
+
 if __name__ == "__main__":
     ll = SinCycLinkedlist()
     ll.add(1)
@@ -157,9 +160,5 @@ def search(self, item):
     print(ll.search(3))
     print(ll.search(7))
     ll.remove(1)
-    print("length:",ll.lengeth())
+    print("length:", ll.lengeth())
     ll.travel()
-
-
-
-

2.3双向链表.py

@@ -3,13 +3,16 @@
 
 class Node(object):
     """双向链表节点"""
+
     def __init__(self, item):
         self.item = item
         self.next = None
         self.prev = None
 
+
 class DLinkList(object):
     """双向链表"""
+
     def __init__(self):
         self._head = None
 
@@ -123,6 +126,7 @@ def remove(self, item):
                     break
                 cur = cur.next
 
+
 if __name__ == "__main__":
     ll = DLinkList()
     ll.add(1)
@@ -138,4 +142,3 @@ def remove(self, item):
     ll.remove(1)
     print("length:", ll.length())
     ll.travel()
-

3.栈.py

@@ -5,8 +5,10 @@
 使用list实现，其中list的append就是栈的push；list的pop就是栈的pop；list的[-1]就是栈的peek
 """
 
+
 class Stack(object):
     """栈"""
+
     def __init__(self):
         self.items = []
 
@@ -30,6 +32,7 @@ def size(self):
         """返回栈的大小"""
         return len(self.items)
 
+
 if __name__ == "__main__":
     stack = Stack()
     stack.push("hello")

4.1队列.py

@@ -6,8 +6,10 @@
 先进先出
 """
 
+
 class Queue(object):
     """队列"""
+
     def __init__(self):
         self.items = []
 

4.2双端队列.py

@@ -4,8 +4,10 @@
 可以在任一端入队和出队
 """
 
+
 class Deque(object):
     """双端队列"""
+
     def __init__(self):
         self.items = []
 
@@ -33,6 +35,7 @@ def size(self):
         """返回队列的大小"""
         return len(self.items)
 
+
 if __name__ == "__main__":
     deque = Deque()
     deque.add_front(1)

5.1冒泡排序.py

@@ -5,14 +5,15 @@
 稳定性：稳定
 """
 
-def bubble_sort(alist):
-    for j in range(len(alist) - 1, 0, -1):
+
+def bubble_sort(a_list):
+    for j in range(len(a_list) - 1, 0, -1):
         # j表示每次遍历需要比较的次数，是逐渐减小的
         for i in range(j):
-            if alist[i] > alist[i+1]:
-                alist[i], alist[i+1] = alist[i+1], alist[i]
+            if a_list[i] > a_list[i+1]:
+                a_list[i], a_list[i+1] = a_list[i+1], a_list[i]
 
 
-li = [54,26,93,17,77,31,44,55,20]
+li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
 bubble_sort(li)
 print(li)

5.2选择排序.py

@@ -5,19 +5,21 @@
 稳定性：不稳定
 """
 
-def selection_sort(alist):
+
+def selection_sort(a_list):
     # 需要进行n-1次选择操作
-    for i in range(len(alist) - 1):
+    for i in range(len(a_list) - 1):
         # 记录最小位置
         min_index = i
-        for j in range(i + 1, len(alist)):
-            if alist[j] < alist[min_index]:
+        for j in range(i + 1, len(a_list)):
+            if a_list[j] < a_list[min_index]:
                 min_index = j
         # 如果选择出的数据不在正确的位置，进行交换
         if min_index != i:
-            alist[i], alist[min_index] = alist[min_index], alist[i]
+            a_list[i], a_list[min_index] = a_list[min_index], a_list[i]
+
 
-alist = [54,226,93,17,77,31,44,55,20]
-print("origin alist:",alist)
-selection_sort(alist)
-print("selection_sort:",alist)
+a_list = [54, 226, 93, 17, 77, 31, 44, 55, 20]
+print("origin a_list:", a_list)
+selection_sort(a_list)
+print("selection_sort:", a_list)