网站优化知识,wordpress邮件代发送,完全免费网站源码,window7用jsp做的网站要什么工具引言
什么是数据结构#xff1f;
数据结构是指相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成。
简单来说#xff0c;数据结构就是设计数据以何种方式组织并存储在计算机中。
比如#xff1a;列表#xff0c;集合和字典等都是数据结构
N.W…引言
什么是数据结构
数据结构是指相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成。
简单来说数据结构就是设计数据以何种方式组织并存储在计算机中。
比如列表集合和字典等都是数据结构
N.Wirth“程序数据结构算法”
数据结构按照其逻辑结构可分为线性结构、树结构、图结构
线性结构数据结构中的元素存在一对一的互相关系。
树结构数据结构中的元素存在一对多的互相关系。
图结构数据结构中的元素存在多对多的互相关系。
数组
在python中是没有数组的有的是列表它是一种基本的数据结构类型。
实现
classArray(object):def __init__(self, size32)::param size: 长度self._sizesize
self._items [None] *size#在执行array[key]时执行
def __getitem__(self, index):returnself._items[index]#在执行array[key] value 时执行
def __setitem__(self, index, value):
self._items[index]value#在执行len(array) 时执行
def __len__(self):returnself._size#清空数组
def clear(self, valueNone):for i inrange(len(self._items)):
self._items[i]value#在遍历时执行
def __iter__(self):for item inself._items:yield item
使用
a Array(4)
a[0] 1
print(a[0]) #1
a.clear()print(a[0]) #None
a[0] 1a[1] 2a[3] 4
for i ina:print(i) #1, 2, None, 4
链表
链表中每一个元素都是一个对象每一个对象被称为节点包含有数据域value和指向下一个节点的指针next。
通过各个节点直接的相互链接最终串成一个链表。实现
classNode(object):def __init__(self, valueNone, nextNone):
self.value, self.nextvalue, nextclassLinkedList(object):def __init__(self, sizeNone)::param size: int or None, 如果None则该链表可以无限扩充self.sizesize#定义一个根节点
self.root Node()#尾节点始终指向最后一个节点
self.tail_node None
self.length0def __len__(self):returnself.lengthdefappend(self, value):#size 不为 None, 且长度大于等于size则链表已满
if self.size and len(self) self.size:raise Exception(LinkedList is full)#构建节点
node Node(value)
tail_nodeself.tail_node#判断尾节点是否为空
if tail_node isNone:#还没有 append 过length 0 追加到 root 后
self.root.next nodeelse:#否则追加到最后一个节点的后边并更新最后一个节点是 append 的节点
tail_node.next node#把尾节点指向node
self.tail_node node#长度加一
self.length 1
#往左边添加
defappend_left(self, value):if self.size and len(self) self.size:raise Exception(LinkedList is full)#构建节点
node Node(value)#链表为空则直接添加设置
if self.tail_node isNone:
self.tail_nodenode#设置头节点为根节点的下一个节点
head_node self.root.next#把根节点的下一个节点指向node
self.root.next node#把node的下一个节点指向原头节点
node.next head_node#长度加一
self.length 1
#遍历节点
defiter_node(self):#第一个节点
current_node self.root.next#不是尾节点就一直遍历
while current_node is notself.tail_node:yieldcurrent_node#移动到下一个节点
current_node current_node.next#尾节点
if current_node is notNone:yieldcurrent_node#实现遍历方法
def __iter__(self):for node inself.iter_node():yieldnode.value#删除指定元素
defremove(self, value):#删除一个值为value的节点只要使该节点的前一个节点的next指向该节点的下一个
#定义上一个节点
perv_node self.root#遍历链表
for current_node inself.iter_node():if current_node.value value:#把上一个节点的next指向当前节点的下一个节点
perv_node.next current_node.next#判断当前节点是否是尾节点
if current_node isself.tail_node:#更新尾节点 tail_node
#如果第一个节点就找到了把尾节点设为空
if perv_node isself.root:
self.tail_nodeNoneelse:
self.tail_nodeperv_node#删除节点长度减一删除成功返回1
delcurrent_node
self.length- 1
return 1
else:
perv_nodecurrent_node#没找到返回-1
return -1
#查找元素找到返回下标没找到返回-1
deffind(self, value):
index0#遍历链表找到返回index,没找到返回-1
for node inself.iter_node():if node.value value:returnindex
index 1
return -1
#删除第一个节点
defpopleft(self):#链表为空
if self.root.next isNone:raise Exception(pop from empty LinkedList)#找到第一个节点
head_node self.root.next#把根节点的下一个节点指向第一个节点的下一个节点
self.root.next head_node.next#获取删除节点的value
value head_node.value#如果第一个节点是尾节点, 则把尾节点设为None
if head_node isself.tail_node:
self.tail_nodeNone#长度减一删除节点返回该节点的值
self.length - 1
delhead_nodereturnvalue#清空链表
defclear(self):for node inself.iter_node():delnode
self.root.nextNone
self.tail_nodeNone
self.length0#反转链表
defreverse(self):#第一个节点为当前节点并把尾节点指向当前节点
current_node self.root.next
self.tail_nodecurrent_node
perv_nodeNonewhilecurrent_node:#下一个节点
next_node current_node.next#当前节点的下一个节点指向perv_node
current_node.next perv_node#当前节点的下一个节点为空则把根节点的next指向当前节点
if next_node isNone:
self.root.nextcurrent_node#把当前节点赋值给perv_node
perv_node current_node#把下一个节点赋值为当前节点
current_node next_node
使用
ll LinkedList()
ll.append(0)
ll.append(1)
ll.append(2)
ll.append(3)print(len(ll)) #4
print(ll.find(2)) #2
print(ll.find(-1)) #-1
ll.clear()print(len(ll)) #0
print(list(ll)) #[]
循环链表
双链表中每一个节点有两个指针一个指向后面节点、一个指向前面节点。循环链表实现
classNode(object):def __init__(self, valueNone, prevNone, nextNone):
self.valuevalue
self.prevprev
self.nextnextclassCircularDoubleLinkedList(object):双向循环链表
def __init__(self, maxsizeNone):
self.maxsizemaxsize
nodeNode()
node.prevnode
node.nextnode
self.rootnode
self.length0def __len__(self):returnself.lengthdefhead_node(self):returnself.root.nextdeftail_node(self):returnself.root.prev#遍历
defiter_node(self):if self.root.next isself.root:returncurrent_nodeself.root.nextwhile current_node.next is notself.root:yieldcurrent_node
current_nodecurrent_node.nextyieldcurrent_nodedef __iter__(self):for node inself.iter_node():yieldnode.value#反序遍历
defiter_node_reverse(self):if self.root.prev isself.root:returncurrent_nodeself.root.prevwhile current_node.prev is notself.root:yieldcurrent_node
current_nodecurrent_node.prevyieldcurrent_nodedefappend(self, value):if self.maxsize is not None and len(self) self.maxsize:raise Exception(LinkedList is full)
nodeNode(value)
tail_node self.tail_node() orself.root
tail_node.nextnode
node.prevtail_node
node.nextself.root
self.root.prevnode
self.length 1
defappend_left(self, value):if self.maxsize is not None and len(self) self.maxsize:raise Exception(LinkedList is full)
nodeNode(value)if self.root.next isself.root:
self.root.nextnode
node.prevself.root
node.nextself.root
self.root.prevnodeelse:
node.nextself.root.next
self.root.next.prevnode
self.root.nextnode
node.prevself.root
self.length 1
defremove(self, node):if node isself.root:returnnode.next.prevnode.prev
node.prev.nextnode.next
self.length- 1
return node
循环链表的使用
dll CircularDoubleLinkedList()
dll.append(0)
dll.append(1)
dll.append(2)assert list(dll) [0, 1, 2]print(list(dll)) #[0, 1, 2]
print([node.value for node in dll.iter_node()]) #[0, 1, 2]
print([node.value for node in dll.iter_node_reverse()]) #[2, 1, 0]
headnodedll.head_node()print(headnode.value) #0
dll.remove(headnode)print(len(dll)) #2
队列
队列(Queue)是一个数据集合仅允许在列表的一端进行插入另一端进行删除。
进行插入的一端成为队尾(rear)插入动作称为进队或入队。
进行删除的一端称为队头(front)删除动作称为出队。
队列的性质先进先出(First-in, First-out)。基于数组实现环形队列
classArray(object):def __init__(self, size32)::param size: 长度self._sizesize
self._items [None] *size#在执行array[key]时执行
def __getitem__(self, index):returnself._items[index]#在执行array[key] value 时执行
def __setitem__(self, index, value):
self._items[index]value#在执行len(array) 时执行
def __len__(self):returnself._size#清空数组
def clear(self, valueNone):for i inrange(len(self._items)):
self._items[i]value#在遍历时执行
def __iter__(self):for item inself._items:yielditemclassArrayQueue(object):def __init__(self, maxsize):
self.maxsizemaxsize
self.arrayArray(maxsize)
self.head0
self.tail0def __len__(self):return self.head -self.tail#入队
defpush(self, value):if len(self) self.maxsize:raise Exception(Queue is full)
self.array[self.head% self.maxsize] value
self.head 1
#出队
defpop(self):
value self.array[self.tail %self.maxsize]
self.tail 1
return value
使用
size 5qArrayQueue(size)for i inrange(size):
q.push(i)print(len(q)) #5
print(q.pop()) #0
print(q.pop()) #1
双向队列
两端都可以进行插入删除。基于双向链表实现双向队列
classNode(object):def __init__(self, valueNone, prevNone, nextNone):
self.valuevalue
self.prevprev
self.nextnextclassCircularDoubleLinkedList(object):双向循环链表
def __init__(self, maxsizeNone):
self.maxsizemaxsize
nodeNode()
node.prevnode
node.nextnode
self.rootnode
self.length0def __len__(self):returnself.lengthdefhead_node(self):returnself.root.nextdeftail_node(self):returnself.root.prev#遍历
defiter_node(self):if self.root.next isself.root:returncurrent_nodeself.root.nextwhile current_node.next is notself.root:yieldcurrent_node
current_nodecurrent_node.nextyieldcurrent_nodedef __iter__(self):for node inself.iter_node():yieldnode.value#反序遍历
defiter_node_reverse(self):if self.root.prev isself.root:returncurrent_nodeself.root.prevwhile current_node.prev is notself.root:yieldcurrent_node
current_nodecurrent_node.prevyieldcurrent_nodedefappend(self, value):if self.maxsize is not None and len(self) self.maxsize:raise Exception(LinkedList is full)
nodeNode(value)
tail_node self.tail_node() orself.root
tail_node.nextnode
node.prevtail_node
node.nextself.root
self.root.prevnode
self.length 1
defappend_left(self, value):if self.maxsize is not None and len(self) self.maxsize:raise Exception(LinkedList is full)
nodeNode(value)if self.root.next isself.root:
self.root.nextnode
node.prevself.root
node.nextself.root
self.root.prevnodeelse:
node.nextself.root.next
self.root.next.prevnode
self.root.nextnode
node.prevself.root
self.length 1
defremove(self, node):if node isself.root:returnnode.next.prevnode.prev
node.prev.nextnode.next
self.length- 1
returnnode#双向队列
classDeque(CircularDoubleLinkedList):#从右边出队
defpop(self):if len(self) 0:raise Exception(stark is empty!)
tail_nodeself.tail_node()
valuetail_node.value
self.remove(tail_node)returnvalue#从左边出队
defpopleft(self):if len(self) 0:raise Exception(stark is empty!)
head_nodeself.head_node()
valuehead_node.value
self.remove(head_node)return value
双向队列的使用
dq Deque()
dq.append(1)
dq.append(2)print(list(dq)) #[1, 2]
dq.appendleft(0)print(list(dq)) #[0, 1, 2]
dq.pop()print(list(dq)) #[0, 1]
dq.popleft()print(list(dq)) #[1]
dq.pop()print(len(dq)) #0
栈
栈(Stack)是一个数据集合可以理解为只能在一端插入或删除操作的链表。
栈的特点后进先出(Last-in, First-out)
栈的概念
栈顶
栈底
栈的基本操作
进栈压栈push
出栈pop基于双向队列实现
classNode(object):def __init__(self, valueNone, prevNone, nextNone):
self.valuevalue
self.prevprev
self.nextnextclassCircularDoubleLinkedList(object):双向循环链表
def __init__(self, maxsizeNone):
self.maxsizemaxsize
nodeNode()
node.prevnode
node.nextnode
self.rootnode
self.length0def __len__(self):returnself.lengthdefhead_node(self):returnself.root.nextdeftail_node(self):returnself.root.prev#遍历
defiter_node(self):if self.root.next isself.root:returncurrent_nodeself.root.nextwhile current_node.next is notself.root:yieldcurrent_node
current_nodecurrent_node.nextyieldcurrent_nodedef __iter__(self):for node inself.iter_node():yieldnode.value#反序遍历
defiter_node_reverse(self):if self.root.prev isself.root:returncurrent_nodeself.root.prevwhile current_node.prev is notself.root:yieldcurrent_node
current_nodecurrent_node.prevyieldcurrent_nodedefappend(self, value):if self.maxsize is not None and len(self) self.maxsize:raise Exception(LinkedList is full)
nodeNode(value)
tail_node self.tail_node() orself.root
tail_node.nextnode
node.prevtail_node
node.nextself.root
self.root.prevnode
self.length 1
defappend_left(self, value):if self.maxsize is not None and len(self) self.maxsize:raise Exception(LinkedList is full)
nodeNode(value)if self.root.next isself.root:
self.root.nextnode
node.prevself.root
node.nextself.root
self.root.prevnodeelse:
node.nextself.root.next
self.root.next.prevnode
self.root.nextnode
node.prevself.root
self.length 1
defremove(self, node):if node isself.root:returnnode.next.prevnode.prev
node.prev.nextnode.next
self.length- 1
returnnodeclassDeque(CircularDoubleLinkedList):defpop(self):if len(self) 0:raise Exception(stark is empty!)
tail_nodeself.tail_node()
valuetail_node.value
self.remove(tail_node)returnvaluedefpopleft(self):if len(self) 0:raise Exception(stark is empty!)
head_nodeself.head_node()
valuehead_node.value
self.remove(head_node)returnvalueclassStack(object):def __init__(self):
self.dequeDeque()#压栈
defpush(self, value):
self.deque.append(value)#出栈
defpop(self):return self.deque.pop()
使用
s Stack()
s.push(0)
s.push(1)
s.push(2)print(s.pop()) #2
print(s.pop()) #1
print(s.pop()) #0
~.~
