数据结构-栈

最新推荐文章于 2025-08-15 16:44:13 发布

转载最新推荐文章于 2025-08-15 16:44:13 发布 · 49 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/xinsiwei18/p/10322626.html

文章标签：

#数据结构与算法

本文深入解析栈数据结构的特点与基本操作，如压栈、出栈和取栈顶，并通过实例展示如何利用栈解决括号匹配问题及实现深度优先搜索解决迷宫问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

　　栈(Stack)是一个数据集合，可以理解为只能在一端进行插入或删除操作的列表

　　栈的特点：后进先出LIFO(last-in,first-out)

　　栈的概念：栈顶，栈底

　　基本操作：

进栈(压栈):push
出栈:pop
取栈顶:gettop

class Stack:
    def __init__(self):
        self.stack = []

    def push(self, element):
        self.stack.append(element)

    def pop(self):
        return self.stack.pop()

    @property
    def is_empty(self):
        return len(self.stack) == 0

    def get_top(self):
        if not self.is_empty:
            return self.stack[-1]
        return None

　　括号匹配问题：给定一个字符串，其中包括小括号，中括号，大括号，验证括号是否匹配

class Stack:
    def __init__(self):
        self.stack = []

    def push(self, element):
        self.stack.append(element)

    def pop(self):
        return self.stack.pop()

    @property
    def is_empty(self):
        return len(self.stack) == 0

    def get_top(self):
        if not self.is_empty:
            return self.stack[-1]
        return None


def brace_match(s):
    match = {')':'(',']':'[','}':'{'}

    stack = Stack()
    for ch in s:
        if ch in match.values():
            stack.push(ch)
        elif ch in match.keys():
            if stack.is_empty: #当栈为空，多了个右括号
                return False
            elif match[ch] != stack.get_top(): #右括号和栈顶不匹配
                return False
            else:
                stack.pop()
    if not stack.is_empty: #最后栈不为空，说明 有括号没匹配上
        return False
    return True

s = "[()({}[])]]"
ret = brace_match(s)
print(ret)

　　利用栈实现深度优先走迷宫

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

        # 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)

转载于:https://www.cnblogs.com/xinsiwei18/p/10322626.html