顺序表
# 导入模块
from timeit import Timer
# 定义append_test
def append_test():
li = []
for i in range(10000):
li.append(i)
def insert_test():
li = []
for i in range(10000):
li.insert(0, i)
# 测试执行时间
append_timer = Timer('append_test()', 'from __main__ import append_test')
print('append插入执行时间：', append_timer.timeit(1000))
insert_timer = Timer('insert_test()', 'from __main__ import insert_test')
print('insert插入执行时间：', insert_timer.timeit(1000))
单向连表
class Node(object):
def __init__(self, elem):
# elem指数据元素
self.elem = elem
# 指向下一个节点的链接域
self.next = None
# 构造单向链表类
class SingleLinkList:
# 初始化方法
def __init__(self, node=None):
# 判断node是否为空
if node != None:
headNode = Node(node)
self.__head = headNode
else:
self.__head = node # 这个是 头部元素
# 在头部添加元素
def add(self, item):
# 将传入的值构造成节点
node = Node(item)
# 将新节点的链接域next指向头节点
node.next = self.__head
# 将链表的头__head指向新节点
self.__head = node
# 在单向链表尾部追加元素
def append(self, item):
# 将传入的值构造成节点
node = Node(item)
if self.is_empty(): # 单链表为空时候
self.__head = node
else: # 单链表不为空
curNode = self.__head
while curNode.next != None:
curNode = curNode.next
# 修改节点指向 最后一个节点的next指向node
curNode.next = node
# 在指定位置添加元素
def insert(self, pos, item):
# 如果传入的pos是小于等于0的数，默认的将节点插入头部
if pos <= 0:
self.add(item)
# 如果pos的值大于链表长度，直接将节点添加到尾部
elif pos > (self.length() - 1):
self.append(item)
else:
# 构造节点
node = Node(item)
count = 0
preNode = self.__head
while count < (pos - 1): # 找前一个节点
count += 1
preNode = preNode.next
# 修改指向
# 将前一个节点的next指向插入位置节点
node.next = preNode.next
# 将插入位置的前一个节点的next指向新节点
preNode.next = node
# 删除节点
def remove(self, item):
curNode = self.__head
preNode = None
while curNode != None:
if curNode.elem == item:
# 判断是否是头节点
if preNode == None: # 是头节点
self.__head = curNode.next
else:
# 删除
preNode.next = curNode.next
break
else:
preNode = curNode
curNode = curNode.next
# 查找节点是否存在
def search(self, item):
curNode = self.__head
while curNode != None:
if curNode.elem == item:
return True
curNode = curNode.next
return False
# 判断单向链表是否为空
def is_empty(self):
return self.__head == None
# 计算单向链表的长度
def length(self):
count = 0
curNode = self.__head
while curNode != None:
count += 1
curNode = curNode.next
return count
def travel(self):
curNode = self.__head
while curNode != None:
print(curNode.elem, end=' ')
curNode = curNode.next
print("")
if __name__ == '__main__':
# 初始化元素值为20的单向链表
# singleLinkList=SingleLinkList(20)
# 初始化一个空的单向链表
singleLinkList = SingleLinkList()
print('是否是空链表：', singleLinkList.is_empty())
print('链表的长度：', singleLinkList.length())
print('----------遍历单链表----------')
singleLinkList.travel()
print('--------查找---------')
print(singleLinkList.search(20))
print(singleLinkList.search(30))
print('------头部插入-----------')
singleLinkList.add(1)
singleLinkList.add(2)
singleLinkList.add(3)
singleLinkList.travel()
print('------尾部追加-----------')
singleLinkList.append(10)
singleLinkList.append(20)
singleLinkList.append(30)
singleLinkList.travel()
print('链表的长度：', singleLinkList.length())
print('----------指定位置插入----------')
singleLinkList.insert(2, 100)
singleLinkList.travel()
singleLinkList.insert(-1, 200)
singleLinkList.travel()
singleLinkList.insert(100, 300)
singleLinkList.travel()
print('---------删除节点--------')
singleLinkList.remove(100)
singleLinkList.travel()
singleLinkList.remove(200)
singleLinkList.travel()
singleLinkList.remove(300)
singleLinkList.travel()
双向链表
# 双向链表的节点
class Node:
def __init__(self, elem):
self.elem = elem
self.next = None # 后继 下一个节点
self.prev = None # 前驱 前一个节点
class DoubleLinkList:
# 初始化方法
def __init__(self, node=None):
# 判断node是否为空
if node != None:
headNode = Node(node)
self.__head = headNode
else:
self.__head = node
# 在头部添加元素
def add(self, item):
# 将传入的值构造成节点
node = Node(item)
# 判断是否是空链表
if self.is_empty():
self.__head = node
else:
# 将新节点的链接域next指向头节点
node.next = self.__head
# 将__head的头节点的prev指向node
self.__head.prev = node
# 将链表的头__head指向新节点
self.__head = node
# 在尾部追加元素
def append(self, item):
# 将传入的值构造成节点
node = Node(item)
if self.is_empty(): # 单链表为空时候
self.__head = node
else: # 不为空
curNode = self.__head
while curNode.next != None:
curNode = curNode.next
# 修改节点指向 最后一个节点的next指向node
curNode.next = node
# 将node节点的前驱指向当前节点
node.prev = curNode
# 在指定位置添加元素
def insert(self, pos, item):
# 如果传入的pos是小于等于0的数，默认的将节点插入头部
if pos <= 0:
self.add(item)
# 如果pos的值大于链表长度，直接将节点添加到尾部
elif pos > (self.length() - 1):
self.append(item)
else:
# 构造节点
node = Node(item)
count = 0
curNode = self.__head
while count < (pos - 1): # 找前一个节点
count += 1
curNode = curNode.next
# 修改指向
# 将node节点的前驱指向当前节点
node.prev = curNode
# 将node节点的后继指向当前节点的下一个节点
node.next = curNode.next
# 将当前节点的下一个节点的前驱指向node节点
curNode.next.prev = node
# 将当前节点的后继指向node节点
curNode.next = node
# 删除节点
def remove(self, item):
curNode = self.__head
while curNode != None:
if curNode.elem == item:
# 判断是否是头节点
if curNode == self.__head: # 是头节点
self.__head = curNode.next
# 判断当前节点是否只有一个节点，如果只有一个节点，则不需要移动下一个节点的前驱
if curNode.next:
curNode.next.prev = None
else:
# 删除
curNode.prev.next = curNode.next
# 判断当前节点是否是最后一个节点，如果是最后一个节点，最后一个节点的下一个节点指向None
if curNode.next:
curNode.next.prev = curNode.prev
break
else:
curNode = curNode.next
# 查找节点是否存在
def search(self, item):
curNode = self.__head
while curNode != None:
if curNode.elem == item:
return True
curNode = curNode.next
return False
# 判断是否为空
def is_empty(self):
return self.__head == None
# 计算链表的长度
def length(self):
count = 0
curNode = self.__head
while curNode != None:
count += 1
curNode = curNode.next
return count
# 遍历链表
def travel(self):
curNode = self.__head
while curNode != None:
print(curNode.elem, end=' ')
curNode = curNode.next
print("")
if __name__ == '__main__':
doubleLinkList = DoubleLinkList()
doubleLinkList.add(11)
doubleLinkList.add(22)
doubleLinkList.add(33)
doubleLinkList.travel()
print('-----------追加-----------')
doubleLinkList.append(100)
doubleLinkList.append(200)
doubleLinkList.append(300)
doubleLinkList.travel()
print('指定位置插入')
doubleLinkList.insert(-1, 44)
doubleLinkList.travel()
doubleLinkList.insert(100, 400)
doubleLinkList.travel()
doubleLinkList.insert(2, 1000)
doubleLinkList.travel()
print('------删除节点--------')
doubleLinkList.remove(44)
doubleLinkList.travel()
doubleLinkList.remove(1000)
doubleLinkList.travel()
doubleLinkList.remove(400)
doubleLinkList.travel()
print('链表的长度：', doubleLinkList.length())
print('查找节点11', doubleLinkList.search(11))
print('查找节点111', doubleLinkList.search(111))
栈郑州专业妇科医院 http://www.hnzzkd.com/
class Stack(object):
# 定义初始化方法
def __init__(self):
# 初始化一个空列表
self.__list = []
# 压栈
def push(self, item):
self.__list.append(item)
# 弹出元素
def pop(self):
return self.__list.pop()
# 返回栈顶元素
def peek(self):
return self.__list[len(self.__list) - 1]
# 判断栈是否为空
def is_empty(self):
return self.__list == []
# 计算栈的大小
def size(self):
return len(self.__list)
if __name__ == '__main__':
stack = Stack()
print('是否空栈吗', stack.is_empty())
# 压栈
stack.push(1)
stack.push(2)
stack.push(3)
stack.push(4)
print('是否空栈吗', stack.is_empty())
print('栈的长度：', stack.size())
# 弹出
print(stack.pop())
print(stack.pop())
print(stack.pop())
print(stack.pop())
队列
class Queue:
def __init__(self):
self.__list = []
# 进队
def enqueue(self, item):
# self.__list.append(item)
self.__list.insert(0, item)
# 出队
def dequeue(self):
# return self.__list.pop(0)
return self.__list.pop()
# 判断队列是否为空
def is_empty(self):
return self.__list == []
# 计算队列的大小
def size(self):
return len(self.__list)
if __name__ == '__main__':
queue = Queue()
queue.enqueue(10)
queue.enqueue(20)
queue.enqueue(30)
# 判断队列是否空
print(queue.is_empty())
print('队列大小', queue.size())
print('-----出队---------')
print(queue.dequeue())
print(queue.dequeue())
print(queue.dequeue())
二叉树
# 定义二叉树的节点
class Node:
def __init__(self, elem):
self.elem = elem
self.lchild = None
self.rchild = None
class Tree:
def __init__(self):
self.root = None
# 添加节点
def add(self, elem):
# 创建节点
node = Node(elem)
if self.root == None:
self.root = node
else:
queue = []
queue.append(self.root)
while queue:
curNode = queue.pop(0)
if curNode.lchild == None:
curNode.lchild = node
return
else:
queue.append(curNode.lchild)
if curNode.rchild == None:
curNode.rchild = node
return
else:
queue.append(curNode.rchild)
# 广度优先遍历
def travel(self):
queue = []
# 判断根节点是否存在
if self.root is None:
return
else:
queue.append(self.root)
while queue:
curNode = queue.pop(0)
print(curNode.elem, end=' ')
if curNode.lchild is not None:
queue.append(curNode.lchild)
if curNode.rchild is not None:
queue.append(curNode.rchild)
print()
# 先序遍历 根 左 右 0 1 3 7 8 4 9 2 5 6
def preOrder(self, root):
if root is None:
return
else:
print(root.elem, end=' ')
self.preOrder(root.lchild)
self.preOrder(root.rchild)
# 中序遍历 左 根 右 7 3 8 1 9 4 0 5 2 6
def inOrder(self, root):
if root is None:
return
else:
self.inOrder(root.lchild)
print(root.elem, end=' ')
self.inOrder(root.rchild)
# 后序遍历 左 右 根 7 8 3 9 4 1 5 6 2 0
def lastOrder(self, root):
if root is None:
return
else:
self.lastOrder(root.lchild)
self.lastOrder(root.rchild)
print(root.elem, end=' ')
if __name__ == '__main__':
tree = Tree()
tree.add(0)
tree.add(1)
tree.add(2)
tree.add(3)
tree.add(4)
tree.add(5)
tree.add(6)
tree.add(7)
tree.add(8)
tree.add(9)
print('广度优先遍历')
tree.travel()
print('先序遍历')
tree.preOrder(tree.root)
print()
print('中序遍历')
tree.inOrder(tree.root)
print()
print('后序遍历')
tree.lastOrder(tree.root)