簡析資料結構

摘要： 一、資料結構的定義 官方定義： 資料結構是指相互之間存在著一種或多種關係的資料元素的集合和該集合中資料元素之間的關係組成。 簡單理解： 資料結構就是設計資料以何種方式組織並存儲在計算機中。比如：列表、集合與字典等都是一種資料結構。 程式=資料結構+演算法 二、資料結構的...

一、資料結構的定義

官方定義：

資料結構是指相互之間存在著一種或多種關係的資料元素的集合和該集合中資料元素之間的關係組成。

簡單理解：

資料結構就是設計資料以何種方式組織並存儲在計算機中。比如：列表、集合與字典等都是一種資料結構。

程式=資料結構+演算法

二、資料結構的分類

資料結構按照其邏輯結構可分為線性結構、樹結構、圖結構

線性結構：資料結構中的元素存在一對一的相互關係(列表)

樹結構：資料結構中的元素存在一對多的相互關係(堆)

圖結構：資料結構中的元素存在多對多的相互關係

-----python的列表

在其他程式語言中被稱為“陣列”，在資料結構中可以統稱為“順序表”，即在記憶體的儲存中是線性的。

列表和陣列的不同之處：

1.陣列要求儲存的資料型別是一樣的。python的列表沒有要求。

2.陣列的長度在宣告時就固定了，不可變的。python的列表長度可變。

python中的列表在資料結構學科中又被稱作是動態表，它在記憶體中的儲存方式大概是這樣的，當你建立一個列表時，系統會先分配一塊特定的記憶體，當列表中元素增滿時，系統會再從新開闢一塊之前容量2倍的新記憶體，然後將之前的資料copy到新開記憶體中，釋放原來的舊地址，反之也是。通過這種 動態擴張的形式讓 python的列表保證了長度可變。

陣列通過規定儲存的資料型別是相同的，同時是線性儲存的特點，通過 陣列的首地址和下標 的關係保證了查詢和儲存資料的高效。而python的列表通過 儲存元素記憶體指標的方式 既可以保證可以儲存不同資料型別的資料，又可以保證查詢和儲存的高效（python在記憶體儲存方面有一個小資料池的概念，它在python實現資料儲存上起到了很大的作用）。

----棧

class Stark(list):
def __init__(self, *args, **kwargs):
super(Stark, self).__init__(*args, **kwargs)

def push(self, val):
self.append(val)

def _pop(self):
return self.pop()

棧的實際應用（括號匹配問題）

括號匹配問題：

給一個字串，其中包含小括號、中括號、大括號，求該字串中的括號是否匹配。

例如：

()()[]{} 匹配

([{()}]) 匹配

[]( 不匹配

[(]) 不匹配

def brace_match(s):
stack = []
match = {')':'(', ']':'[', '}':'{'}
match2 = {'(':')', '[':']', '{':'}'}
for ch in s:
if ch in {'(', '[', '{'}:
stack.append(ch)
elif len(stack) == 0:
print("缺少%s" % match[ch])
return False
elif stack[-1] == match[ch]:
stack.pop()
else:
print("括號不匹配")
return False
if len(stack) > 0:
print("缺少%s" % (match2[stack[-1]]))
return False
return True

棧的應用——迷宮問題

maze = [
[1,1,1,1,1,1,1,1,1,1],
[1,0,0,1,0,0,0,1,0,1],
[1,0,0,1,0,0,0,1,0,1],
[1,0,0,0,0,1,1,0,0,1],
[1,0,1,1,1,0,0,0,0,1],
[1,0,0,0,1,0,0,0,0,1],
[1,0,1,0,0,0,1,0,0,1],
[1,0,1,1,1,0,1,1,0,1],
[1,1,0,0,0,0,0,0,0,1],
[1,1,1,1,1,1,1,1,1,1]
]

dirs = [
lambda x,y:(x-1,y),#上
lambda x,y:(x,y+1),#右
lambda x,y:(x+1,y),#下
lambda x,y:(x,y-1),#左
]

def solve_maze(x1, y1, x2, y2):
stack = []
stack.append((x1,y1))
maze[x1][y1] = 2
while len(stack) > 0:# 當棧不空迴圈
cur_node = stack[-1]
if cur_node == (x2,y2): #到達終點
for p in stack:
print(p)
return True
for dir in dirs:# 四個方向探查
next_node = dir(*cur_node)
if maze[next_node[0]][next_node[1]] == 0:#找到一個能走的方向
stack.append(next_node)
maze[next_node[0]][next_node[1]] = 2# 2表示已經走過的點
break
else: #如果一個方向也找不到
stack.pop()
else:
print("無路可走")
return False

----佇列

佇列解決迷宮問題

from collections import deque

maze = [
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 1, 0, 0, 0, 1, 0, 1],
[1, 0, 0, 1, 0, 0, 0, 1, 0, 1],
[1, 0, 0, 0, 0, 1, 1, 0, 0, 1],
[1, 0, 1, 1, 1, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 1, 0, 0, 0, 0, 1],
[1, 0, 1, 0, 0, 0, 1, 0, 0, 1],
[1, 0, 1, 1, 1, 0, 1, 1, 0, 1],
[1, 1, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
]

dirs = [
lambda x, y: (x - 1, y),# 上
lambda x, y: (x, y + 1),# 右
lambda x, y: (x + 1, y),# 下
lambda x, y: (x, y - 1),# 左
]

def solve_maze2(x1, y1, x2, y2):
queue = deque()
path = []# 記錄出隊之後的節點
queue.append((x1, y1, -1))
maze[x1][y1] = 2
while len(queue) > 0:
cur_node = queue.popleft()
path.append(cur_node)
if cur_node[0] == x2 and cur_node[1] == y2:# 到終點
real_path = []
x, y, i = path[-1]
real_path.append((x, y))
while i >= 0:
node = path[I]
real_path.append(node[0:2])
i = node[2]
real_path.reverse()
for p in real_path:
print(p)
return True
for dir in dirs:# 四個方向探查
next_node = dir(cur_node[0], cur_node[1])
if maze[next_node[0]][next_node[1]] == 0:# 可以走
queue.append((next_node[0], next_node[1], len(path) - 1))
maze[next_node[0]][next_node[1]] = 2# 標記為已經走過
else:
print("無路可走")
return False

----連結串列

頭插法程式碼演示

class Node:
def __init__(self, data):
self.data = data
self.next = None

def create_linklist(li):
head = Node(None)# 頭節點
for num in li:
node = Node(num)
node.next = head.next#先接後面的再接前面的，防止丟失資料
head.next = node
return head

def print_linklist(head):
node = head.next
while node:
print(node.data)
node = node.next

尾插法程式碼演示

class Node:
def __init__(self, data):
self.data = data
self.next = None

def create_linklist_tail(li):
head = Node(None)# 空的頭節點
tail = head# 定義一個尾巴記錄一下
for num in li:
node = Node(num)
tail.next = node# 連結新資料
tail = node# 更新尾巴
return head

def print_linklist(head):
node = head.next
while node:
print(node.data)
node = node.next

雙向連結串列

雙鏈表中每個節點有兩個指標：一個指向後面節點、一個指向前面節點。

和連結串列的情況大體一致，當涉及到插入刪除是記得畫圖，直觀的保證資料的安全。

連結串列和順序表的對比：

連結串列在插入和刪除的操作上明顯快於順序表

連結串列的記憶體可以更靈活的分配

連結串列這種鏈式儲存的資料結構對樹和圖的結構有很大的啟發性

----雜湊表

雜湊表概念：

一個通過雜湊函式來計算資料儲存位置的資料結構，通常支援如下操作：

insert(key, value)：插入鍵值對(key,value)-----鍵值就是字典，有鍵沒值就是集合

get(key)：如果存在鍵為key的鍵值對則返回其value，否則返回空值

delete(key)：刪除鍵為key的鍵值對

-----二叉樹

二叉樹的四種遍歷程式碼實現：

from collections import deque

class BiTreeNode:
# 構建二叉樹
def __init__(self, data):
self.data = data
self.lchild = None
self.rchild = None

a = BiTreeNode('A')
b = BiTreeNode('B')
c = BiTreeNode('C')
d = BiTreeNode('D')
e = BiTreeNode('E')
f = BiTreeNode('F')
g = BiTreeNode('G')

e.lchild = a
e.rchild = g
a.rchild = c
c.lchild = b
c.rchild = d
g.rchild = f

root = e

def pre_order(root):
# 前序遍歷
if root:
print(root.data, end='')
pre_order(root.lchild)
pre_order(root.rchild)

def in_order(root):
# 中序遍歷
if root:
in_order(root.lchild)
print(root.data, end='')
in_order(root.rchild)

def post_order(root):
# 後序遍歷
if root:
post_order(root.lchild)
post_order(root.rchild)
print(root.data, end='')

def level_order(root):
# 層次遍歷（佇列實現）
queue = deque()
queue.append(root)
while len(queue) > 0:
node = queue.popleft()
print(node.data, end='')
if node.lchild:
queue.append(node.lchild)
if node.rchild:
queue.append(node.rchild)

樹還有 二叉搜尋樹 和 AVL樹 ，如果有想進一步瞭解的，自行網上查詢資料吧！！！