26数据结构day03部分完成

Author: HaoZhang95

26数据结构/day01/__init__.py

@@ -90,28 +90,51 @@ def insert(self, pos, item):
             pre.next = node
 
     def remove(self, item):
+        if self.is_empty():
+            return
+
         cur = self.__head
         pre = None
 
-        while cur is not None:
+        while cur.next is not self.__head:
             if cur.elem == item:
                 # 判断是不是头节点
                 if cur == self.__head:
+                    rear = self.__head
+                    while rear.next is not self.__head:
+                        rear = rear.next
                     self.__head = cur.next
+                    rear.next = self.__head
+
                 else:
                     pre.next = cur.next
-                break
+                return
             else:
                 pre = cur
                 cur = cur.next
 
+        if cur.elem == item:
+            if cur is self.__head:
+                # 链表只有一个节点
+                self.__head = None
+            else:
+                pre.next = cur.next
+
     def search(self, item):
+
+        if self.is_empty():
+            return False
+
         cur = self.__head
-        while cur is not None:
+        while cur.next is not self.__head:
             if cur.elem == item:
                 return True
             else:
                 cur = cur.next
+        # 此时的cur指向最后一个元素
+        if cur.elem == item:
+            return True
+
         return False
 
 

26数据结构/day02/02basic.py

@@ -0,0 +1,83 @@
+"""
+    堆栈就像水杯一样，一种容器，类似于顺序表结构但是只有push和pop，一端进出，后进的先出去
+    队列就像排队一样，先来的先出去
+"""
+
+
+class Stack(object):
+    def __init__(self):
+        self.__list = []
+
+    def push(self, item):
+        self.__list.append(item)
+        # 可以选择append和insert0的方式，不过insert的方式时间复杂度为O(n)
+        # self.__list.insert(0)
+        # self.__list.pop(0)
+
+    def pop(self):
+        self.__list.pop()
+
+    def peek(self):
+        if self.__list:
+            return self.__list[-1]
+        else:
+            return None
+
+    def is_empty(self):
+        # return not self.__list
+        # return self.__list == []
+        return self.size() == 0
+
+    def size(self):
+        return len(self.__list)
+
+
+class Queue(object):
+    def __init__(self):
+        self.__list = []
+
+    def enqueue(self, item):
+        self.__list.append(item)
+        # 可以选择append和insert0的方式，不过insert的方式时间复杂度为O(n)
+        # self.__list.insert(0, item)
+        # self.__list.pop()
+
+    def dequeue(self):
+        self.__list.pop(0)
+
+    def is_empty(self):
+        # return not self.__list
+        # return self.__list == []
+        return self.size() == 0
+
+    def size(self):
+        return len(self.__list)
+
+
+class Deque(object):
+    """
+        double-ended-queue双端队列，两端都可以进行push和pop，类似于两个堆栈底部合起来
+
+    """
+    def __init__(self):
+        self.__list = []
+
+    def add_front(self, item):
+        self.__list.insert(0, item)
+
+    def ad_rear(self, item):
+        self.__list.append(item)
+
+    def remove_front(self):
+        self.__list.pop(0)
+
+    def remove_rear(self):
+        self.__list.pop()
+
+    def is_empty(self):
+        # return not self.__list
+        # return self.__list == []
+        return self.size() == 0
+
+    def size(self):
+        return len(self.__list)

26数据结构/day02/__init__.py

@@ -0,0 +1,22 @@
+
+def bubble_sort(alist):
+
+    n = len(alist)
+    for j in range(0, n-1):
+        # j表示需要n-1次冒泡过程， i表示一次冒泡过程中的交换
+
+        count = 0
+        for i in range(0, n-j-1):
+            # 只需要到列表的n-1位置，因为从0开始正好range结尾是闭区间，所以只需要-1
+            # 比如总共9个元素，需要遍历到第八个位置，让其跟8+1去比较，第八个元素的索引是7，所以range(0, 8)
+            if alist[i] > alist[i+1]:
+                alist[i], alist[i+1] = alist[i+1], alist[i]
+                count += 1
+        """
+            每次冒泡的过程count都为0来记录这次冒泡过程中是否有交换发生
+            如果只要有一次冒泡过程中没有交换发生直接结束循环，表示前面的都是有序的
+            [1,2,3,9,8]第三次循环的时候发现count没变，直接return
+        """
+        if 0 == count:
+            return
+

26数据结构/day03/01basic.py

@@ -0,0 +1,29 @@
+
+def select_sort(alist):
+
+    """
+        选择排序：从无序队列中选择最小的放到前面去，有序部分和无序部分
+        首先认为最小的元素就是第一个元素，不断比较更新这个min的数值
+    """
+    for j in range(0, len(alist)-1):
+
+        min_index = j
+        # 因为j要和剩余的部分作比较也就是从j+1到最后一个元素，n的索引为n-1，闭区间所以到n
+        for i in range(j+1, len(alist)):
+            if alist[min_index] > alist[i]:
+                min_index = i
+
+        alist[j], alist[min_index] = alist[min_index], alist[j]
+
+    """
+        j从0开始比较到倒数第二个元素，总共9个元素，最后让8和8+1比较，所以range：9-1=8,闭区间只能到7
+        内层循环中让j和j+1比较，更新min_index和剩余无序部分的数值
+        时间复杂度为O(n^2)
+    """
+
+    """
+        排序中的稳定性，如果列表中两个元素相等，排序如果可能出现这两个相等元素的位置不固定的话，则为不稳定排序
+        [1, 3, 2, 2]
+    """
+
+