python - 線性數據結構

單鏈表

單鏈表是一種基本的數據結構，鏈表中每個節點裏存放該節點的值和下一個節點的位置信息。

節點定義：

class SingleNode(object):
	def __init__(self, item):
		self.item = item
		self.next = None

單鏈表的常用操作：

• is_empty()：鏈表是否爲空
• length()：鏈表長度
• travel()：遍歷鏈表
• add(item)：鏈表頭部添加元素
• append(item)：鏈表尾部添加元素
• insert(pos, item)：在指定位置添加元素
• remove(pos, item)：刪除節點
• search(item)：查找結點是否存在

單鏈表定義： 指定頭結點並設爲None

class SingleLinkList(object):
 """單鏈表"""
 def __init__(self):
     self._head = None

判空、鏈表長度

def is_empty(self):
     return self._head is None

 def length(self):
     # cur初始時指向頭節點
     cur = self._head
     count = 0
     # 尾節點指向None，當未到達尾部時
     while cur is not None:
         count += 1
         # 將cur後移一個節點
         cur = cur.next
     return count

遍歷鏈表

 def travel(self):
     cur = self._head
     while cur is not None:
         print(cur.item, end=" ")
         cur = cur.next
     print()

鏈表頭部插入元素

 def add(self, item):
     # 先創建一個保存item節點的值
     node = SingleNode(item)
     # 將新節點的鏈接域next指向頭節點，即_head指向的位置
     # 先連接再設置頭節點指針 
     node.next = self._head
     # 將鏈表的頭_head指向新節點
     self._head = node
 

示意圖：

尾部添加元素

def append(self, item):
     """尾部添加元素"""
     node = SingleNode(item)
     # 先判斷鏈表是否爲空，若是空鏈表，則將_head指向新節點
     if self.is_empty():
         self._head = node
     # 若不爲空，則找到尾部，將尾節點的next指向新節點
     else:
         cur = self._head
         while cur.next is not None:
             cur = cur.next
         cur.next = node

指定位置插入元素

 def insert(self, index, item):
     """指定位置添加元素"""
     # 若指定位置pos爲第一個元素之前，則執行頭部插入
     if index <= 0:
         self.add(item)
     # 若指定位置超過鏈表尾部，則執行尾部插入
     elif index > (self.length() - 1):
         self.append(item)
     # 找到指定位置
     else:
         node = SingleNode(item)
         count = 0
         # pre用來指向指定位置pos的前一個位置pos-1，初始從頭節點開始移動到指定位置
         pre = self._head
         while count < (index - 1):
             count += 1
             pre = pre.next
         # 先將新節點node的next指向插入位置的節點
         node.next = pre.next
         # 將插入位置的前一個節點的next指向新節點
         pre.next = node

示意圖：

刪除節點

 def remove(self, item):
     """刪除節點"""
     cur = self._head
     pre = None
     while cur is not None:
         # 找到了指定元素
         if cur.item == item:
             # 如果第一個就是刪除的節點
             if not pre:
                 # 將頭指針指向頭節點的後一個節點
                 self._head = cur.next
             else:
                 # 將刪除位置前一個節點的next指向刪除位置的後一個節點
                 pre.next = cur.next
             break
         else:
             # 繼續按鏈表後移節點
             pre = cur
             cur = cur.next

示意圖：

查找指定元素

def search(self, item):
     """鏈表查找節點是否存在，並返回True或者False"""
     cur = self._head
     while cur is not None:
         if cur.item == item:
             return True
         cur = cur.next
     return False

---

雙鏈表

# 雙向鏈表節點定義
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

# 判空
 def is_empty(self):
     return self._head == None

# 鏈表長度
 def length(self):
    cur = self._head
     count = 0
     while cur is not None:
         count += 1
         cur = cur.next
     return count

# 遍歷鏈表
 def travel(self):
     cur = self._head
     while cur is not None:
         print(cur.item, end=" ")
         cur = cur.next
     print("")

# 頭部插入元素
 def add(self, item):
     node = Node(item)
     if self.is_empty():
         # 如果是空鏈表，將_head指向node
         self._head = node
     else:
         # 將node的next指向_head的頭節點
         node.next = self._head
         # 將_head的頭節點的prev指向node
         self._head.prev = node
         # 將_head 指向node
         self._head = node

# 尾部插入元素
 def append(self, item):
     node = Node(item)
     if self.is_empty():
         # 如果是空鏈表，將_head指向node
         self._head = node
     else:
         # 移動到鏈表尾部
         cur = self._head
         while cur.next is not None:
             cur = cur.next
         # 將尾節點cur的next指向node
         cur.next = node
         # 將node的prev指向cur
         node.prev = cur

# 查找指定元素
 def search(self, item):
     cur = self._head
     while cur is not None:
         if cur.item == item:
             return True
         cur = cur.next
     return False

# 指定位置添加節點
def insert(self, pos, item):
     if pos <= 0:
         self.add(item)
     elif pos > (self.length() - 1):
         self.append(item)
     else:
         node = Node(item)
         cur = self._head
         count = 0
         # 移動到指定位置的前一個位置
         while count < (pos - 1):
             count += 1
             cur = cur.next
         # 將node的prev指向cur
         node.prev = cur
         # 將node的next指向cur的下一個節點
         node.next = cur.next
         # 將cur的下一個節點的prev指向node
         cur.next.prev = node
         # 將cur的next指向node
         cur.next = node

# 移除指定元素     
def remove(self, item):
     if self.is_empty():
         return
     else:
         cur = self._head
         if cur.item == item:
             # 如果首節點的元素即是要刪除的元素
             if cur.next == None:
                 # 如果鏈表只有這一個節點
                 self._head = None
             else:
                 # 將第二個節點的prev設置爲None
                 cur.next.prev = None
                 # 將_head指向第二個節點
                 self._head = cur.next
             return
         while cur != None:
             if cur.item == item:
                 # 將cur的前一個節點的next指向cur的後一個節點
                 cur.prev.next = cur.next
                 # 將cur的後一個節點的prev指向cur的前一個節點
                 cur.next.prev = cur.prev
                 break
             cur = cur.next

---

棧

棧是一種先入後出的數據結構，使用python中的list可以很方便的用來構建棧，list的append()和pop()可以表示入棧和出棧。

class Stack(object):
 def __init__(self):
     self.items = []

 def is_empty(self):
     return self.items == []

# 入棧
 def push(self, item):
     self.items.append(item)

# 出棧
 def pop(self):
     return self.items.pop()

# 返回棧頂元素
 def peek(self):
     return self.items[len(self.items) - 1]

# 棧大小
 def size(self):
     return len(self.items)

---

隊列

隊列（queue）是隻允許在一端進行插入操作，而在另一端進行刪除操作的線性表。隊列是一種先進先出的（First In First Out）的線性表，允許插入的一端爲隊尾，允許刪除的一端爲隊頭。隊列不允許在中間部位進行操作。

class Queue(object):
 def __init__(self):
     self.items = []

 def is_empty(self):
     return self.items == []
 
 # 入隊
 def enqueue(self, item):
     self.items.insert(0, item)
 # 出隊
 def dequeue(self):
     return self.items.pop()

 def size(self):
     return len(self.items)

---

雙端隊列

class Deque(object):
 """雙端隊列"""

 def __init__(self):
     self.items = []
 # 判斷隊列是否爲空
 def is_empty(self):
     return self.items == []
     
 # 在隊頭添加元素
 def add_front(self, item):
     self.items.insert(0, item)

 # 在隊尾添加元素
 def add_rear(self, item):
     self.items.append(item)

 # 從隊頭刪除元素
 def remove_front(self):
     return self.items.pop(0)

 # 從隊尾刪除元素
 def remove_rear(self):
     return self.items.pop()
     
 # 隊列大小
 def size(self):
     return len(self.items)