常用数据结构
栈
class Stock():
def __init__(self):
self.items = []
def add(self,item):
self.items.append(item)
def pop(self):
return self.items.pop()
def size(self):
return len(self.items)
def isEmtpy(self):
return self.items == []
def peek(self):
return len(self.items) -1
队列
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)
def isEmtpy(self):
return self.items == []
单链表
class Node():
def __init__(self, item):
self.item = item
self.next = None
class Link():
def __init__(self):
self._head = None
def add(self, item):
node = Node(item)
node.next = self._head
self._head = node
def travel(self):
cur = self._head
while cur:
print(cur.item)
cur = cur.next
def length(self):
count = 0
cur = self._head
while cur:
count += 1
cur = cur.next
return count
def isEmpty(self):
return self._head == None
def search(self, item):
cur = self._head
find = False
while cur:
if cur.item == item:
find = True
return
else:
cur = cur.next
return find
def append(self, item):
node = Node(item)
cur = self._head
if self._head == None:
self._head = node
return
pre = None
while cur:
pre = cur
cur = cur.next
pre.next = node
def insert(self, pos, item):
node = Node(item)
if pos == 0:
node.next = self._head
self._head = node
return
cur = self._head
pre = None
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 True:
pre = cur
cur = cur.next
if cur.item == item:
pre.next = cur.next
break
elif cur == None:
break
def reverse(self):
cur = self._head
pre = None
cur_next = cur.next
while cur:
cur.next = pre
pre = cur
cur = cur_next
if cur != None:
cur_next = cur_next.next
self._head = pre
二叉树
# 封装节点
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_list = [cur]
while True:
first_item = q_list.pop(0)
if first_item.left != None:
# 判断取出节点的左节点是否为空 不为空假如到列表
q_list.append(first_item.left)
else:
first_item.left = node
break
# 判断右叶子节点是否为空
if first_item.right != None:
q_list.append(first_item.right)
else:
first_item.right = node
break
def travel(self):
cur = self.root
q_list = [cur]
while q_list:
first_item = q_list.pop(0)
print(first_item.item)
if first_item.left != None:
q_list.append(first_item.left)
if first_item.right != None:
q_list.append(first_item.right)
二叉树遍历
- 广度遍历
- 深度遍历：竖向遍历，需要作用在二叉树的每一颗子树
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_list = [cur]
while True:
first_item = q_list.pop(0)
if first_item.left != None:
# 判断取出节点的左节点是否为空 不为空假如到列表
q_list.append(first_item.left)
else:
first_item.left = node
break
# 判断右叶子节点是否为空
if first_item.right != None:
q_list.append(first_item.right)
else:
first_item.right = node
break
def forward(self, root):
# 将根左右作用在每一颗子树中，子树和子树是基于区分
# 参数root是子树的根节点
# 设计一个结束递归的结束条件
if root == None:
return
print(root.item)
self.forward(root.left)
self.forward(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)
排序二叉树
class Node():
def __init__(self,item):
self.item = item
self.left = None # 左节点
self.right = None # 右节点
# 封装排序二叉树
class SortTree():
def __init__(self):
self.root = None
def add(self,item):
node = Node(item)
# 树为空
if self.root == None:
self.root = node
return
# 树为非空
cur = self.root
while True:
if cur.item < item:
# 插入节点值大于根节点，将节点插入到根节点右侧
if cur.right == None:
cur.right = node
break
else:
cur = cur.right
else:
# 将节点插入到节点左侧
if cur.left == None:
cur.left = node
break
else:
cur = cur.left
def middle(self,root):
if root == None:
return
self.middle(root.left)
print(root.item)
self.middle(root.right)