基礎數據結構
目錄
棧（stack）
棧（stack）又名堆棧，它是一種運算受限的線性表。其限制是僅允許在表的一端進行插入和刪除運算。
這一端被稱為棧頂，相對地，把另一端稱為棧底。向一個棧插入新元素又稱作進棧、入棧或壓棧，
它是把新元素放到棧頂元素的上面，使之成為新的棧頂元素；從一個棧刪除元素又稱作出棧或退棧，
它是把棧頂元素刪除掉，使其相鄰的元素成為新的棧頂元素。
棧作為一種數據結構，是一種只能在一端進行插入和刪除操作的特殊線性表。它按照先進后出的原則存儲數據，
先進入的數據被壓入棧底，最后的數據在棧頂，需要讀數據的時候從棧頂開始彈出數據（最后一個數據被第一個讀出來）。
棧具有記憶作用，對棧的插入與刪除操作中，不需要改變棧底指針。
- 特性：先進后出的數據結構
# 應用：每個 web 瀏覽器都有一個返回按鈕。當你瀏覽網頁時，這些網頁被放置在一個棧中（實際是網頁的網址）。
你現在查看的網頁在頂部，你第一個查看的網頁在底部。如果按‘返回’按鈕，將按相反的順序瀏覽剛才的頁面。
# 使用python代碼實現一個棧
- Stack() 創建一個空的新棧。 它不需要參數，並返回一個空棧。
- push(item)將一個新項添加到棧的頂部。它需要 item 做參數並不返回任何內容。
- pop() 從棧中刪除頂部項。它不需要參數並返回 item 。棧被修改。
- peek() 從棧返回頂部項，但不會刪除它。不需要參數。 不修改棧。
- isEmpty() 測試棧是否為空。不需要參數，並返回布爾值。
- size() 返回棧中的 item 數量。不需要參數，並返回一個整數。
class Stack():
def __init__(self):
self.items = []
def push(self,item):
self.items.append(item)
def pop(self):
return self.items.pop()
def peek(self):
return len(self.items) - 1
def isEmpty(self):
return self.items == []
def size(self):
return len(self.items)
stack = Stack()
stack.push(1)
stack.push(2)
stack.push(3)
print('棧頂元素下標：',stack.peek())
print(stack.isEmpty())
print('元素個數：',stack.size())
print(stack.pop())
print(stack.pop())
print(stack.pop())
隊列 (queue)
- 隊列：先進先出
- 應用場景：
- 我們的計算機實驗室有 30 台計算機與一台打印機聯網。當學生想要打印時，
他們的打印任務與正在等待的所有其他打印任務“一致”。第一個進入的任務是先完成。
如果你是最后一個，你必須等待你前面的所有其他任務打印。
# 使用python代碼實現一個隊列
- Queue() 創建一個空的新隊列。 它不需要參數，並返回一個空隊列。
- enqueue(item) 將新項添加到隊尾。 它需要 item 作為參數，並不返回任何內容。
- dequeue() 從隊首移除項。它不需要參數並返回 item。 隊列被修改。
- isEmpty() 查看隊列是否為空。它不需要參數，並返回布爾值。
- size() 返回隊列中的項數。它不需要參數，並返回一個整數。
class Queue():
def __init__(self):
self.items = []
def enqueue(self,item):
self.items.insert(0,item)
def dequeue(self):
return self.items.pop()
def isEmpty(self):
return self.items == []
def size(self):
return len(self.items)
q = Queue()
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
print(q.dequeue())
print(q.dequeue())
print(q.dequeue())
# 面試題
- 燙手的山芋
- 燙手山芋游戲介紹：6個孩子圍城一個圈，排列順序孩子們自己指定。第一個孩子手里有一個燙手的山芋，
需要在計時器計時1秒后將山芋傳遞給下一個孩子，依次類推。規則是，在計時器每計時7秒時，手里有山芋的孩子退出游戲。
該游戲直到剩下一個孩子時結束，最后剩下的孩子獲勝。請使用隊列實現該游戲策略，排在第幾個位置最終會獲勝。
# 解題思路
- 讓手里有山芋的孩子永遠排在隊列的頭部
class Queue():
def __init__(self):
self.items = []
def enqueue(self,item):
self.items.insert(0,item)
def dequeue(self):
return self.items.pop()
def isEmpty(self):
return self.items == []
def size(self):
return len(self.items)
kids = ['A','B','C','D','E','F']
queue = Queue()
for kid in kids:
queue.enqueue(kid) #A對頭F隊尾
while queue.size() > 1:
for i in range(6): #每循環一次，山芋傳遞一次，手里有山芋的孩子永遠在對頭位置
kid = queue.dequeue()
queue.enqueue(kid)
queue.dequeue()
print('獲勝的選手是：',queue.dequeue())
for a in range(len(kids)):
if kids[a] == kid:
print('排在第：%d會獲勝'%a)
# 執行結果
獲勝的選手是： E
排在第：4會獲勝
# 面試題 使用兩個隊列實現一個棧
class Queue():
def __init__(self):
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)
alist = [1,2,3,4,5]
q1 = Queue()
for i in alist:
q1.enqueue(i)
q2 = Queue()
while q1.size() > 0:
#將q1中的n-1個值取出放入到q2中
while q1.size() > 1:
item = q1.dequeue()
q2.enqueue(item)
print(q1.dequeue())
q1,q2 = q2,q1
雙端隊列 ( deque )
同隊列相比，有兩個頭部和尾部。可以在雙端進行數據的插入和刪除，提供了單數據結構中棧和隊列的特性.
# 用python代碼實現一個雙端隊列
- Deque() 創建一個空的新 deque。它不需要參數，並返回空的 deque。
- addFront(item) 將一個新項添加到 deque 的首部。它需要 item 參數 並不返回任何內容。
- addRear(item) 將一個新項添加到 deque 的尾部。它需要 item 參數並不返回任何內容。
- removeFront() 從 deque 中刪除首項。它不需要參數並返回 item。deque 被修改。
- removeRear() 從 deque 中刪除尾項。它不需要參數並返回 item。deque 被修改。
- isEmpty() 測試 deque 是否為空。它不需要參數，並返回布爾值。
- size() 返回 deque 中的項數。它不需要參數，並返回一個整數。
class Deque():
def __init__(self):
self.items = []
def addFront(self,item):
self.items.insert(0,item)
def addRear(self,item):
self.items.append(item)
def removeFront(self):
return self.items.pop()
def removeRear(self):
return self.items.pop(0)
def isEmpty(self):
return self.items == []
def size(self):
return len(self.items)
q = Deque()
q.addFront(1)
q.addFront(2)
q.addFront(3)
print(q.removeRear())
print(q.removeRear())
print(q.removeRear())
- 雙端隊列應用案例：回文檢查
- 回文是一個字符串，讀取首尾相同的字符，例如，radar toot madam。
class Deque():
def __init__(self):
self.items = []
def addFront(self,item):
self.items.insert(0,item)
def addRear(self,item):
self.items.append(item)
def removeFront(self):
return self.items.pop()
def removeRear(self):
return self.items.pop(0)
def isEmpty(self):
return self.items == []
def size(self):
return len(self.items)
def isHuiWen(s):
ex = True
q = Deque()
for ch in s:
q.addFront(ch)
while q.size() > 1:
if q.removeFront() != q.removeRear():
ex = False
break
return ex
print(isHuiWen('上海自來水來自海上'))
# 執行結果
True
順序表 與 內存
-
簡單了解一下內存
- 內存在計算機的作用
- 用來存儲和運算二進制的數據
- 問題：計算機如何計算1+2？
- 將1和2的二進制類型的數據加載到計算機的內存中，然后使用寄存器進行數值的預算。
- 變量的概念
- 變量可以理解為某一塊內存(實際是引用的某一塊內存的地址)
- 內存空間是有兩個默認的屬性：
- 內存空間的大小
- bit（位）：一個bit大小的內存空間只能存放一位二進制的數
- byte（字節）：8bit
- kb：1024byte
- 內存空間的地址
- 使用一個十六進制的數值表示
- 作用：讓cup尋址
- 理解a=10的內存圖（引用，指向）
- 引用：變量==》內存空間的地址
- a = 10：a變量/引用/內存空間的地址
- 指向：如果變量或者引用表示的是某一塊內存空間地址的話，則該變量或者該引用指向了該塊內存
-
順序表
- 集合中存儲的元素是有順序的，順序表的結構可以分為兩種形式：單數據類型(np.array數組)和多數據類型(列表,元組)。
- python中的列表和元組就屬於多數據類型的順序表
- 單數據類型順序表的內存圖 (內存連續開辟,每個內存空間大小一致)
- 多數據類型順序表的內存圖（內存非連續開辟）
-
順序表的弊端：順序表的結構需要預先知道數據大小來申請連續的存儲空間，而在進行擴充時又需要進行數據的搬遷。
鏈表 （Linked list）
- 鏈表（Linked list）是一種常見的基礎數據結構，是一種線性表，但是不像順序表一樣連續存儲數據，
而是每一個結點（數據存儲單元）里存放下一個結點的信息（即地址）
- 相對於順序表，鏈表結構可以充分利用計算機內存空間，實現靈活的內存動態管理且進行擴充時不需要進行數據搬遷。
- 使用python實現單向鏈表
. is_empty()：鏈表是否為空
. length()：鏈表長度
. travel()：遍歷整個鏈表
. add(item)：鏈表頭部添加元素
. append(item)：鏈表尾部添加元素
. insert(pos, item)：指定位置添加元素
. remove(item)：刪除節點
. search(item)：查找節點是否存在
# 代碼
class Node():
def __init__(self,item):
self.item = item
self.next = None
class Link():
def __init__(self):
#構造出一個空鏈表
#_head存儲的只能是空或者第一個節點的地址
self._head = None
#向鏈表的頭部插入一個節點
def add(self,item):
#創建一個新的節點
node = Node(item)
node.next = self._head
self._head = node
def travel(self):
#_head在鏈表創建好之后一定是不可變
cur = self._head
while cur:
print(cur.item)
cur = cur.next
def isEmpty(self):
return self._head == None
def size(self):
cur = self._head
count = 0
while cur:
count += 1
cur = cur.next
return count
def append(self,item):
node = Node(item)
#特殊情況
if self._head == None:
self._head = node
return
cur = self._head
pre = None#pre指向的是cur前一個節點
while cur:
pre = cur
cur = cur.next
pre.next = node
def search(self,item):
find = False
cur = self._head
while cur:
if cur.item == item:
find = True
break
cur = cur.next
return find
def insert(self,pos,item):
node = Node(item)
pre = None
cur = self._head
for i in range(pos):
pre = cur
cur = cur.next
pre.next = node
node.next = cur
def remove(self,item):
cur = self._head
pre = None
#刪除的是第一個節點
if cur.item == item:
self._head = cur.next
return
while cur:
pre = cur
cur = cur.next
if cur.next == None:
return
if cur.item == item:
pre.next = cur.next
return
- 如何實現將單鏈表倒置
# 單鏈表（插入，刪除，遍歷）
class Node():
def __init__(self,item):
self.item = item
self.next = None
class Link():
def __init__(self):
self._head = None
def append(self,item):
node = Node(item)
if self._head == None:
self._head = node
return
cur = self._head
pre = None
while cur:
pre = cur
cur = cur.next
pre.next = node
def travel(self):
cur = self._head
while cur:
print(cur.item)
cur = cur.next
def remove(self,item):
cur = self._head
pre = None
#刪除的是第一個節點
if cur.item == item:
self._head = cur.next
return
while cur:
pre = cur
cur = cur.next
if item == cur.item:
pre.next = cur.next
return
def reverse(self):
cur = self._head
pre = None
next_node = cur.next
while cur:
cur.next = pre
pre = cur
cur = next_node
if cur:
next_node = cur.next
self._head = pre
# 雙向鏈表就是連續開辟三個內存空間,分別存放 數據 上個節點內存地址 下個節點內存地址
二叉樹
- 二叉樹
- 根節點
- 葉子節點：
- 左葉子節點
- 右葉子節點
- 樹的層級/樹的高度
- 二叉樹的遍歷
- 廣度優先遍歷
- 一層一層對節點進行遍歷
- 深度優先遍歷
- 前序：根左右
- 中序：左根右
- 后序：左右根
- 廣度優先遍歷
# 使用python代碼實現二叉樹
class Node():
def __init__(self,item):
self.item = item
self.left = None
self.right = None
class Tree():
def __init__(self):
self.root = None
def addNode(self,item):
node = Node(item)
#如果插入第一個節點的情況
if self.root == None:
self.root = node
return
cur = self.root
q = [cur] #列表元素是我們進行遍歷判斷的節點
while q:
nd = q.pop(0)
if nd.left == None:
nd.left = node
return
else:
q.append(nd.left)
if nd.right == None:
nd.right = node
return
else:
q.append(nd.right)
def travel(self): #廣度優先遍歷
cur = self.root
q = [cur]
while q:
nd = q.pop(0)
print(nd.item)
if nd.left:
q.append(nd.left)
if nd.right:
q.append(nd.right)
def forwoar(self,root): #深度優先 前序:根左右
if root == None:
return
print(root.item)
self.forwoar(root.left)
self.forwoar(root.right)
def middle(self,root): #深度優先 前序:左根右
if root == None:
return
self.middle(root.left)
print(root.item)
self.middle(root.right)
def back(self,root): #深度優先 前序:左右根
if root == None:
return
self.back(root.left)
self.back(root.right)
print(root.item)