python拓展4 數據結構

時間 2019-11-25

標籤 python 拓展數據結構欄目 Python 简体版

原文原文鏈接

內容：node

1.數組python

2.鏈表web

3.字典算法

4.二叉樹(搜索樹)數組

5.set集合實現數據結構

1.數組app

數組在python中是以列表的形式存在，基本上每個語言中都有數組形式的數據結構存在ide

數組通常存儲在連續的一塊內存，數組存取元素時間是 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()

View Code

另外，關於棧和隊列的實現：

上述鏈表實現中prepend + pop 就實現了隊列的入隊(enqueue)和出隊(dequeue)操做，append + pop 就實現了棧的入棧(push) 和出棧(pop)操做

 1 # encoding: utf-8
 2 # __author__ = "wyb"
 3 # date: 2018/9/28
 4 
 5 """
 6  數據結構的核心是，一個結構只有特定的操做，能夠實現特定的功能
 7 
 8  棧的特色是「先進後出」，通常有這幾個操做
 9 # push 將一個元素存入棧中
10 # pop  將一個元素從棧中取出，並在棧中刪除它
11 
12 # top  將一個元素從棧中取出
13 # is_empty 查看棧是不是空的
14 
15 """
16 
17 
18 # Node類是一個節點，有兩個屬性，一個存儲元素，一個存儲指向另外一個節點的引用
19 class Node:
20     def __init__(self, element=None, next=None):
21         self.element = element
22         self.next = next
23 
24     # 這個函數是會在print的時候被自動調用，就是把這個Node顯示出來
25     def __repr__(self):
26         return str(self.element)
27 
28 
29 class Stack:
30     # 初始化函數，自動被調用
31     # 初始化Stack()類的時候，它有一個head屬性，值是一個空的Node
32     def __init__(self):
33         self.head = Node()
34 
35     # 若是head的next屬性爲空，則說明棧是空的
36     def is_empty(self):
37         return self.head.next is None
38 
39     # 建立一個node，並讓它指向當前head.next指向的元素，再把head.next指向它
40     def push(self, element):
41         self.head.next = Node(element, self.head.next)
42 
43     # 取出head.next指向的元素，若是棧不是空的，就讓head.next指向node.next，這樣node就不在棧中了
44     def pop(self):
45         node = self.head.next
46         if not self.is_empty():
47             self.head.next = node.next
48         return node
49 
50     # head.next就是棧裏面第一個元素
51     def top(self):
52         return self.head.next
53 
54 
55 # 測試函數
56 def test():
57     s = Stack()
58 
59     s.push(1)
60     s.push(2)
61     s.push(3)
62     s.push(4)
63 
64     print(s.pop())
65     print(s.pop())
66     print(s.pop())
67     print(s.pop())
68 
69 
70 if __name__ == '__main__':
71     # 運行測試函數
72     test()

鏈表實現棧

 1 # encoding: utf-8
 2 # __author__ = "wyb"
 3 # date: 2018/9/28
 4 
 5 
 6 """
 7 隊列的特色是「先進先出」，通常有這幾個操做
 8 
 9 # enqueue 將一個元素存入隊列中
10 # dequeue 將一個元素從隊列中取出，並在隊列中刪除它
11 
12 # empty 查看棧是不是空的
13 
14 能夠把隊列看作排隊，銀行叫號機就是隊列，先取號的先入隊，叫號的時候也就先出隊
15 """
16 
17 
18 # Node類是一個節點，有兩個屬性，一個存儲元素，一個存儲指向另外一個節點的引用
19 class Node:
20     def __init__(self, element=None, next=None):
21         self.element = element
22         self.next = next
23 
24     # 這個函數是會在print的時候被自動調用，就是把這個Node顯示出來
25     def __repr__(self):
26         return str(self.element)
27 
28 
29 class Queue:
30     # 初始化函數，自動被調用
31     # 初始化Queue()類的時候，它有2個屬性，分別指向頭尾
32     def __init__(self):
33         self.head = Node()
34         self.tail = self.head
35 
36     # 若是head的next屬性爲空，則說明隊列是空的
37     def empty(self):
38         return self.head.next is None
39 
40     # 建立一個node
41     # 讓tail.next指向它
42     # 讓tail指向它，tail如今就是新的隊尾了
43     def enqueue(self, element):
44         n = Node(element)
45         self.tail.next = n
46         self.tail = n
47 
48     # 取出head.next指向的元素，若是隊列不是空的，就讓head.next指向node.next，這樣node就不在隊列中了
49     def dequeue(self):
50         node = self.head.next
51         if not self.empty():
52             self.head.next = node.next
53         return node
54 
55 
56 # 測試函數
57 def test():
58     q = Queue()
59 
60     q.enqueue(1)
61     q.enqueue(2)
62     q.enqueue(3)
63     q.enqueue(4)
64 
65     print(q.dequeue())
66     print(q.dequeue())
67     print(q.dequeue())
68     print(q.dequeue())
69 
70 
71 if __name__ == '__main__':
72     # 運行測試函數
73     test()

鏈表實現隊列

3.字典(哈希表、對象、Map)

python中的字典把字符串轉爲數字做爲下標存儲到數組中，字符串轉化爲數字的算法是 O(1)，因此字典的存取操做都是 O(1)

除非對數據有順序要求，不然字典永遠是最佳選擇

字符串轉化爲數字的算法：

肯定數據規模，這樣能夠肯定容器數組的大小 Size
把字符看成 N 進制數字獲得結果
eg：'gua' 被視爲 g * 1 + u * 10 + a * 100 獲得結果 n，n % Size 做爲字符串在數組中的下標(一般 Size 會選一個素數)
當下標衝突時，有標準的解決碰撞方法(連接法)

實現字典(哈希表)：

  1 class HashTable(object):
  2     def __init__(self):
  3         # table 是用來存儲數據的數組
  4         # 先讓它有 10007 個格子好了
  5         # 上課的時候說過, 這個尺寸最好選素數
  6         # 這樣能夠獲得更爲合理的下標分佈
  7         self.table_size = 10007
  8         self.table = [0] * self.table_size
  9 
 10     # 這個魔法方法是用來實現 in  not in 語法的
 11     def __contains__(self, item):
 12         return self.has_key(item)
 13 
 14     def has_key(self, key):
 15         """
 16         檢查一個 key 是否存在, 時間很短, 是 O(1)
 17         若是用 list 來存儲, 須要遍歷, 時間是 O(n)
 18         """
 19         index = self._index(key)
 20         # 取元素
 21         v = self.table[index]
 22         if isinstance(v, list):
 23             # 檢查是否包含咱們要找的 key
 24             for kv in v:
 25                 if kv[0] == key:
 26                     return True
 27         # 若是獲得的是 int 0 說明沒找到, 返回 False
 28         # 若是獲得的是 list 可是遍歷結果沒有咱們要找的 key 也是沒找到
 29         return False
 30 
 31     def _insert_at_index(self, index, key, value):
 32         # 檢查下標處是不是第一次插入數據
 33         v = self.table[index]
 34         data = [key, value]
 35         # 也能夠用這個判斷 if v == 0:
 36         if isinstance(v, int):
 37             # 若是是第一次, 獲得的是 int 0
 38             # 那麼就插入一個 list 來存, 之後相同 key 的元素都放這裏面
 39             # 注意咱們把 key value 做爲一個數組保存進去了, 這是由於
 40             # 會出現相同 hash 值的 key
 41             # 這時候就須要比較原始信息來找到相應的數據
 42             self.table[index] = [data]
 43         else:
 44             # 若是不是, 獲得的會是 list, 直接 append
 45             self.table[index].append(data)
 46 
 47     def add(self, key, value):
 48         """
 49         add 函數往 hashtable 中加入一對元素
 50         咱們先只支持字符串當 key
 51         """
 52         # 先計算出下標
 53         index = self._index(key)
 54         # 在下標處插入元素
 55         self._insert_at_index(index, key, value)
 56 
 57     def get(self, key, default_value=None):
 58         """
 59         這個和 dict 的 get 函數同樣
 60         """
 61         index = self._index(key)
 62         # 取元素
 63         v = self.table[index]
 64         if isinstance(v, list):
 65             # 檢查是否包含咱們要找的 key
 66             for kv in v:
 67                 if kv[0] == key:
 68                     return kv[1]
 69         # 若是獲得的是 int 0 說明沒找到, 返回 default_value
 70         # 若是獲得的是 list 可是遍歷結果沒有咱們要找的 key 也是沒找到
 71         return default_value
 72 
 73     def _index(self, key):
 74         # 先計算出下標
 75         return self._hash(key) % self.table_size
 76 
 77     def _hash(self, s):
 78         """
 79         下劃線開始的函數被咱們視爲私有函數
 80         但實際上仍是能夠在外部調用, 這只是一個給本身看的標記
 81         """
 82         n = 1
 83         f = 1
 84         for i in s:
 85             n += ord(i) * f
 86             f *= 10
 87         return n
 88 
 89 
 90 def test():
 91     import uuid
 92     names = [
 93         'gua',
 94         'xiao',
 95         'name',
 96         'web',
 97         'python',
 98     ]
 99     ht = HashTable()
100     for key in names:
101         value = uuid.uuid4()
102         ht.add(key, value)
103         print('add 元素', key, value)
104     for key in names:
105         v = ht.get(key)
106         print('get 元素', key, v)
107     print('魔法方法', 'gua' in ht)
108 
109 
110 if __name__ == '__main__':
111     test()

4.二叉樹(搜索樹)

二叉樹(又叫搜索樹)：

 1 # encoding: utf-8
 2 # __author__ = "wyb"
 3 # date: 2018/9/28
 4 
 5 
 6 class Tree(object):
 7     def __init__(self, element=None):
 8         self.element = element
 9         self.left = None
10         self.right = None
11 
12     def traversal(self):
13         """
14         樹的遍歷, 是一個遞歸操做
15         """
16         print(self.element)     # 前序遍歷
17         if self.left is not None:
18             self.left.traversal()
19         # print(self.element)   # 中序遍歷
20         if self.right is not None:
21             self.right.traversal()
22         # print(self.element)   # 後序遍歷
23 
24     def reverse(self):
25         """
26         翻轉二叉樹
27         :return:
28         """
29         self.left, self.right = self.right, self.left
30         if self.left is not None:
31             self.left.reverse()
32         if self.right is not None:
33             self.right.reverse()
34 
35 
36 def test():
37     # 手動構建二叉樹
38     t = Tree(0)
39     left = Tree(1)
40     right = Tree(2)
41     t.left = left
42     t.right = right
43     # 遍歷
44     t.traversal()
45 
46 
47 if __name__ == '__main__':
48     test()

5.set集合實現

(1)題目要求

 1 # 做業一：
 2 # 寫一個 set 的類, 無序且元素不重複，內部使用數組來存儲元素，具備如下成員函數
 3 # 1. remove ，刪除元素
 4 # 2. add， 增長元素
 5 # 3. has，判斷元素是否存在
 6 # 形式以下：
 7 # class Set(object)：
 8 #     def __init__(self, *args)
 9 #         self.data = []
10 #         # ...
11 #     def remove(self, x):
12 #         pass
13 #     def add(self, x):
14 #         pass
15 #     def has(self, x):
16 #         pass
17 #
18 #
19 # 做業二：
20 # 在做業一的基礎上，在Set類裏增長 __repr__  和 __eq__ 兩個成員函數。
21 # 並經過附帶 testSet() 函數的測試。
22 # 形式以下：
23 # class Set(object)：
24 #     # ...
25 #     def __init__(self, *args)
26 #         self.data = []
27 #
28 #     def __repr__(self):
29 #         pass
30 #
31 #     def __eq__(self, other):
32 #         pass
33 #
34 #     def remove(self, x):
35 #         pass
36 #     def add(self, x):
37 #         pass
38 #     def has(self, x):
39 #         pass
40 #
41 # def testSet():
42 #     a = Set(1, 2, 2, 3, 4, 4)
43 #     b = Set(1, 2, 2, 3, 4)
44 #     c = Set(1, 3, 4, 2)
45 #     d = Set(2, 3)
46 #     assert (str(a) == '{1, 2, 3, 4}')
47 #     print(a, b, c, d)
48 #     assert (a == b)
49 #     assert (a == c)
50 #     assert (a != d)
51 #     assert (a.has(1) == True)
52 #     a.remove(1)
53 #     assert (a.has(1) == False)
54 #     a.add(1)
55 #     assert (a.has(1) == True)
56 #
57 #
58 # 做業三：
59 # 參考第17課板書 hash_table 的代碼，寫一個類 Set，實現時間複雜度爲O(1) 的 add,remove 函數 。
60 # 形式以下：
61 # class Set(object):
62 #     # ...
63 #     def add(self, x):
64 #         pass
65 #
66 #     def remove(self, x):
67 #         pass