数据结构 迷宫问题和二叉树

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]
		if curNode[0] == x2 and curNode[1] == y2 :
			for p in stack :
				print (p)
			return True

		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
				break

		else :
			maze[nextNode[0]][nextNode[1]] = 2
			stack.pop()

	else:
		print ("没有路")
		return False

maze_path(1,1,8,8)

二叉树

class Node:
    def __init__(self,name,type ="dir"):
        self.name = name
        self.type = type
        self.children = []
        self.parent = None

    def __repr__(self):
        return self.name

# n = Node("hello")
# n2 = Node("world")
# n.children.append(n2)
# n2.parent = n

class FileSystemTree:
    def __init__(self):
        self.root =Node ("/")    # /abc/bcd 类似这种文件 首个字符用/
        self.now = self.root     #现在的位置

    def mkdir(self,name):
        #name 必须是/结尾 ，不能是文件夹，要是文件
        if name[-1] != "/":
            name += "/"
        node = Node(name)
        self.now.children.append(node)
        node.parent = self.now

    def ls(self):  #当前目录所有的子目录
        return self.now.children

    def cd(self,name): #切换目录
        if name[-1] != "/":
            name += "/"
        for child in self.now.children:
            if child.name == name :
                self.now = child
                return 
        raise ValueError("invalid dir ")


tree = FileSystemTree()
tree.mkdir("var/")
print(tree.root.children)

 二叉树的遍历方式

前序

def pre_order(root):
    if root :
        print(root.data,end="")
        pre_order(root.lchild)
        pre_order(root.rchild)

#中序遍历

def in_order(root):
    if root :
        in_order(root.lchild)
        print(root.data,end="")
        in_order(root.rchild)

二叉搜索树

#查询
def query(self,node,val):
    if not node:
        return None
    if node.data < val :
        return self.query(node.rchild,val)
    elif node.data > val :
        return self.query(node.lchild,val)
    else:
        return node

def query_no_rec(self,val):
    p = self.root
    while p :
        if p.data < val:
            p = p.rchild
        elif p.data > val:
            p = p.lchild
        else:
            return p
    return False

 二叉树的删除