内容：
1.数组
2.链表
3.字典
4.二叉树(搜索树)
5.set集合实现
1.数组
数组在python中是以列表的形式存在，基本上每一个语言中都有数组形式的数据结构存在
数组一般存储在连续的一块内存，数组存取元素时间是 O(1)，插入、删除是 O(n)，另外可以用数组实现栈和队列，栈：先进后出，队列：先进先出
另外python list中有两个部件：
- 数组 存储数据在链表中的地址
- 链表 实际存储数据
列表：
1 lt = [1, 2, 3, 4, 5, 5] 2 3 # 存取 4 print(lt[0]) 5 lt[1] = 666 6 print(lt) 7 8 # 插入元素 9 lt.insert(0, 333) 10 print(lt) 11 12 # 删除元素 13 # 按值删除: 14 lt.remove(5) 15 print(lt) 16 # 按索引删除: 17 lt.pop(0) 18 print(lt) 19 del lt[0] 20 print(lt)
用python中的list相关操作实现栈和列表如下：
1 # encoding: utf-8 2 # __author__ = "wyb" 3 # date: 2018/9/28 4 5 6 class Stack(object): 7 def __init__(self): 8 self.lt = [] 9 10 def empty(self): 11 """ 12 判断栈是否为空 13 :return: 14 """ 15 return len(self.lt) == 0 16 17 def top(self): 18 """ 19 查看栈顶的对象，但不移除 20 :return: 21 """ 22 if not self.empty(): 23 return self.lt[-1] 24 return None 25 26 def push(self, obj): 27 """ 28 把对象压入栈顶 29 :return: 30 """ 31 self.lt.append(obj) 32 33 def pop(self): 34 """ 35 移除栈顶对象，并返回该对象的值 36 :return: 37 """ 38 if not self.empty(): 39 return self.lt.pop() 40 return None 41 42 def search(self, obj): 43 """ 44 返回对象在栈中的位置，以1为基数 45 :param obj: 46 :return: 47 """ 48 if not self.empty(): 49 return self.lt.index(obj) + 1 50 return -1 51 52 53 class Queue(object): 54 def __init__(self): 55 self.lt = [] 56 57 def empty(self): 58 """ 59 判断队列是否为空 60 :return: 61 """ 62 return len(self.lt) == 0 63 64 def first(self): 65 """ 66 查看队首的对象，但不移除 67 :return: 68 """ 69 if not self.empty(): 70 return self.lt[0] 71 return None 72 73 def enqueue(self, obj): 74 """ 75 将指定元素加入队列的尾部 76 :param obj: 77 :return: 78 """ 79 self.lt.append(obj) 80 81 def dequeue(self): 82 """ 83 移除队首对象，并返回该对象的值 84 :return: 85 """ 86 if not self.empty(): 87 return self.lt.pop(0) 88 return None 89 90 def search(self, obj): 91 """ 92 返回对象在队列中的位置，以1为基数 93 :param obj: 94 :return: 95 """ 96 if not self.empty(): 97 return self.lt.index(obj) + 1 98 return -1
用python list实现python中的set：
1 # encoding: utf-8 2 # __author__ = "wyb" 3 # date: 2018/9/29 4 5 6 class Set(object): 7 def __init__(self, *args): 8 self.table_size = 10007 9 self.data = [0] * self.table_size 10 for i in args: 11 self.add(i) 12 13 def __repr__(self): 14 """ 15 调用str及输出的魔法方法 16 :return: 17 """ 18 lt = set() 19 for i in range(0, len(self.data)): 20 if self.data[i] != 0: 21 item = self.data[i] 22 lt.add(item[0]) 23 return str(lt) 24 25 def __eq__(self, other): 26 """ 27 判断相等的魔法方法 28 :param other: 29 :return: 30 """ 31 if type(other) == type(self): 32 return str(self.data) == str(other.data) 33 else: 34 return False 35 36 def remove(self, x): 37 index = self._index(x) 38 self.data[index] = 0 39 40 def _index(self, obj): 41 index = hash(obj) % self.table_size 42 return index 43 44 def _insert_at_index(self, index, key): 45 v = self.data[index] 46 if v == 0: 47 self.data[index] = [key] 48 else: 49 return False 50 51 def add(self, key): 52 # 先计算出下标 53 index = self._index(key) 54 # 在下标处插入元素 55 self._insert_at_index(index, key) 56 57 # for i in range(0, len(self.data)): 58 # if self.data[i] == x: 59 # return False 60 # self.data.append(x) 61 62 def has(self, key): 63 index = self._index(key) 64 # 取元素 65 v = self.data[index] 66 if isinstance(v, list): 67 if v[0] == key: 68 return True 69 return False 70 71 # for i in range(0, len(self.data)): 72 # if self.data[i] == x: 73 # return True 74 # return False 75 76 77 def testSet(): 78 a = Set(1, 2, 2, 3, 4, 4) 79 b = Set(1, 2, 2, 3, 4) 80 c = Set(1, 3, 4, 2) 81 d = Set(2, 3) 82 assert (str(a) == '{1, 2, 3, 4}') 83 print(a, b, c, d) 84 assert (a == b) 85 assert (a == c) 86 assert (a != d) 87 assert (a.has(1) is True) 88 a.remove(1) 89 assert (a.has(1) is False) 90 a.add(1) 91 assert (a.has(1) is True) 92 93 94 if __name__ == '__main__': 95 testSet()
2.链表
我们可以将链表比作手拉手的盒子，一个盒子只能访问左右手的盒子
以下标方式读取元素的时间是 O(n)，插入、删除是 O(1)，栈和队列可以用链表实现，栈：先进后出，队列：先进先出
链表简单实现：
1 # encoding: utf-8 2 # __author__ = "wyb" 3 # date: 2018/9/27 4 5 6 class Node(): 7 def __init__(self, element=None): 8 self.e = element 9 self.next = None 10 11 12 def append(node, element): 13 """ 14 append: 添加一个元素到末尾 15 :param node: 是一个 Node 实例 16 :param element: 任意类型的元素 17 """ 18 n = node 19 while n.next is not None: 20 n = n.next 21 # n 现在是最后一个元素 22 new_node = Node(element) 23 n.next = new_node 24 25 26 def prepend(head_node, element): 27 """ 28 prepend: 添加一个元素到开头 29 :param head_node: 头元素 30 :param element: 任意类型的元素 31 :return: 32 """ 33 n = Node(element) 34 n.next = head_node.next 35 head_node.next = n 36 37 38 def pop(head_node): 39 """ 40 pop是stack的两个操作之一 41 push 入栈 42 pop 出栈 43 prepend + pop 就实现了 队列 的 入队(enqueue)和出队(dequeue)操作 44 append + pop 就实现了 栈 的 入栈(push) 和 出栈(pop)操作 45 :param head_node: 头部节点 46 :return: 47 """ 48 tail = head_node 49 while tail.next is not None: 50 tail = tail.next 51 # 现在 tail 是最后一个元素了 52 n = head_node 53 while n.next is not tail: 54 n = n.next 55 # 现在 n 是 tail 之前的元素了 56 n.next = None 57 return tail.e 58 59 60 def log_list(node): 61 n = node 62 s = '' 63 while n is not None: 64 s += (str(n.e) + ' > ') 65 n = n.next 66 print(s[0: -2]) 67 68 69 head = Node() 70 n1 = Node(111) 71 n2 = Node(222) 72 n3 = Node(333) 73 n1.next = n2 74 n2.next = n3 75 76 head.next = n1 77 78 log_list(n1) 79 append(n1, 'gua') 80 log_list(n1) 81 prepend(head, 'hello') 82 log_list(head) 83 print('pop head: ', pop(head)) 84 log_list(head)
链表封装成类：
1 # encoding: utf-8 2 # __author__ = "wyb" 3 # date: 2018/9/27 4 5 6 # 节点类 7 class Node(object): 8 def __init__(self, element=-1): 9 self.element = element 10 self.next = None 11 12 13 # 链表类 14 class LinkedList(object): 15 def __init__(self): 16 self.head = None 17 18 def is_empty(self): 19 """ 20 判断链表是否为空 21 :return: 22 """ 23 return self.head is None 24 25 def length(self): 26 """ 27 获得链表长度(包含head) 28 :return: 29 """ 30 index = 0 31 node = self.head 32 while node is not None: 33 index += 1 34 node = node.next 35 return index 36 37 def find(self, element): 38 """ 39 查找元素 40 :param element: 元素值 41 :return: 42 """ 43 node = self.head 44 while node is not None: 45 if node.element == element: 46 return node 47 node = node.next 48 return None 49 50 def _node_at_index(self, index): 51 """ 52 返回某个节点 53 :param index: 索引 -> 从0开始 0是head 54 :return: 55 """ 56 i = 0 57 node = self.head 58 while node is not None: 59 if i == index: 60 return node 61 node = node.next 62 i += 1 63 return None 64 65 def element_at_index(self, index): 66 """ 67 返回某个节点的值 68 :param index: 索引 -> 从0开始 0是head 69 :return: 70 """ 71 node = self._node_at_index(index) 72 return node.element 73 74 def first_object(self): 75 """ 76 返回第一个节点 -> head 77 :return: 78 """ 79 return self._node_at_index(0) 80 81 def last_object(self): 82 """ 83 返回最后一个节点 84 :return: 85 """ 86 i = 0 87 while self._node_at_index(i) is not None: 88 i += 1 89 return self._node_at_index(i - 1) 90 91 def insert_before_index(self, position, element): 92 """ 93 在节点之前插入元素 94 :param position: 节点位置 95 :param element: 元素值 96 :return: 97 """ 98 insert_node = Node(element) 99 # 错误情况判断: 100 if position == 0: 101 print("不能在head之前插入元素") 102 return False 103 if self._node_at_index(position) is None: 104 print("节点顺序超了!请输入正确的节点顺序!") 105 return False 106 node = self._node_at_index(position - 1) 107 # 插入元素 108 insert_node.next = node.next 109 node.next = insert_node 110 111 def insert_after_index(self, position, element): 112 """ 113 在节点之后插入元素 114 :param position: 节点位置 115 :param element: 元素值 116 :return: 117 """ 118 insert_node = Node(element) 119 node = self._node_at_index(position) 120 # 错误情况判断: 121 if node is None: 122 print("节点顺序超了!请输入正确的节点顺序!") 123 return False 124 # 在节点之后插入元素 125 insert_node.next = node.next 126 node.next = insert_node 127 128 def append(self, element): 129 """ 130 在最后插入节点 131 :param element: 节点值 132 :return: 133 """ 134 node = Node(element) 135 if self.head is None: 136 self.head.next = node 137 else: 138 last_node = self.last_object() 139 last_node.next = node 140 node.front = last_node 141 142 def prepend(self, element): 143 """ 144 在开头插入节点 145 :param element: 节点值 146 :return: 147 """ 148 node = Node(element) 149 node.next = self.head.next 150 self.head.next = node 151 152 def pop(self): 153 """ 154 删除最后一个节点 155 :return: 156 """ 157 tail = self.first_object() 158 while tail.next is not None: 159 tail = tail.next 160 # 现在 tail 是最后一个元素了 161 n = self.first_object() 162 while n.next is not tail: 163 n = n.next 164 # 现在 n 是 tail 之前的元素了 165 n.next = None 166 return tail.element 167 168 def log_list(self, msg=""): 169 """ 170 输出链表 171 :param msg: 输出链表之前显示的信息 172 :return: 173 """ 174 n = self.head.next 175 s = msg + '' 176 while n is not None: 177 s += (str(n.element) + ' > ') 178 n = n.next 179 print(s[0: -2]) 180 181 182 # 测试链表初始化及输出链表: 183 def test_log(): 184 head = Node(0) 185 n1 = Node(1) 186 n2 = Node(2) 187 n3 = Node(3) 188 lt = LinkedList() 189 lt.head = head 190 head.next = n1 191 n1.next = n2 192 n2.next = n3 193 lt.log_list("输出链表: ") 194 return lt 195 196 197 # 测试链表判空及链表长度: 198 def test_empty_length(lt): 199 if lt.is_empty() is True: 200 print("链表为空") 201 return None 202 else: 203 length = lt.length() 204 print("链表不为空, 链表长度为: ", length) 205 return length 206 207 208 # 测试find 209 def test_find(lt): 210 if lt.find(5) is None: 211 print("链表中不存在5") 212 else: 213 print("链表中存在5") 214 node = lt.find(5) 215 return node 216 217 if lt.find(3) is None: 218 print("链表中不存在3") 219 else: 220 print("链表中存在3") 221 node = lt.find(3) 222 return node 223 224 225 # 测试element_at_index 226 def test_element_at_index(lt): 227 print(lt.element_at_index(0)) 228 print(lt.element_at_index(1)) 229 print(lt.element_at_index(2)) 230 print(lt.element_at_index(3)) 231 232 233 # 测试first_obj和last_obj 234 def test_first_last(lt): 235 print(lt.first_object().element) 236 print(lt.last_object().element) 237 238 239 # 测试插入 240 def test_insert(lt): 241 lt.insert_before_index(0, "在节点0之前插入") 242 lt.log_list() 243 lt.insert_before_index(1, "在节点1之前插入") 244 lt.log_list() 245 lt.insert_after_index(0, "在节点0之后插入") 246 lt.log_list() 247 lt.insert_after_index(2, "在节点2之后插入") 248 lt.log_list() 249 lt.append("在最后插入节点") 250 lt.log_list() 251 lt.prepend("在开头插入节点") 252 lt.log_list() 253 254 255 # 测试pop 256 def test_pop(lt): 257 lt.pop() 258 lt.log_list("删除最后一个元素: ") 259 260 261 # 单元测试 262 def test(): 263 linked_list = test_log() 264 265 # 测试空链表: 266 # test_empty_length(LinkedList()) 267 268 # 测试非空链表: 269 # test_empty_length(linked_list) 270 271 # 测试find 272 # test_find(linked_list) 273 274 # 测试element_at_index 275 # test_element_at_index(linked_list) 276 277 # 测试first_obj和last_obj 278 # test_first_last(linked_list) 279 280 # 测试insert 281 # test_insert(linked_list) 282 283 # 测试pop 284 # test_pop(linked_list) 285 286 287 if __name__ == '__main__': 288 test()