线性数据结构Linear DS
作用:将数据项以某种线性的次序组织起来
1.栈Stack
栈Stack维持了数据项后进先出LIFO的次序 stack的基本操作包括push，pop，isEmpty
栈的两种实现
1.左为栈顶,时间复杂度为O(n)
#左边为顶,右边为低
class Stack:
def __init__(self):
self.items = []
def isEmpty(self):
return self.items == []
def push(self,item):
self.items.insert(0,item)
def pop(self):
return self.items.pop(0)
def peek(self):
return self.items[0]
def size(self):
return len(self.items)
2.右为栈顶,时间复杂度O(1)
# 左边为低,右边为顶--->更高效
class Stack:#Stack---->ADT
def __init__(self):
self.items =[]
def isEmpty(self):
return self.items == []
# 满足这些属性(行为)的是栈
def push(self,item):
self.items.append(item)
def pop(self):
return self.items.pop()
def peek(self):
return self.items[len(self.items)-1]
#
def size(self):
return len(self.items)
s = Stack()
2.队列Queue
队列Queue维持了数据项先进先出FIFO的次序 queue的基本操作包括enqueue， dequeue,isEmpty 有助于构建时序模拟
书写表达式的方法有前缀prefix、中缀infix和后缀postfix三种由于栈结构具有次序反转的特性，所以栈结构适合用于开发表达式求值和转换的算法 “模拟系统”可以通过一个对现实世界问题进行抽象建模，并加入随机数动态运行为复杂问题的决策提供各种情况的参考队列queue可以用来进行模拟系统的开发
3.双端队列Deque
双端队列Deque可以同时具备栈和队列的功能
deque的主要操作包括addFront，addRear, removeFront, removeRear, isEmpty
#创建一个双端队列(Dequeue)
class Dequeue:
#定义一个初始化函数然后创建一个空列表用于传递数据items
def __init__(self):
self.items = []
#判断列表是否为空
def isEmpty(self):
return self.items == []
#在队首加入元素items
def addFront(self,item):
self.items.append(item)
#在队尾加入元素items
def addRear(self,item):
self.items.insert(0,item)
#从队首移除数据,返回值为移除数据项
def removeFront(self):
return self.items.pop()
#从队尾移除数据,返回移除数据项
def removeRear(self):
return self.items.pop(0)
#判断列表是否为空
def isEmpty(self):
return self.items == []
#返回Dequeue中包含的数据项的个数
def size(self):
return len(self.items)
#palindrome - 回文检查
def pal_checker (ps):
#实例化对象
d = Dequeue()
for char in ps:
d.addRear(char)
#假设元素左右相等
still_equal = True
#依次取出首尾元素进行判断,然后再判断它是否满足 :
# 奇数个元素的时候,双端队列里面还剩下一个元素
#偶数个元素的时候,双端队列里面没有元素
while d.size() > 1 and still_equal :
#从队首取出一个元素
first = d.removeFront()
#从队尾取出一个元素
last = d.removeRear()
if first != last:
still_equal = False
return still_equal
print(pal_checker ("上海自来水来自海上"))
print(pal_checker ("110110"))
4.列表List
列表List是数据项能够维持相对位置的数据集
# 通过链表实现 无序表-列表
#列表 和 链表 都是无序表 unordered list
#实现链表
class Node:
def __init__(self,init_data):
self.data = init_data
self.next = None
#获得数据项
def get_data(self):
return self.data
#获得节点
def get_next(self):
return self.next
#设置数据项
def set_data(self,new_data):
self.data = new_data
#设置节点
def set_next(self,new_next):
self.next = new_next
#结点示例
temp = Node(93)
print(temp.get_data())
5.链表
链表的实现，可以保持列表维持相对位置(保证逻辑顺序)的特点，而不需要连续的存储空间 链表实现时，其各种方法，对链表头部head需要特别的处理
a.无序链表的实现
# 通过链表实现 无序表-列表
#列表 和 链表 都是无序表 unordered list
#实现链表 -- 链表相当于火车(顺藤摸瓜结构,如果放在链表后面,找那个车厢需要从头开始往后找)
class Node:#结点Node相当于车厢
def __init__(self,init_data):
self.data = init_data
self.next = None
#获得数据项
def get_data(self):
return self.data
#获得节点
def get_next(self):
return self.next
#设置数据项
def set_data(self,new_data):
self.data = new_data#属性
#设置节点
def set_next(self,new_next):
self.next = new_next#属性
#结点示例
temp = Node(93)
temp2 = Node(17)
temp3 = Node(77)
print(temp.get_data())
print(temp2.get_data())
print(temp3.get_data())
# 链表:1.有序表 2.无序表
#链表实现: 无序表 UnorderedList
#设立一个属性head , 保存对对第一个节点的引用
#空表的 head 为 None
class UnorderedList:
def __init__(self):
self.head = None
# mylist = UnorderedList()
# print (mylist.head)
#为item数据项生成一个结点-Node 叫做item
def add(self,item):
#然后将这个结点命名为临时变量
temp = Node(item)
#将下一个临时结点设置为表头
temp.set_next(self.head)
#表头指向新增加的临时结点
self.head = temp
def size(self):
#当前节点设为表头第一个节点
current = self.head
count = 0
while current != None:
count += 1
#将当前节点设为下一个结点的结点,循环往复
current = current.get_next()
#返回结点的个数
return count
def search(self,item):
current = self.head
found = False
while current != None and not found:
#判断当前节点数据项是否等于我想要找的数据
if current.get_data() == item:
found = True
else:
current = current.get_next()
return found
def remove(self,item):#删除找到的元素--引用两个指针当前和上继指针
current = self.head
previous = None
found = False
#先判断是不是我要找的那个元素
while not found:
if current.get_data == item:
found = True
else:
#通过current的指针给初始没有指针的previous指路
previous = current
#然后current指针继续往下走
current = current.get_next
# 如果中间位置找不到,那我们再判断表头
#当前删除的车厢部位值item 位于头部时,可以利用 previous 指向空
if previous == None:#当前想要删除的是不是车头处的元素
self.head = current.get_next()
else:
previous.set_next(current.get_next())#删除的是中间元素
def traverse(self):
current = self.head
while current != None:
print(current.get_data())
current = current.get_next()
#实例化无序表:
ll = UnorderedList()
# 加入新节点
ll.add(7)
ll.add(9)
ll.add(6)
ll.add(8)
ll.add(10)
print(ll.search(1000))
ll.traverse()
b.有序链表的实现
class Node:#结点Node相当于车厢
def __init__(self,init_data):
self.data = init_data
self.next = None
#获得数据项
def get_data(self):
return self.data
#获得节点
def get_next(self):
return self.next
#设置数据项
def set_data(self,new_data):
self.data = new_data#属性
#设置节点
def set_next(self,new_next):
self.next = new_next#属性
class Orderedlist:
def __init__(self):
self.head = None
def search(self,item):
current = self.head
found = False
stop = False
while current != None and not found and not stop:
if current.get_data() == item:
found = True
else:
if current.get_data() > item:
stop = True
else:
current = current.get_next()
return found
def add(self,item):
current = self.head#指针1
previous = None#p2
stop = False
while current != None and not stop:
#发现插入位置
if current.get_data() > item:
stop = True
else:
previous = current
current = current.get_next()
temp = Node(item)
#插在表头
if previous == None:
temp.set_next(self.head)
self.head = temp
#插在表中
else:
temp.set_next(current)
previous.set_next(temp)
def size(self):
current = self.head
count = 0
while current != None:
count += 1
current = current.get_next()
return count
def remove(self, item):
current = self.head
previous = None
found = False
while not found and current != None:
if current.get_data() == item:
found = True
else:
previous = current
current = current.get_next()
if found:
if previous == None:
self.head = current.get_next()
else:
previous.set_next(current.get_next())
def traverse(self):
current = self.head
while current != None:
print(current.get_data())
current = current.get_next()
ol = Orderedlist()
ol.add(7)
ol.add(9)
ol.add(6)
ol.add(8)
ol.add(10)
print(ol.search(6))
ol.traverse()