靈魂拷問：為什么要學資料結構？
資料結構，直白地理解，就是研究資料的存盤方式，資料存盤只有一個目的，即為了方便后期對資料的再利用，因此，資料在計算機存盤空間的存放，決不是胡亂的，這就要求我們選擇一種好的方式來存盤資料，而這也是資料結構的核心內容，
可以說，資料結構是一切編程的基本，學習資料結構是學習一種思想：如何把現實問題轉化為計算機語言的表示，
對于學計算機的朋友來說，學習資料結構是基本功，而對于非計算機專業，但是未來想往資料分析、大資料方向發展、或者在Python的使用上能有一個大的跨越的朋友來說，學習資料結構是一種非常重要的邏輯思維能力的鍛煉，在求職、職業發展、問題解決等方面都能有潛移默化的大幫助，
資料結構——堆疊（順序堆疊與鏈堆疊）
- 資料結構——堆疊（順序堆疊與鏈堆疊）
- 第一章 堆疊的基礎知識
- 1. 堆疊存盤結構
- 1.1 堆疊的基本介紹
- 1.2 進堆疊和出堆疊
- 1.3 堆疊的具體實作
- 1.4 堆疊的應用
- 2. 順序堆疊及基本操作（包含入堆疊和出堆疊）
- 2.1 順序堆疊的基礎介紹
- 2.2 順序堆疊元素"入堆疊"
- 2.3 順序堆疊元素"出堆疊"
- 任務一：順序堆疊的表示和實作（難度：★）
- 3. 鏈堆疊及基本操作（包含入堆疊和出堆疊）詳解
- 3.1 鏈堆疊的基本介紹
- 3.2 鏈堆疊元素入堆疊
- 3.3 鏈堆疊元素出堆疊
- 任務二：鏈堆疊的表示和實作（難度：★★）
- 4.堆疊的應用（難度：★★）
- 應用1：括號匹配問題
- 應用2：十進制轉二進制
- 應用3
資料結構——堆疊（順序堆疊與鏈堆疊）
第一章 堆疊的基礎知識
堆疊和佇列，嚴格意義上來說，也屬于線性表，因為它們也都用于存盤邏輯關系為 “一對一” 的資料，使用堆疊結構存盤資料，講究“先進后出”，即最先進堆疊的資料，最后出堆疊；使用佇列存盤資料，講究 “先進先出”，即最先進佇列的資料，也最先出佇列，既然堆疊和佇列都屬于線性表，根據線性表分為順序表和鏈表的特點，堆疊也可分為順序堆疊和鏈堆疊，佇列也分為順序佇列和鏈佇列，這些內容都會在本章做詳細講解，
1. 堆疊存盤結構
1.1 堆疊的基本介紹
同順序表和鏈表一樣，堆疊也是用來存盤邏輯關系為 “一對一” 資料的線性存盤結構，如圖1所示，
從圖 1 我們看到，堆疊存盤結構與之前所學的線性存盤結構有所差異，這緣于堆疊對資料 “存” 和 “取” 的程序有特殊的要求：
（1）堆疊只能從表的一端存取資料，另一端是封閉的，如圖 1 所示；
（2）在堆疊中，無論是存資料還是取資料，都必須遵循"先進后出"的原則，即最先進堆疊的元素最后出堆疊，拿圖 1 的堆疊來說，從圖中資料的存盤狀態可判斷出，元素 1 是最先進的堆疊，因此，當需要從堆疊中取出元素 1 時，根據"先進后出"的原則，需提前將元素 3 和元素 2 從堆疊中取出，然后才能成功取出元素 1，
因此，我們可以給堆疊下一個定義，即堆疊是一種只能從表的一端存取資料且遵循 “先進后出” 原則的線性存盤結構，
通常，堆疊的開口端被稱為堆疊頂；相應地，封口端被稱為堆疊底，因此，堆疊頂元素指的就是距離堆疊頂最近的元素，拿圖 2 來說，堆疊頂元素為元素 4；同理，堆疊底元素指的是位于堆疊最底部的元素，圖 2 中的堆疊底元素為元素 1，
1.2 進堆疊和出堆疊
基于堆疊結構的特點，在實際應用中，通常只會對堆疊執行以下兩種操作：
（1）向堆疊中添加元素，此程序被稱為"進堆疊"（入堆疊或壓堆疊）；
（2）從堆疊中提取出指定元素，此程序被稱為"出堆疊"（或彈堆疊）；
1.3 堆疊的具體實作
堆疊是一種 “特殊” 的線性存盤結構，因此堆疊的具體實作有以下兩種方式：
（1）順序堆疊：采用順序存盤結構可以模擬堆疊存盤資料的特點，從而實作堆疊存盤結構；
（2）鏈堆疊：采用鏈式存盤結構實作堆疊結構；
兩種實作方式的區別，僅限于資料元素在實際物理空間上存放的相對位置，順序堆疊底層采用的是陣列，鏈堆疊底層采用的是鏈表，有關順序堆疊和鏈堆疊的具體實作會在后續章節中作詳細講解，
1.4 堆疊的應用
基于堆疊結構對資料存取采用 “先進后出” 原則的特點，它可以用于實作很多功能，
例如，我們經常使用瀏覽器在各種網站上查找資訊，假設先瀏覽的頁面 A，然后關閉了頁面 A 跳轉到頁面 B，隨后又關閉頁面 B 跳轉到了頁面 C，而此時，我們如果想重新回到頁面 A，有兩個選擇：
（1）重新搜索找到頁面 A；
（2）使用瀏覽器的"回退"功能，瀏覽器會先回退到頁面 B，而后再回退到頁面 A，
瀏覽器 “回退” 功能的實作，底層使用的就是堆疊存盤結構，當你關閉頁面 A 時，瀏覽器會將頁面 A 入堆疊；同樣，當你關閉頁面 B 時，瀏覽器也會將 B入堆疊，因此，當你執行回退操作時，才會首先看到的是頁面 B，然后是頁面 A，這是堆疊中資料依次出堆疊的效果，
不僅如此，堆疊存盤結構還可以幫我們檢測代碼中的括號匹配問題，多數編程語言都會用到括號（小括號、中括號和大括號），括號的錯誤使用（通常是丟右括號）會導致程式編譯錯誤，而很多開發工具中都有檢測代碼是否有編輯錯誤的功能，其中就包含檢測代碼中的括號匹配問題，此功能的底層實作使用的就是堆疊結構，
同時，堆疊結構還可以實作數值的進制轉換功能，例如，撰寫程式實作從十進制數自動轉換成二進制數，就可以使用堆疊存盤結構來實作，
2. 順序堆疊及基本操作（包含入堆疊和出堆疊）
2.1 順序堆疊的基礎介紹
順序堆疊，即用順序表實作堆疊存盤結構，通過前面的學習我們知道，使用堆疊存盤結構操作資料元素必須遵守 “先進后出” 的原則，本節就 “如何使用順序表模擬堆疊以及實作對堆疊中資料的基本操作（出堆疊和入堆疊）” 給大家做詳細介紹，
如果你仔細觀察順序表（底層實作是陣列）和堆疊結構就會發現，它們存盤資料的方式高度相似，只不過堆疊對資料的存取程序有特殊的限制，而順序表沒有，
例如，我們先使用順序表（a 陣列）存盤 {1,2,3,4}，存盤狀態如圖 1 所示：
同樣，使用堆疊存盤結構存盤 {1,2,3,4}，其存盤狀態如圖 2 所示：
通過圖 1 和圖 2 的對比不難看出，使用順序表模擬堆疊結構很簡單，只需要將資料從 a 陣列下標為 0 的位置依次存盤即可，
從陣列下標為 0 的模擬堆疊存盤資料是常用的方法，從其他陣列下標處存盤資料也完全可以，這里只是為了方便初學者理解，
了解了順序表模擬堆疊存盤資料后，接下來看如何模擬堆疊中元素出堆疊的操作，由于堆疊對存盤元素出堆疊的次序有"先進后出"的要求，如果想將圖 1 中存盤的元素 1 從堆疊中取出，需先將元素 4、元素 3 和元素 2 依次從堆疊中取出，
這里給出使用順序表模擬堆疊存盤結構常用的實作思路，即在順序表中設定一個實時指向堆疊頂元素的變數（一般命名為 top），top 初始值為 -1，表示堆疊中沒有存盤任何資料元素，及堆疊是"空堆疊"，一旦有資料元素進堆疊，則 top 就做 +1 操作；反之，如果資料元素出堆疊，top 就做 -1 操作，
2.2 順序堆疊元素"入堆疊"
比如，還是模擬堆疊存盤 {1,2,3,4} 的程序，最初，堆疊是"空堆疊"，即陣列是空的，top 值為初始值 -1，如圖 3 所示：
首先向堆疊中添加元素 1，我們默認陣列下標為 0 一端表示堆疊底，因此，元素 1 被存盤在陣列 a[1] 處，同時 top 值 +1，如圖 4 所示：
采用以上的方式，依次存盤元素 2、3 和 4，最終，top 值變為 3，如圖 5 所示：
2.3 順序堆疊元素"出堆疊"
其實，top 變數的設定對模擬資料的 “入堆疊” 操作沒有實際的幫助，它是為實作資料的 “出堆疊” 操作做準備的，
比如，將圖 5 中的元素 2 出堆疊，則需要先將元素 4 和元素 3 依次出堆疊，需要注意的是，當有資料出堆疊時，要將 top 做 -1 操作，因此，元素 4 和元素 3 出堆疊的程序分別如圖 6a) 和 6b) 所示：
注意，圖 6 陣列中元素的消失僅是為了方便初學者學習，其實，這里只需要對 top 值做 -1 操作即可，因為 top 值本身就表示堆疊的堆疊頂位置，因此 top-1 就等同于堆疊頂元素出堆疊，并且后期向堆疊中添加元素時，新元素會存盤在類似元素 4 這樣的舊元素位置上，將舊元素覆寫，
關于順序堆疊Python編程實作代碼可參考↓（個人撰寫，僅供參考，歡迎提出寶貴建議）
任務一：順序堆疊的表示和實作（難度：★）
實作基本功能：（包括但不限于，可以根據自己能力繼續擴展）
（1）初始化空堆疊
（2）判斷堆疊是否為空
（3）回傳堆疊頂元素
（4）回傳堆疊的長度
（5）進堆疊（又稱壓堆疊、入堆疊）
（6）出堆疊
（7）清空堆疊
代碼實作：
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2021/7/27 13:52
# @Author : vaxtiandao
# @File : sqStack_21.py
# -*-coding:utf-8-*-
# 定義順序堆疊
class sqStack:
# 初始化堆疊
def __init__(self, MAXSIZE):
self.MAXSIZE = MAXSIZE
self.data = [None] * self.MAXSIZE
self.top = -1
# 判斷當前堆疊是否為空
def is_empty(self):
return self.top == -1
def gettop(self):
if self.is_empty():
print("當前順序堆疊為空")
return None
else:
return self.data[self.top]
# 入堆疊
def Push(self, item):
# 判斷堆疊是否已滿
if self.top == self.MAXSIZE - 1:
return "sqStack is full."
self.data[self.top+1] = item
self.top += 1
# 串列入堆疊
def ListPush(self, x):
# 判斷堆疊是否已滿
if self.top == self.MAXSIZE - 1:
return "sqStack is full."
for i in range((len(x))):
self.Push(x[i])
# 出堆疊
def Pop(self):
# 判斷堆疊是否為空
if self.is_empty():
return "sqStack is empty"
rs = self.data[self.top]
self.top -= 1
return rs
# 輸出堆疊的長度
def size(self):
return self.top + 1
# 輸出堆疊內元素
def display(self):
# 判斷堆疊是否為空
if self.is_empty():
print("當前順序堆疊為空", end=" ")
else:
print("當前鏈表元素為：", end="")
for i in range(self.top+1):
print(self.data[i], end=" ")
print()
# 清空堆疊
def clear(self):
self.data = [None] * self.MAXSIZE
self.top = -1
if __name__ == '__main__':
print('---------------------------------')
# 初始化一個長度為20的順序堆疊
s = sqStack(20)
print("初始化堆疊：", s)
print('---------------------------------')
# 判斷當前堆疊是否為空
print("當前堆疊是否為空：", s.is_empty())
print('---------------------------------')
# 輸出堆疊的元素
s.display()
print('---------------------------------')
print("入堆疊前堆疊內元素：", end="")
s.display()
# 入堆疊
s.Push(1)
s.Push(10)
s.Push(100)
# 輸出當前堆疊內的元素
print("入堆疊后堆疊內元素：", end="")
s.display()
print('---------------------------------')
print("當前堆疊的長度為：", s.size())
print('---------------------------------')
print("佇列入堆疊前堆疊內元素：", end="")
s.display()
s.ListPush([1, 2, 3, 4])
print("佇列入堆疊后堆疊內元素：", end="")
s.display()
print('---------------------------------')
print("當前堆疊頂元素為：", s.gettop())
print('---------------------------------')
# 頂端元素出堆疊
print("出堆疊前堆疊內元素：", end="")
s.display()
print("出堆疊元素為：", s.Pop())
print("出堆疊后堆疊內元素：", end="")
s.display()
print('---------------------------------')
# 輸出當前堆疊內的元素
s.display()
print('---------------------------------')
s.clear()
s.display()
print('---------------------------------')
實作效果：
3. 鏈堆疊及基本操作（包含入堆疊和出堆疊）詳解
3.1 鏈堆疊的基本介紹
鏈堆疊，即用鏈表實作堆疊存盤結構，
鏈堆疊的實作思路同順序堆疊類似，順序堆疊是將數順序表（陣列）的一端作為堆疊底，另一端為堆疊頂；鏈堆疊也如此，通常我們將鏈表的頭部作為堆疊頂，尾部作為堆疊底，如圖 1 所示：
將鏈表頭部作為堆疊頂的一端，可以避免在實作資料 “入堆疊” 和 “出堆疊” 操作時做大量遍歷鏈表的耗時操作，
鏈表的頭部作為堆疊頂，意味著：
（1）在實作資料"入堆疊"操作時，需要將資料從鏈表的頭部插入；
（2）在實作資料"出堆疊"操作時，需要洗掉鏈表頭部的首元節點；
因此，鏈堆疊實際上就是一個只能采用頭插法插入或洗掉資料的鏈表，
3.2 鏈堆疊元素入堆疊
例如，將元素 1、2、3、4 依次入堆疊，等價于將各元素采用頭插法依次添加到鏈表中，每個資料元素的添加程序如圖 2 所示：
3.3 鏈堆疊元素出堆疊
例如，圖 2e) 所示的鏈堆疊中，若要將元素 3 出堆疊，根據"先進后出"的原則，要先將元素 4 出堆疊，也就是從鏈表中摘除，然后元素 3 才能出堆疊，整個操作程序如圖 3 所示：
關于鏈堆疊Python編程實作代碼可參考↓（個人撰寫，僅供參考，歡迎提出寶貴建議）
任務二：鏈堆疊的表示和實作（難度：★★）
實作基本功能：（跟順序堆疊一樣）
（1）初始化空堆疊
（2）判斷堆疊是否為空
（3）回傳堆疊頂元素
（4）回傳堆疊的長度
（5）進堆疊（又稱壓堆疊、入堆疊）
（6）出堆疊
（7）清空堆疊
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2021/7/27 14:47
# @Author : vaxtiandao
# @File : liStack.py
# 定義鏈堆疊節點
class Node(object):
# 初始化鏈堆疊
def __init__(self, data):
self.data = data
self.next = None
# 定義鏈堆疊
class linkstack(object):
# 初始化鏈堆疊
def __init__(self):
self.top = None
# 判斷鏈堆疊是否為空
def is_empty(self):
return self.top == None
# 清空鏈堆疊
def clear(self):
self.top = None
# 回傳當前堆疊的長度
def size(self):
i = 0
tempnode = self.top
while tempnode is not None:
tempnode = tempnode.next
i += 1
return i
# 元素入堆疊
def push(self, item):
node = Node(item)
node.next = self.top
self.top = node
# 堆疊頂元素出堆疊
def pop(self):
x = self.top.data
self.top = self.top.next
return x
# 獲取堆疊頂元素
def gettop(self):
return self.top.data
# 輸出當前堆疊內元素
def display(self):
if self.top == None:
print("當前堆疊內元素為空", end="")
else:
print("當前堆疊內元素為：", end="")
tempnode = self.top
while tempnode is not None:
print(tempnode.data, end=" ")
tempnode = tempnode.next
print()
if __name__ == "__main__":
print("-----------------------")
s1 = linkstack()
print("初始化的堆疊為：", s1)
print("-----------------------")
print("入堆疊前的鏈堆疊元素為：", end="")
s1.display()
s1.push(1)
s1.push(2)
s1.push(3)
s1.push(4)
s1.push(5)
s1.push(6)
print("入堆疊后的鏈堆疊元素為：", end="")
s1.display()
print("-----------------------")
print("當前堆疊頂元素為：", s1.gettop())
print("-----------------------")
print("當前鏈堆疊的長度為：", s1.size())
print("-----------------------")
print("出堆疊前的鏈堆疊元素為：", end="")
s1.display()
print("出堆疊元素為：", s1.pop())
print("出堆疊后的鏈堆疊元素為：", end="")
s1.display()
print("-----------------------")
print("清空前的鏈堆疊元素為：", end="")
s1.display()
s1.clear()
print("清空后的鏈堆疊元素為：", end="")
s1.display()
print("-----------------------")
print("當前鏈堆疊是否為空：", s1.is_empty())
print("-----------------------")
實作效果：
4.堆疊的應用（難度：★★）
應用1：括號匹配問題
檢驗演算法借助一個堆疊，每當讀入一個左括號，則直接入堆疊，等待相匹配的同類右括號；每當讀入一個右括號，若與當前堆疊頂的左括號型別相同，則二者匹配，將堆疊頂的左括號出堆疊，直到運算式掃描完畢，
在處理程序中，還要考慮括號不匹配出錯的情況，例如，當出現 (()[]) 這種情況時，由于前面入堆疊的左括號均已知和后面出現的右括號相匹配，堆疊已空，因此最后掃描的右括號不能得到匹配；出現 [([]) 這種錯誤，當運算式掃描結束時，堆疊中還有一個左括號沒有匹配；出現 (()] 這種錯誤顯然是堆疊頂的左括號和最后的右括號不匹配，
測驗案例：（小伙伴們需要拿以下三個案例測驗自己寫的代碼哈！）
案例1：{{([][])}()}
案例2：[[{{(())}}]]
案例3：[[(()(()))])]{}
運行結果：
關于此題編程實作代碼可參考↓（個人撰寫，僅供參考，歡迎提出寶貴建議）
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2021/7/28 10:14
# @Author : vaxtiandao
# @File : ds_parentMatching.py
# 定義順序堆疊
class sqStack:
# 初始化堆疊
def __init__(self, MAXSIZE):
self.MAXSIZE = MAXSIZE
self.data = [None] * self.MAXSIZE
self.top = -1
# 判斷當前堆疊是否為空
def is_empty(self):
return self.top == -1
def gettop(self):
if self.is_empty():
print("當前順序堆疊為空")
return None
else:
return self.data[self.top]
# 入堆疊
def Push(self, item):
# 判斷堆疊是否已滿
if self.top == self.MAXSIZE - 1:
return "sqStack is full."
self.data[self.top + 1] = item
self.top += 1
# 串列入堆疊
def ListPush(self, x):
# 判斷堆疊是否已滿
if self.top == self.MAXSIZE - 1:
return "sqStack is full."
for i in range((len(x))):
self.Push(x[i])
# 出堆疊
def Pop(self):
# 判斷堆疊是否為空
if self.is_empty():
return "sqStack is empty"
rs = self.data[self.top]
self.top -= 1
return rs
# 輸出堆疊的長度
def size(self):
return self.top + 1
# 輸出堆疊內元素
def display(self):
# 判斷堆疊是否為空
if self.is_empty():
print("當前順序堆疊為空", end=" ")
else:
print("當前鏈表元素為：", end="")
for i in range(self.top + 1):
print(self.data[i], end=" ")
print()
# 清空堆疊
def clear(self):
self.data = [None] * self.MAXSIZE
self.top = -1
def matching(strings): # 輸入是一串字符
bktStack = sqStack(60) # 創建類實體
flag = 1
opens = "{[("
closes = "}])"
# 對于每個輸入字符
for i in strings:
# 遇到左括號，就將其壓堆疊
if i in opens:
bktStack.Push(i)
# 遇到右括號
elif i in closes:
# 若已沒左括號與之匹配
if bktStack.is_empty():
# 不匹配，結束
return False
# 左括號按什么順序入，右括號應按相反順序消掉，
# 如果匹配，右括號消的始終是堆疊頂括號，
# 彈堆疊bktStack.pop()，判斷堆疊頂左括號與當前右括號是否匹配
if closes.index(i) != opens.index(bktStack.Pop()):
# 不匹配，結束
return False
# 若一直沒有return而是遍歷了一遍，且沒有多余左括號留在堆疊中，則說明匹配，反之不匹配，
return bktStack.is_empty()
# 判斷回傳的是True還是False
def check(strings):
if matching(strings):
print("%s 匹配正確!" % strings)
else:
print("%s 匹配錯誤！" % strings)
if __name__ == "__main__":
# 測驗函式
for i in range(4):
stringa = input()
check(stringa)
實作效果：
應用2：十進制轉二進制
當將一個十進制整數M轉換為二進制數時，在計算程序中，把M與2求余得到的二進制數的各位依次進堆疊，計算完畢后將堆疊中的二進制數依次出堆疊輸出，輸出結果就是待求得的二進制數，
測驗案例：
[200, 254, 153, 29, 108, 631, 892]
運行結果：
關于此題編程實作代碼可參考↓（個人撰寫，僅供參考，歡迎提出寶貴建議）
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2021/7/28 10:31
# @Author : vaxtiandao
# @File : ds_10to2.py
# 定義順序堆疊
class sqStack:
# 初始化堆疊
def __init__(self, MAXSIZE):
self.MAXSIZE = MAXSIZE
self.data = [None] * self.MAXSIZE
self.top = -1
# 判斷當前堆疊是否為空
def is_empty(self):
return self.top == -1
def gettop(self):
if self.is_empty():
print("當前順序堆疊為空")
return None
else:
return self.data[self.top]
# 入堆疊
def Push(self, item):
# 判斷堆疊是否已滿
if self.top == self.MAXSIZE - 1:
return "sqStack is full."
self.data[self.top + 1] = item
self.top += 1
# 串列入堆疊
def ListPush(self, x):
# 判斷堆疊是否已滿
if self.top == self.MAXSIZE - 1:
return "sqStack is full."
for i in range((len(x))):
self.Push(x[i])
# 出堆疊
def Pop(self):
# 判斷堆疊是否為空
if self.is_empty():
return "sqStack is empty"
rs = self.data[self.top]
self.top -= 1
return rs
# 輸出堆疊的長度
def size(self):
return self.top + 1
# 輸出堆疊內元素
def display(self):
# 判斷堆疊是否為空
if self.is_empty():
print("當前順序堆疊為空", end=" ")
else:
print("當前鏈表元素為：", end="")
for i in range(self.top + 1):
print(self.data[i], end=" ")
print()
# 清空堆疊
def clear(self):
self.data = [None] * self.MAXSIZE
self.top = -1
if __name__ == "__main__":
s = sqStack(20)
data = int(input("請輸入要轉換成二進制的數字： "))
while data != 0:
ys = data % 2
s.Push(ys)
data = data // 2
while s.top != -1:
print(s.Pop(), end='')
實作效果：
應用3
十進制轉N進制（應用2的拓展）
當將一個十進制整數M轉換為N進制數時，在計算程序中，把M與N求余得到的N進制數的各位依次進堆疊，計算完畢后將堆疊中的N進制數依次出堆疊輸出，輸出結果就是待求得的N進制數，
測驗案例：
測驗數：[200, 254, 153, 29, 108, 631, 892]
進制：[4, 8, 16]
自由搭配即可，這里我主要使用了random.choice()來對測驗數要轉換的進制隨機取數，測驗代碼如下所示，僅供參考；
運行結果：
關于此題編程實作代碼可參考↓（個人撰寫，僅供參考，歡迎提出寶貴建議）
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2021/7/28 10:32
# @Author : vaxtiandao
# @File : ds_10toN.py
# 定義順序堆疊
class sqStack:
# 初始化堆疊
def __init__(self, MAXSIZE):
self.MAXSIZE = MAXSIZE
self.data = [None] * self.MAXSIZE
self.top = -1
# 判斷當前堆疊是否為空
def is_empty(self):
return self.top == -1
def gettop(self):
if self.is_empty():
print("當前順序堆疊為空")
return None
else:
return self.data[self.top]
# 入堆疊
def Push(self, item):
# 判斷堆疊是否已滿
if self.top == self.MAXSIZE - 1:
return "sqStack is full."
self.data[self.top + 1] = item
self.top += 1
# 串列入堆疊
def ListPush(self, x):
# 判斷堆疊是否已滿
if self.top == self.MAXSIZE - 1:
return "sqStack is full."
for i in range((len(x))):
self.Push(x[i])
# 出堆疊
def Pop(self):
# 判斷堆疊是否為空
if self.is_empty():
return "sqStack is empty"
rs = self.data[self.top]
self.top -= 1
return rs
# 輸出堆疊的長度
def size(self):
return self.top + 1
# 輸出堆疊內元素
def display(self):
# 判斷堆疊是否為空
if self.is_empty():
print("當前順序堆疊為空", end=" ")
else:
print("當前鏈表元素為：", end="")
for i in range(self.top + 1):
print(self.data[i], end=" ")
print()
# 清空堆疊
def clear(self):
self.data = [None] * self.MAXSIZE
self.top = -1
def divideByN(number, base):
digits = "0123456789ABCDEF"
remstack = sqStack(100)
while number > 0:
rem = number % base
remstack.Push(rem)
number = number // base
newString = ""
while not remstack.is_empty():
newString = newString + digits[remstack.Pop()]
return newString
import random
numbers = [200, 254, 153, 29, 108, 631, 892]
bases = [4, 8, 6]
for number in numbers:
base = random.choice(bases)
print("%d 的 %d 進制數為：%s" % (number, base, divideByN(number, base)))
實作效果：
回顧資料結構專欄往期內容：【Python資料結構系列】《線性表》——知識點講解+代碼實作
其他專欄精彩內容：
【建議收藏系列】爆肝3w字帶你理解什么叫運維~
10分鐘教你如何自動化操控瀏覽器——Selenium測驗工具
【一周掌握Flask框架學習筆記】Flask概念及基礎
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/292343.html
標籤：其他
上一篇：漫畫 | Google：互聯網太慢了，我要替換TCP！
下一篇：【Linux】權限管理