本篇主要實現四種資料結構，分別是陣列、堆疊、佇列、連結串列。我不知道我為什麼要用Python來幹C乾的事情，總之Python就是可以幹。
所有概念性內容可以在參考資料中找到出處
陣列
陣列的設計
陣列設計之初是在形式上依賴記憶體分配而成的，所以必須在使用前預先請求空間。這使得陣列有以下特性：
- 請求空間以後大小固定，不能再改變（資料溢位問題）；
- 在記憶體中有空間連續性的表現，中間不會存在其他程式需要呼叫的資料，為此陣列的專用記憶體空間；
- 在舊式程式語言中（如有中階語言之稱的C），程式不會對陣列的操作做下界判斷，也就有潛在的越界操作的風險（比如會把資料寫在執行中程式需要呼叫的核心部分的記憶體上）。
因為簡單陣列強烈倚賴電腦硬體之記憶體，所以不適用於現代的程式設計。欲使用可變大小、硬體無關性的資料型別，Java等程式設計語言均提供了更高階的資料結構：ArrayList、Vector等動態陣列。
Python的陣列
從嚴格意義上來說:Python裡沒有嚴格意義上的陣列。
List可以說是Python裡的陣列，下面這段程式碼是CPython的實現List的結構體:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
typedef struct { PyObject_VAR_HEAD /* Vector of pointers to list elements. list[0] is ob_item[0], etc. */ PyObject **ob_item; /* ob_item contains space for 'allocated' elements. The number * currently in use is ob_size. * Invariants: * 0 <= ob_size <= allocated * len(list) == ob_size * ob_item == NULL implies ob_size == allocated == 0 * list.sort() temporarily sets allocated to -1 to detect mutations. * * Items must normally not be NULL, except during construction when * the list is not yet visible outside the function that builds it. */ Py_ssize_t allocated; } PyListObject; |
還有一篇文章講List實現,感興趣的朋友可以去看看。中文版。
當然，在Python裡它就是陣列。
後面的一些結構也將用List來實現。
堆疊
什麼是堆疊
堆疊（英語：stack），也可直接稱棧，在電腦科學中，是一種特殊的串列形式的資料結構，它的特殊之處在於只能允許在連結串列或陣列的一端（稱為堆疊頂端指標，英語：top）進行加入資料（英語：push）和輸出資料（英語：pop）的運算。另外堆疊也可以用一維陣列或連結串列的形式來完成。堆疊的另外一個相對的操作方式稱為佇列。
由於堆疊資料結構只允許在一端進行操作，因而按照後進先出（LIFO, Last In First Out）的原理運作。
特點
- 先入後出，後入先出。
- 除頭尾節點之外，每個元素有一個前驅，一個後繼。
操作
從原理可知，對堆疊(棧)可以進行的操作有:
- top():獲取堆疊頂端物件
- push():向棧裡新增一個物件
- pop():從棧裡推出一個物件
實現
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
class my_stack(object): def __init__(self, value): self.value = value # 前驅 self.before = None # 後繼 self.behind = None def __str__(self): return str(self.value) def top(stack): if isinstance(stack, my_stack): if stack.behind is not None: return top(stack.behind) else: return stack def push(stack, ele): push_ele = my_stack(ele) if isinstance(stack, my_stack): stack_top = top(stack) push_ele.before = stack_top push_ele.before.behind = push_ele else: raise Exception('不要亂扔東西進來好麼') def pop(stack): if isinstance(stack, my_stack): stack_top = top(stack) if stack_top.before is not None: stack_top.before.behind = None stack_top.behind = None return stack_top else: print('已經是棧頂了') |
佇列
什麼是佇列
和堆疊類似，唯一的區別是佇列只能在隊頭進行出隊操作，所以佇列是是先進先出（FIFO, First-In-First-Out）的線性表
特點
- 先入先出,後入後出
- 除尾節點外,每個節點有一個後繼
- （可選）除頭節點外,每個節點有一個前驅
操作
- push（）:入隊
- pop（）：出隊
實現
普通佇列
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
class MyQueue(): def __init__(self, value=None): self.value = value # 前驅 # self.before = None # 後繼 self.behind = None def __str__(self): if self.value is not None: return str(self.value) else: return 'None' def create_queue(): """僅有隊頭""" return MyQueue() def last(queue): if isinstance(queue, MyQueue): if queue.behind is not None: return last(queue.behind) else: return queue def push(queue, ele): if isinstance(queue, MyQueue): last_queue = last(queue) new_queue = MyQueue(ele) last_queue.behind = new_queue def pop(queue): if queue.behind is not None: get_queue = queue.behind queue.behind = queue.behind.behind return get_queue else: print('佇列裡已經沒有元素了') def print_queue(queue): print(queue) if queue.behind is not None: print_queue(queue.behind) |
連結串列
什麼是連結串列
連結串列（Linked list）是一種常見的基礎資料結構，是一種線性表，但是並不會按線性的順序儲存資料，而是在每一個節點裡存到下一個節點的指標(Pointer)。由於不必須按順序儲存，連結串列在插入的時候可以達到O(1)的複雜度，比另一種線性表順序錶快得多，但是查詢一個節點或者訪問特定編號的節點則需要O(n)的時間，而順序表相應的時間複雜度分別是O(logn)和O(1)。
特點
使用連結串列結構可以克服陣列連結串列需要預先知道資料大小的缺點，連結串列結構可以充分利用計算機記憶體空間，實現靈活的記憶體動態管理。但是連結串列失去了陣列隨機讀取的優點，同時連結串列由於增加了結點的指標域，空間開銷比較大。
操作
- init():初始化
- insert(): 插入
- trave(): 遍歷
- delete(): 刪除
- find(): 查詢
實現
此處僅實現雙向列表
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 |
class LinkedList(): def __init__(self, value=None): self.value = value # 前驅 self.before = None # 後繼 self.behind = None def __str__(self): if self.value is not None: return str(self.value) else: return 'None' def init(): return LinkedList('HEAD') def delete(linked_list): if isinstance(linked_list, LinkedList): if linked_list.behind is not None: delete(linked_list.behind) linked_list.behind = None linked_list.before = None linked_list.value = None def insert(linked_list, index, node): node = LinkedList(node) if isinstance(linked_list, LinkedList): i = 0 while linked_list.behind is not None: if i == index: break i += 1 linked_list = linked_list.behind if linked_list.behind is not None: node.behind = linked_list.behind linked_list.behind.before = node node.before, linked_list.behind = linked_list, node def remove(linked_list, index): if isinstance(linked_list, LinkedList): i = 0 while linked_list.behind is not None: if i == index: break i += 1 linked_list = linked_list.behind if linked_list.behind is not None: linked_list.behind.before = linked_list.before if linked_list.before is not None: linked_list.before.behind = linked_list.behind linked_list.behind = None linked_list.before = None linked_list.value = None def trave(linked_list): if isinstance(linked_list, LinkedList): print(linked_list) if linked_list.behind is not None: trave(linked_list.behind) def find(linked_list, index): if isinstance(linked_list, LinkedList): i = 0 while linked_list.behind is not None: if i == index: return linked_list i += 1 linked_list = linked_list.behind else: if i < index: raise Exception(404) return linked_list |
以上所有原始碼均在Github共享，歡迎提出issue或PR，希望與大家共同進步!
參考資料