栈
栈(stack),也称堆栈,是一种容器,特点是在于只能允许在容器的一段进行加入数据和输出数据的运算。
由于栈数据结构只允许在一端进行操作,因而按照后进先出(LIFO,Last In First Out)的原理运作
在这里插入代码片class Stack(object):
'''栈'''
def __init__(self):
self.__list = []
def push(self, item):
'''添加一个新的元素item到栈顶'''
self.__list.append(item)
def pop(self):
'''弹出栈顶元素'''
return self.__list.pop()
def peck(self):
'''返回栈顶元素'''
if self.__list:
return self.__list[-1]
else:
return None
def is_empty(self):
'''判断栈是否为空'''
return self.__list == []
def size(self):
'''返回栈的元素个数'''
return len(self.__list)
if __name__ == '__main__':
s = Stack()
s.push(1)
s.push(2)
s.push(3)
s.push(4)
print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())
队列
普通队列
队列(queue)是只允许在一端进行插入操作,而在另一端进行删除操作的线性表
队列是一种先进先出(First In First Out)的线性表,简称FIFO
class Queue(object):
def __init__(self):
self.__list = []
#添加元素
def inqueue(self, item):
self.__list.append(item)
#从队列头部取出一个元素
def outqueue(self):
return self.__list.pop(0)
#判断队列是否为空
def is_empty(self, item):
return self.__list == []
#返回队列的大小
def size(self):
return len(self.__list)
if __name__ == '__main__':
s = Queue()
s.inqueue(1)
s.inqueue(2)
s.inqueue(3)
s.inqueue(4)
print(s.outqueue())
print(s.outqueue())
print(s.outqueue())
print(s.outqueue())
双端队列
class DoubleQueue(object):
def __init__(self):
self.__list = []
def look_data(self):
item = self.__list
return item
#从头部添加元素
def add_front(self, item):
self.__list.insert(0, item)
# 从尾部添加元素
def add_last(self, item):
self.__list.append(item)
#从队列头部取出一个元素
#从头部取出元素
def pop_front(self):
return self.__list.pop(0)
# 从尾部取出元素
def pop_last(self):
return self.__list.pop()
#判断队列是否为空
def is_empty(self, item):
return self.__list == []
#返回队列的大小
def size(self):
return len(self.__list)
if __name__ == '__main__':
s = DoubleQueue()
for i in range(0,5):
s.add_front(i)
for i in range(0,5):
s.add_last(i)
print(s.look_data())
print(s.size())
# for i in range(0,7):
# print(s.pop_front())
for i in range(0,7):
print(s.pop_last())
链表的实现
单向链表
class Node(object):
def __init__(self, elem):
self.elem = elem
self.next = None
class SingLelinklist(object):
def __init__(self, node=None):
self.__head = node
#判断链表是否为空
def is_empty(self):
return self.__head == None
#链表长度
def length(self):
# cur游标,用来移动遍历节点
cur = self.__head
# count记录数量
count = 0
while cur != None:
count += 1
cur = cur.next
return count
#遍历链表
def travel(self):
cur = self.__head
while cur != None:
print(cur.elem, end=' ')
cur = cur.next
print('')
#头插法
def add(self, item):
node = Node(item)
node.next = self.__head
self.__head = node
#尾插法
def append(self, item):
node = Node(item)
if self.is_empty():
self.__head = node
else:
cur = self.__head
while cur.next != None:
cur = cur.next
cur.next = node
#指定位置添加元素
def insert(self, pos, item):
#pos从0开始
if pos <= 0:
self.add(item)
elif pos > (self.length()-1):
self.append(item)
else:
pre = self.__head
count = 0
while count < (pos-1):
count += 1
pre = pre.next
#当循环退出后,pre只想pos-1位置
node = Node(item)
node.next = pre.next
pre.next = node
#删除节点
def remove(self, item):
cur = self.__head
pre = None
while cur != None:
if cur.elem == item:
#判断此节点是不是头结点
if cur == self.__head:
self.__head = cur.next
else:
pre.next = cur.next
break
else:
pre = cur
cur = cur.next
#查找节点是否存在
def search(self, item):
cur = self.__head
while cur != None:
if cur.elem == item:
return True
else:
cur = cur.next
return False
if __name__ == '__main__':
ll = SingLelinklist()
# print(ll.is_empty())
# print(ll.length())
ll.append(1)
# print(ll.is_empty())
# print(ll.length())
ll.append(2)
ll.add(8)
ll.append(3)
ll.append(4)
ll.append(5)
ll.append(6)
ll.travel()
ll.remove(8)
ll.travel()
ll.remove(6)
ll.travel()
单向循环链表
class Node(object):
def __init__(self, elem):
self.elem = elem
self.next = None
#单向循环列表
class SingLelinklist(object):
def __init__(self, node=None):
self.__head = node
if node:
node.next = node
#判断链表是否为空
def is_empty(self):
return self.__head == None
#链表长度
def length(self):
if self.is_empty():
return 0
cur = self.__head
count = 1
while cur.next != self.__head:
count += 1
cur = cur.next
return count
#遍历链表
def travel(self):
cur = self.__head
while cur.next != self.__head:
print(cur.elem, end=' ')
cur = cur.next
#退出循环,cur指向尾节点,但不没有打印
print(cur.elem)
#头插法
def add(self, item):
node = Node(item)
cur = self.__head
if self.is_empty():
self.__head = node
node.next = node
while cur.next != self.__head:
cur = cur.next
# 退出循环,cur指向尾节点
node.next = self.__head
self.__head = node
# cur.next = node
cur.next = self.__head
#尾插法
def append(self, item):
node = Node(item)
if self.is_empty():
self.__head = node
node.next = node
else:
cur = self.__head
while cur.next != self.__head:
cur = cur.next
cur.next = node
node.next = self.__head
#指定位置添加元素
def insert(self, pos, item):
#pos从0开始
if pos <= 0:
self.add(item)
elif pos > (self.length()-1):
self.append(item)
else:
pre = self.__head
count = 0
while count < (pos-1):
count += 1
pre = pre.next
#当循环退出后,pre只想pos-1位置
node = Node(item)
node.next = pre.next
pre.next = node
#删除节点
def remove(self, item):
cur = self.__head
pre = None
if self.is_empty():
return
while cur.next != self.__head:
if cur.elem == item:
#判断此节点是不是头结点
if cur == self.__head:
#头结点
rear = self.__head
while rear.next != self.__head:
rear = rear.next
self.__head = cur.next
rear.next = self.__head
#中间节点
else:
pre.next = cur.next
return
else:
pre = cur
cur = cur.next
#退出循环,cur指向尾节点
if cur.elem == item:
if cur == self.__head:
#链表只有一个节点
self.__head = None
else:
pre.next = cur.next
#查找节点是否存在
def search(self, item):
cur = self.__head
if self.is_empty():
return False
while cur.next != self.__head:
if cur.elem == item:
return True
else:
cur = cur.next
#退出循环,cur指向尾节点
if cur.elem == item:
return True
return False
if __name__ == '__main__':
ll = SingLelinklist()
# print(ll.is_empty())
# print(ll.length())
ll.append(1)
# print(ll.is_empty())
# print(ll.length())
ll.append(2)
ll.add(8)
ll.append(3)
ll.append(4)
ll.append(5)
ll.append(6)
ll.travel()
ll.remove(8)
ll.travel()
ll.remove(6)
ll.travel()