标签：数字 结束 assign a* pat 写入 png __init__ isp
数据结构是指相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成。简单来说，数据结构就是设计数据以何种方式组织并存贮在计算机中。比如：列表，集合与字典等都是一种数据结构。而之前已经学习过列表，字典，集合，元组等，这里就简单说一下不再赘述。
N.Wirth：“程序=数据结构+算法”
数据：数据即信息的载体，是能够输入到计算机中并且能被计算机识别，存储和处理的符号总称。
数据元素：数据元素是数据的基本单位，又称之为记录（Record），一般，数据元素若由若干基本型（或称字段，域，属性）组成。
数据结构按照其逻辑结构可分为线性结构，树结构，图结构
列表（其他语言称为数组，但是数组和Python的列表还是有区别的）是一种基本数据类型。
列表，在Python中称为list，使用中括号包含，其中内部元素使用逗号分隔，内部元素可以是任何类型包含空。
Python列表操作方法请参考此博客：https://www.cnblogs.com/wj-1314/p/8433116.html
元组，Python中类为tuple。使用小括号包含，内部元素使用逗号分隔，可为任意值。与列表不同之处为，其内部元素不可修改，而且不能做删除，更新操作。
注意：当元组中元素只有一个时，结尾要加逗号，若不加逗号，Python解释器都将解释成元素本身的类型，而非元组类型。
举个例子：
>>> a = (1,2,3) >>> b = (‘1‘,[2,3]) >>> c = (‘1‘,‘2‘,(3,4)) >>> d = () >>> e = (1,)
通过下标操作
如下，做出更改和删除会报异常：
>>> c[0] = 1 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: ‘tuple‘ object does not support item assignment >>> del c[0] Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: ‘tuple‘ object doesn‘t support item deletion
元组本身是不可变，但是可以通过 + 来构成新的元组。
>>> a (1, 2, 3) >>> b (‘1‘, [2, 3]) >>> a + b (1, 2, 3, ‘1‘, [2, 3])
可以通过使用内建函数 len 获取元组长度，可以使用 * 元素来实现元素的重复
>>> a = (1,2,3) >>> len(a) 3 >>> a*3 (1, 2, 3, 1, 2, 3, 1, 2, 3)
元组也支持 in 和 not in 成员运算符。
集合用于包含一组无序的对象，与列表和元组不同，集合是无序的，也无法通过数字进行索引。此外，集合中的元素不能重复。set和dict一样，只是没有 value，相当于 dict 的 key 集合，由于 dict 的 key 是不重复的，且 key 是不可变对象，因此 set 有如下特性：
Python的集合与数学中的集合一样，也有交集，并集和合集。
举例如下：
>>> s1 = {1,2,3,4,5}
>>> s2 = {1,2,3}
>>> s3 = {4,5}
>>> s1&s2 # 交集
{1, 2, 3}
>>> s1|s2 # 并集
{1, 2, 3, 4, 5}
>>> s1 - s2 # 差差集
{4, 5}
>>> s3.issubset(s1) # s3 是否为s1 的子集
True
>>> s1.issuperset(s2) # s1 是否为 s2 的超集
True
更多集合相关的操作参考博客：https://www.cnblogs.com/wj-1314/p/8423273.html
栈（Stack）是一个数据集合，可以理解为只能在一段进行插入或删除操作的列表。
栈的特点：后进先出 LIFO（Last-in， First-out）
栈的概念有：栈顶，栈底
栈的基本操作：
对栈的理解，就像是一摞书，只能从上面放和取。
使用一般列表结构即可实现栈：
那现在我们写一个类实现它：
class Stack:
def __init__(self):
self.stack = []
def push(self, element):
self.stack.append(element)
def pop(self):
# 移除列表中的一个元素（默认最后一个），并返回该元素的值
return self.stack.pop()
def get_top(self):
if len(self.stack) > 0:
return self.stack[-1]
else:
return None
stack = Stack()
stack.push(1)
stack.push(2)
print(stack.pop()) # 2
我们可以通过栈来解决括号匹配的问题，就是解决IDE实现括号未匹配成功报错的问题。
代码：
class Stack:
def __init__(self):
self.stack = []
def push(self,element):
return self.stack.append(element)
def pop(self):
return self.stack.pop()
def get_top(self):
if len(self.stack) > 0:
return self.stack[-1]
else:
return None
def is_empty(self):
return len(self.stack) == 0
def brace_match(s):
match = {‘}‘: ‘{‘, ‘]‘: ‘[‘, ‘)‘: ‘(‘}
stack = Stack()
for ch in s:
if ch in {‘(‘, ‘[‘, ‘{‘}:
stack.push(ch)
else:
if stack.is_empty():
return False
elif stack.get_top() == match[ch]:
stack.pop()
else:
return False
if stack.is_empty():
return True
else:
return False
print(brace_match(‘{[{()}]}‘))
队列（Queue）是一个数据集合，仅允许在列表的一端进行插入，另一端进行删除。进行插入的一端称为队尾（rear），插入动作称为进队或者入队。进行删除的一端称为对头（front），删除动作称为出队。
队列的性质：先进先出（First-in , First-out）
队列可以并发的派多个线程，对排列的线程处理，并切每个需要处理线程只需要将请求的数据放入队列容器的内存中，线程不需要等待，当排列完毕处理完数据后，线程在准时来取数据即可，请求数据的线程只与这个队列容器存在关系，处理数据的线程down掉不会影响到请求数据的线程，队列会派给其他线程处理这份数据，它实现了解耦，提高效率。队列内会有一个顺序的容器，列表与这个容器是有区别的，列表中数据虽然是排列的，但数据被取走后还会保留，而队列中这些容器的数据被取后将不会保留。当必须在多个线程之间安全的交换信息时，队列在线程编程中特别有用。
队列能否用列表简单实现？为什么？
环形队列：当队尾指针 front == MaxSize + 1 时，再前进一个位置就自动到0。
class Queue:
def __init__(self, size):
self.queue = [0 for _ in range(size)]
self.size = size
self.rear = 0 # 队尾指针是进队的
self.front = 0 # 对首指针是出队的
def push(self, element):
if not self.is_filled():
rear = (self.rear + 1) % self.size
self.queue[self.rear] = element
else:
raise IndexError("Queue is filled")
def pop(self):
if not self.is_empty():
self.front = (self.front + 1) % self.size
return self.queue[self.front]
else:
raise IndexError("Queue is empty")
# 判断队空
def is_empty(self):
return self.rear == self.front
# 判断队满
def is_filled(self):
return (self.rear + 1) % self.size == self.front
q = Queue(5)
for i in range(4):
q.push(i)
print(q.pop())
from collections import deque q = deque() q.append(1) # 队尾进队 print(q.popleft()) # 对首出队 # 用于双向队列 q.appendleft(1) # 队首进队 print(q.pop()) #队尾出队
双向队列的完整用法：
# _*_coding:utf-8_*_ # 创建双向队列 from collections import deque d = deque() # append（往右边添加一个元素） d.append(1) d.append(2) print(d) # deque([1, 2]) # appendleft（往左边添加一个元素） d.appendleft(11) d.appendleft(22) print(d) # deque([22, 11, 1, 2]) # clear清空队列 d.clear() print(d) # deque([]) # 浅copy copy d.append(1) new_d = d.copy() print(new_d) # deque([1]) # count(返回指定元素的出现次数) d.append(1) d.append(1) print(d) # deque([1, 1, 1]) print(d.count(1)) # 3 # extend(从队列右边扩展一个列表的元素) d.append(2) d.extend([3, 4, 5]) print(d) # deque([1, 1, 1, 2, 3, 4, 5]) # extendleft(从队列左边扩展一个列表的元素) d.extendleft([3, 4, 5]) print(d) # deque([5, 4, 3, 1, 1, 1, 2, 3, 4, 5]) # index（查找某个元素的索引位置） d.clear() d.extend([‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘]) print(d) print(d.index(‘e‘)) print(d.index(‘c‘, 0, 3)) # 指定查找区间 ‘‘‘ deque([‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘]) 4 2 ‘‘‘ # insert（在指定位置插入元素） d.insert(2, ‘z‘) print(d) # deque([‘a‘, ‘b‘, ‘z‘, ‘c‘, ‘d‘, ‘e‘]) # pop（获取最右边一个元素，并在队列中删除） x = d.pop() print(x) print(d) ‘‘‘ e deque([‘a‘, ‘b‘, ‘z‘, ‘c‘, ‘d‘]) ‘‘‘ # popleft（获取最左边一个元素，并在队列中删除） print(d) x = d.popleft() print(x) print(d) ‘‘‘ deque([‘a‘, ‘b‘, ‘z‘, ‘c‘, ‘d‘]) a deque([‘b‘, ‘z‘, ‘c‘, ‘d‘]) ‘‘‘ # remove（删除指定元素） print(d) d.remove(‘c‘) print(d) ‘‘‘ deque([‘b‘, ‘z‘, ‘c‘, ‘d‘]) deque([‘b‘, ‘z‘, ‘d‘]) ‘‘‘ # reverse（队列反转） print(d) d.reverse() print(d) ‘‘‘ deque([‘b‘, ‘z‘, ‘d‘]) deque([‘d‘, ‘z‘, ‘b‘]) ‘‘‘ # rotate（把右边元素放到左边） d.extend([‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘]) print(d) d.rotate(2) # 指定次数，默认1次 print(d) ‘‘‘ deque([‘d‘, ‘z‘, ‘b‘, ‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘]) deque([‘d‘, ‘e‘, ‘d‘, ‘z‘, ‘b‘, ‘a‘, ‘b‘, ‘c‘]) ‘‘‘
Queue：FIFO 即 first in first out 先进先出
LifoQueue：LIFO 即 last in first out 后进先出
PriorityQueue：优先队列，级别越低，越优先
deque：双边队列
导入三种队列，包
from queue import Queue,LifoQueue,PriorityQueue
#基本FIFO队列 先进先出 FIFO即First in First Out,先进先出 #maxsize设置队列中，数据上限，小于或等于0则不限制，容器中大于这个数则阻塞，直到队列中的数据被消掉 q = Queue(maxsize=0) #写入队列数据 q.put(0) q.put(1) q.put(2) #输出当前队列所有数据 print(q.queue) #删除队列数据，并返回该数据 q.get() #输也所有队列数据 print(q.queue) # 输出: # deque([0, 1, 2]) # deque([1, 2])
#LIFO即Last in First Out,后进先出。与栈的类似，使用也很简单,maxsize用法同上 lq = LifoQueue(maxsize=0) #队列写入数据 lq.put(0) lq.put(1) lq.put(2) #输出队列所有数据 print(lq.queue) #删除队尾数据，并返回该数据 lq.get() #输出队列所有数据 print(lq.queue) #输出: # [0, 1, 2] # [0, 1]
# 存储数据时可设置优先级的队列 # 优先级设置数越小等级越高 pq = PriorityQueue(maxsize=0) #写入队列，设置优先级 pq.put((9,‘a‘)) pq.put((7,‘c‘)) pq.put((1,‘d‘)) #输出队例全部数据 print(pq.queue) #取队例数据，可以看到，是按优先级取的。 pq.get() pq.get() print(pq.queue) #输出： [(9, ‘a‘)]
#双边队列 dq = deque([‘a‘,‘b‘]) #增加数据到队尾 dq.append(‘c‘) #增加数据到队左 dq.appendleft(‘d‘) #输出队列所有数据 print(dq) #移除队尾，并返回 print(dq.pop()) #移除队左，并返回 print(dq.popleft()) #输出: deque([‘d‘, ‘a‘, ‘b‘, ‘c‘]) c d
当我们存储一大波数据时，我们很多时候是使用数组，但是当我们执行插入操作的时候就是非常麻烦，比如，有一堆数据1,2,3,5,6,7 我们要在3和5之间插入4，如果用数组，我们会怎么办？当然是将5之后的数据往后退一位，然后再插入4，这样非常麻烦，但是如果用链表，就直接在3和5之间插入4即可。
所以链表的节点结构如下：
data为自定义的数据，next为下一个节点的地址。head保存首位节点的地址。
首先可以看一个小链表，定义链表：
class Node:
def __init__(self, item):
self.item = item
self.next = None
a = Node(1)
b = Node(2)
c = Node(3)
# 通过next 将 a,b,c联系起来
a.next = b
b.next = c
# 打印a的下一个的下一个结果是什么
print(a.next.next.item) # 3
当然，我们不可能这样next来调用链表，使用循环等，下面继续学习。
链表永远有一个头结点，head
头插法和尾插法的代码如下：
class Node:
def __init__(self, item):
self.item = item
self.next = None
# 头插法
# 这里我们使用 li 进行循环插入
def create_linklist_head(li):
head = Node(li[0])
for element in li[1:]:
node = Node(element)
node.next = head # 将头结点 给刚插入的节点
head = node # 然后将插入的节点设置为头结点
return head
# 尾插法
def create_linklist_tail(li):
head = Node(li[0])
tail = head
for element in li[1:]:
node = Node(element)
tail.next = node
tail = node
return head
def print_linklist(lk):
while lk:
print(lk.item, end=‘,‘)
lk = lk.next
print(‘*********‘)
lk = create_linklist_head([1, 2, 3, 4])
# print(lk.item) # 4
print_linklist(lk) # 4,3,2,1,*********
lk = create_linklist_tail([1, 2, 3, 4, 5])
print_linklist(lk) # 1,2,3,4,5,
插入如下，非常简单，所以时间复杂度也低。
def isEmpty(self):
return (self.length == 0)
def append(self, dataOrNode):
item = None
if isinstance(dataOrNode, Node):
item = dataOrNode
else:
item = Node(dataOrNode)
if not self.head:
self.head = item
self.length += 1
else:
node = self.head
while node._next:
node = node._next
node._next = item
self.length += 1
# 删除一个节点之后，记得把链表长度减一
def delete(self, index):
if self.isEmpty():
print("this chain table is empty")
return
if index < 0 or index >= self.length:
print(‘Error: out of index‘)
return
# 要注意删除第一个节点的情况，如果有空的头节点就不用这样
if index == 0:
self.head = self.head._next
self.length -= 1
return
# prev 为保存前导节点
# node 为保存当前节点
# 当j 与index 相等时就相当于找到要删除的节点
j = 0
node = self.head
prev = self.head
while node._next and j < index:
prev = node
node = node._next
j += 1
if j == index:
prev._next = node._next
self.length -= 1
def update(self, index, data):
if self.isEmpty() or index < 0 or index >= self.length:
print ‘error: out of index‘
return
j = 0
node = self.head
while node._next and j < index:
node = node._next
j += 1
if j == index:
node.data = data
def getItem(self, index):
if self.isEmpty() or index < 0 or index >= self.length:
print "error: out of index"
return
j = 0
node = self.head
while node._next and j < index:
node = node._next
j += 1
return node.data
def getIndex(self, data):
j = 0
if self.isEmpty():
print "this chain table is empty"
return
node = self.head
while node:
if node.data == data:
return j
node = node._next
j += 1
if j == self.length:
print "%s not found" % str(data)
return
def insert(self, index, dataOrNode):
if self.isEmpty():
print "this chain tabale is empty"
return
if index < 0 or index >= self.length:
print "error: out of index"
return
item = None
if isinstance(dataOrNode, Node):
item = dataOrNode
else:
item = Node(dataOrNode)
if index == 0:
item._next = self.head
self.head = item
self.length += 1
return
j = 0
node = self.head
prev = self.head
while node._next and j < index:
prev = node
node = node._next
j += 1
if j == index:
item._next = node
prev._next = item
self.length += 1
def clear(self):
self.head = None
self.length = 0
顺序表（列表/数组）与链表
众所周知，HashMap是一个用于存储 Key-Value键值对的集合，每一个键值对也叫Entry，这些键值对（Entry）分散存储在一个数组当中，这个数组就是HashMap的主干。
使用哈希表可以进行非常快速的查找操作，查找时间为常数，同时不需要元素排列有序；Python的内建数据类型：字典就是用哈希表实现的。
Python中的这些东西都是哈希原理：字典(dictionary)、集合(set)、计数器(counter)、默认字典Defaut dict)、有序字典(Order dict).
哈希表示一个高效的查找的数据结构，哈希表一个通过哈希函数来计算数据存储位置的数据结构，通常支持如下操作：
直接寻址技术缺点：
直接寻址表：key为k的元素放到k位置上
改进直接寻址表：哈希（Hashing）
哈希表（Hash Table，又称为散列表），是一种线性表的存储结构。哈希表由一个直接寻址表和一个哈希函数组成。哈希函数h(k)将元素关键字 k 作为自变量，返回元素的存储下标。
假设有一个长度为7的哈希表，哈希函数 h(k)=k%7.元素集合 {14, 22, 3, 5}的存储方式如下图：
代码如下：
class LinkList:
class Node:
def __init__(self, item=None):
self.item = item
self.next = None
class LinkListIterator:
def __init__(self, node):
self.node = node
def __next__(self):
if self.node:
cur_node = self.node
self.node = cur_node.next
return cur_node.item
else:
raise StopIteration
def __iter__(self):
return self
def __init__(self, iterable=None):
self.head = None
self.tail = None
if iterable:
self.extend(iterable)
def append(self, obj):
s = LinkList.Node(obj)
if not self.head:
self.head = s
self.tail = s
else:
self.tail.next = s
self.tail = s
def extend(self, iterable):
for obj in iterable:
self.append(obj)
def find(self, obj):
for n in self:
if n == obj:
return True
else:
return False
def __iter__(self):
return self.LinkListIterator(self.head)
def __repr__(self):
return "<<" + ",".join(map(str, self)) + ">>"
# 类似于集合的结构
class HashTable:
def __init__(self, size=101):
self.size = size
self.T = [LinkList() for i in range(self.size)]
def h(self, k):
return k % self.size
def insert(self, k):
i = self.h(k)
if self.find(k):
print(‘Duplicated Insert‘)
else:
self.T[i].append(k)
def find(self, k):
i = self.h(k)
return self.T[i].find(k)
字典与集合都是通过哈希表来实现的。比如：
dic_res = {‘name‘:‘james‘, ‘age‘:32, ‘gender‘: ‘Man‘}
使用哈希表存储字典，通过哈希表将字典的键映射为下标，假设 h(‘name‘)=3，h(‘age‘)=4，则哈希表存储为：
[None, 32, None, ‘james‘, ‘Man‘]
如果发生哈希冲突，则通过拉链法或开发寻址法解决。
MD5（Message-Digest Algorithm 5）曾经是密码学中常用的哈希函数，可以把任意长度的数据映射为128位的哈希值，其曾经包含如下特征：
应用举例：文件的哈希值
算出文件的哈希值，若两个文件的哈希值相同，则可认为这两个文件时相同的，因此：
历史上MD5和SHA-1曾经是使用最为广泛的 cryptographic hash function，但是随着密码学的发展，这两个哈希函数的安全性相继受到了各种挑战。
因此现在安全性较重要的场合推荐使用 SHA-A等新的更安全的哈希函数。
SHA-2包含了一系列的哈希函数：SHA-224， SHA-256， SHA-384，SHA-512，SHA-512/224，SHA-512/256，其对应的哈希值长度分别为 224， 256， 384 or 512位。
SHA-2 具有和 MD5 类似的性质。
例如在比特币系统中，所有参与者需要共同解决如下问题：对于一个给定的字符串U，给定的目标哈希值H，需要计算一个字符串V，使得 U+ V的哈希值与H的差小于一个给定值D。此时，只能通过暴力枚举V来进行猜测。首先计算出结果的人可获得一定奖金。而某人首先计算成功的概率与其拥有的计算量成正比，所以其获得的奖金的期望值与其拥有的计算量成正比。
给出一个二维列表，表示迷宫（0表示通道，1表示围墙）。给出算法，求一条走出迷宫的路径。
将其转化为数组如下：
那有两种思路，一种是使用栈（深度优先搜索）来存储当前路径，也可以称为回溯法。但是深度优先有一个缺点，就是虽然能找到路径，但是不能保证是最短路径，其优点就是简单，容易理解。
另一种方法就是队列，
回溯法
思路：从一个节点开始，任意找下一个能走的点，当炸不到能走的点时，退回上一个点寻找是否有其他方向的点。
使用栈存储当前路径
如下图所示：
代码如下：
# _*_coding:utf-8_*_
maze = [
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 1, 0, 0, 0, 1, 0, 1],
[1, 0, 0, 1, 0, 0, 0, 1, 0, 1],
[1, 0, 0, 0, 0, 1, 1, 0, 0, 1],
[1, 0, 1, 1, 1, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 1, 0, 0, 0, 0, 1],
[1, 0, 1, 0, 0, 0, 1, 0, 0, 1],
[1, 0, 1, 1, 1, 0, 1, 1, 0, 1],
[1, 1, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
]
# 这里我们封装一个列表,用来表示走迷宫的四个方向
dirs = [
lambda x, y: (x + 1, y), # 表示向上走
lambda x, y: (x - 1, y), # 表示向下走
lambda x, y: (x, y - 1), # 表示向左走
lambda x, y: (x, y + 1), # 表示向右走
]
def maze_path(x1, y1, x2, y2):
stack = []
stack.append((x1, y1))
while (len(stack) > 0):
curNode = stack[-1] # 当前节点是 stack最后一个位置
if curNode[0] == x2 and curNode[1] == y2:
return True # 如果有路则返回TRUE，没有路则返回FALSE
# x,y当前坐标，四个方向上下左右分别是：x-1,y x+1,y x, y-1 x,y+1
for dir in dirs:
nextNode = dir(curNode[0], curNode[1])
# 如果下一个节点能走
if maze[nextNode[0]][nextNode[1]] == 0:
stack.append(nextNode)
maze[nextNode[0]][nextNode[1]] = 2 # 2表示已经走过了
break
else: # 如果一个都找不到，就需要回退了
maze[nextNode[0]][nextNode[1]] = 2
stack.pop() # 栈顶出栈，也就是回退
else:
print("没有路")
return False
maze_path(1, 1, 8, 8)
思路：从下一个节点开始，寻找所有接下来能继续走的点，继续不断寻找，直到找到出口。
使用队列存储当前正在考虑的节点
思路图如下：
或者这样：
可以通过如下方式理解：
代码如下：
# _*_coding:utf-8_*_
from collections import deque
maze = [
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 1, 0, 0, 0, 1, 0, 1],
[1, 0, 0, 1, 0, 0, 0, 1, 0, 1],
[1, 0, 0, 0, 0, 1, 1, 0, 0, 1],
[1, 0, 1, 1, 1, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 1, 0, 0, 0, 0, 1],
[1, 0, 1, 0, 0, 0, 1, 0, 0, 1],
[1, 0, 1, 1, 1, 0, 1, 1, 0, 1],
[1, 1, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
]
dirs = [
lambda x, y: (x + 1, y), # 表示向上走
lambda x, y: (x - 1, y), # 表示向下走
lambda x, y: (x, y - 1), # 表示向左走
lambda x, y: (x, y + 1), # 表示向右走
]
def print_r(path):
real_path = [] # 用来存储真实的路径
i = len(path) - 1 # 用i指向path的最后一个下标
while i >= 0:
real_path.append(path[i][0:2])
i = path[i][2]
real_path.reverse()
# 起点坐标（x1, y1) 终点坐标（x2, y2）
def maze_path_queue(x1, y1, x2, y2):
queue = deque()
path = []
# -1 为当前path的路径的下标
queue.append((x1, y1, -1))
while len(queue) > 0: # 当队列不空时循环
# append是从右边加入的，popleft()从左边出去
cur_Node = queue.popleft()
path.append(cur_Node)
if cur_Node[0] == x2 and cur_Node[1] == y2:
# 如果当前节点等于终点节点，则说明到达终点
print_r(path)
return True
# 队列是找四个方向，每个能走就继续
for dir in dirs:
# 下一个方向的节点坐标
next_node = dir(cur_Node[0], cur_Node[1])
if maze[next_node[0]][next_node[1]] == 0:
queue.append((next_node[0], next_node[1], len(path) - 1))
maze[next_node[0]][next_node[1]] = 2 # 标记为已走过
return False # 如果队列结束了，空了，还没找到路径，则为FALSE
maze_path_queue(1, 1, 8, 8)
标签：数字 结束 assign a* pat 写入 png __init__ isp
原文地址：https://www.cnblogs.com/wj-1314/p/11574277.html
