数据结构编程实践20讲(Python版)—03栈

已于 2024-09-27 21:52:31 修改
阅读量840 收藏 8
点赞数 20
分类专栏： 数据结构编程实践20讲(Python版) 文章标签： python 数据结构 开发语言
于 2024-09-27 10:26:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32882309/article/details/142578785
版权

本文目录

往期链接

01 数组02 链表

03 栈 Stack

S1 说明

栈是一种线性数据结构，具有后进先出（LIFO, Last In First Out）的特点。栈的主要操作包括插入（压栈）和删除（弹栈），这些操作只能在栈的顶端进行。

基本操作

  • 压栈（Push）：将一个元素添加到栈顶。
  • 弹栈（Pop）：从栈顶移除并返回一个元素。
  • 查看栈顶元素（Peek/Top）：返回栈顶元素，但不删除它。
  • 检查栈是否为空（IsEmpty）：判断栈中是否还有元素。
  • 获取栈的大小（Size）：返回栈中元素的数量。

性质

  • 后进先出（LIFO）：最后压入栈的元素最先弹出。
  • 只能在栈顶进行操作，无法直接访问栈中间或底部的元素。

S2 示例

基于列表的实现
class Stack:
    def __init__(self):
        self.items = []  # 使用列表存储栈元素

    def push(self, item):
        """压栈操作"""
        self.items.append(item)

    def pop(self):
        """弹栈操作"""
        if not self.is_empty():
            return self.items.pop()
        raise IndexError("弹栈失败，栈为空")

    def peek(self):
        """查看栈顶元素"""
        if not self.is_empty():
            return self.items[-1]
        raise IndexError("查看栈顶元素失败，栈为空")

    def is_empty(self):
        """检查栈是否为空"""
        return len(self.items) == 0

    def size(self):
        """获取栈的大小"""
        return len(self.items)

# 使用示例
if __name__ == "__main__":
    stack = Stack()
    stack.push(1)
    stack.push(2)
    stack.push(3)

    print("栈顶元素:", stack.peek())  # 输出 3
    print("弹出元素:", stack.pop())    # 输出 3
    print("当前栈大小:", stack.size())  # 输出 2

输出

栈顶元素: 3
弹出元素: 3
当前栈大小: 2
基于链表的实现
class Node:
    """链表节点类"""
    def __init__(self, value):
        self.value = value  # 节点存储的值
        self.next = None    # 指向下一个节点的指针


class LinkedListStack:
    """基于链表的栈类"""
    def __init__(self):
        self.top = None  # 栈顶指针

    def push(self, value):
        """压栈操作"""
        new_node = Node(value)  # 创建新节点
        new_node.next = self.top  # 新节点指向当前栈顶
        self.top = new_node  # 更新栈顶为新节点

    def pop(self):
        """弹栈操作"""
        if self.is_empty():
            raise IndexError("弹栈失败，栈为空")
        popped_value = self.top.value  # 保存栈顶值
        self.top = self.top.next  # 更新栈顶为下一个节点
        return popped_value  # 返回弹出的值

    def peek(self):
        """查看栈顶元素"""
        if self.is_empty():
            raise IndexError("查看栈顶元素失败，栈为空")
        return self.top.value  # 返回栈顶值

    def is_empty(self):
        """检查栈是否为空"""
        return self.top is None  # 栈顶指针为空则栈为空

    def size(self):
        """获取栈的大小"""
        count = 0
        current = self.top
        while current:
            count += 1
            current = current.next
        return count


# 使用示例
if __name__ == "__main__":
    stack = LinkedListStack()
    stack.push(10)
    stack.push(20)
    stack.push(30)

    print("栈顶元素:", stack.peek())  # 输出 30
    print("弹出元素:", stack.pop())    # 输出 30
    print("当前栈大小:", stack.size())  # 输出 2
    print("栈是否为空:", stack.is_empty())  # 输出 False

    # 弹出剩余元素
    print("弹出元素:", stack.pop())    # 输出 20
    print("弹出元素:", stack.pop())    # 输出 10
    print("栈是否为空:", stack.is_empty())  # 输出 True

输出

栈顶元素: 30
弹出元素: 30
当前栈大小: 2
栈是否为空: False
弹出元素: 20
弹出元素: 10
栈是否为空: True

S3 问题：复杂嵌套结构的括号匹配问题

‌括号匹配问题‌是一个在算法和数据结构中常见的问题，主要目标是通过检查输入的括号序列是否平衡和闭合，以确定它们是否匹配。这个问题涉及到各种类型的括号，如圆括号、花括号和大括号。

括号匹配问题的核心在于检查输入的括号序列中的左括号和右括号是否能够正确配对，并且配对的顺序是否正确。例如，在算术表达式中，需要确保每一个左括号（如“(”或“[”）都有一个相应的右括号（如“)”或“]”）来闭合它，并且这些括号必须按照正确的顺序闭合。如果输入的括号序列无法满足这些条件，则称该序列不匹配。

要判断的括号字符串：

expressions = [
    "({[()]}{[()]})",  # 匹配
    "{([()][()])}{[()]()}",  # 匹配
    "({[()]}{[(])})",  # 不匹配
    "({[()]}([]{}))"  # 不匹配
]
求解思路
  • 使用一个栈（用Python的列表实现）来跟踪开放的括号。
  • 定义开放括号和闭合括号的集合，以及一个配对字典。
  • 遍历输入字符串中的每个字符：
    • 如果是开放括号，将其推入栈中。
    • 如果是闭合括号，检查栈是否为空（如果为空，则不平衡），然后检查栈顶元素是否与当前闭合括号匹配。如果匹配，则弹出栈顶元素；如果不匹配，则表达式不平衡。
  • 最后，如果栈为空，则表达式平衡；否则不平衡。
Python3程序
def is_balanced(expression):
    # 初始化一个空栈，用于存储开放括号
    stack = []
    # 定义开放括号的集合
    opening = "({["
    # 定义闭合括号的集合
    closing = ")}]"
    # 定义括号对应关系的字典
    pairs = {")": "(", "}": "{", "]": "["}

    # 遍历表达式中的每个字符
    for char in expression:
        # 如果是开放括号，将其压入栈中
        if char in opening:
            stack.append(char)
        # 如果是闭合括号
        elif char in closing:
            # 如果栈为空，说明闭合括号没有对应的开放括号，返回False
            if not stack:
                return False
            # 如果栈顶的开放括号与当前闭合括号匹配
            if stack[-1] == pairs[char]:
                # 弹出栈顶元素
                stack.pop()
            else:
                # 如果不匹配，返回False
                return False

    # 遍历结束后，如果栈为空，说明所有括号都匹配，返回True；否则返回False
    return len(stack) == 0


# 测试样例
expressions = [
    "({[()]}{[()]})",  # 匹配
    "{([()][()])}{[()]()}",  # 匹配
    "({[()]}{[(])})",  # 不匹配
    "({[()]}([]{}))"  # 不匹配
]

# 遍历所有测试样例
for expr in expressions:
    # 调用is_balanced函数检查是否平衡，并打印结果
    print(f"'{expr}'是{'匹配的' if is_balanced(expr) else '不匹配的'}")

输出

'({[()]}{[()]})'是匹配的
'{([()][()])}{[()]()}'是匹配的
'({[()]}{[(])})'是不匹配的
'({[()]}([]{}))'是匹配的

S4 问题：基于栈的阶乘计算VS递归实现

求解思路

使用栈实现的非递归版本。它的工作原理如下：

  • 初始化一个栈和结果变量。
  • 将初始值n压入栈中。
  • 当栈不为空时，循环处理：
    • 弹出栈顶元素。
    • 如果是0或1，直接继续（因为0!和1!都等于1）。
    • 否则，将当前值乘到结果中，并将下一个要处理的值（当前值-1）压入栈中。
  • 循环结束后，返回最终结果。
Python3程序
# 递归版本的阶乘计算
def factorial_recursive(n):
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorial_recursive(n - 1)


# 使用栈的非递归版本的阶乘计算
def factorial_iterative(n):
    # 初始化一个栈来模拟递归调用
    stack = []
    result = 1

    # 将初始值压入栈中
    stack.append(n)

    # 当栈不为空时，继续处理
    while stack:
        # 从栈顶取出当前要处理的值
        current = stack.pop()

        if current == 0 or current == 1:
            # 0!和1!的值都是1，不需要further处理
            continue
        else:
            # 将当前值乘到结果中
            result *= current
            # 将下一个要处理的值压入栈中
            stack.append(current - 1)

    return result


# 测试两个版本的阶乘函数
test_numbers = [100]

print("递归版本结果：")
for num in test_numbers:
    print(f"{num}! = {factorial_recursive(num)}")

print("\n非递归版本结果：")
for num in test_numbers:
    print(f"{num}! = {factorial_iterative(num)}")

输出

递归版本结果：
100! = 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

非递归版本结果：
100! = 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

S5 问题：逆波兰表示法(后缀表达式)求值

逆波兰表示法（Reverse Polish Notation, RPN）是一种数学表达式的表示方式，其中运算符跟在操作数后面。这种表示法的优点是可以不使用括号来明确运算的优先级，因为操作数的顺序和运算符的顺序自然决定了计算的顺序。逆波兰表示法的特点

  • 无括号：在逆波兰表示法中，运算符总是位于操作数之后，因此不需要括号来改变运算顺序。
  • 后进先出（LIFO）原则：通常使用栈来计算逆波兰表达式。操作数被压入栈中，运算符则从栈中弹出操作数进行计算。

为什么要将看似简单的中缀表达式转换为复杂的逆波兰式？原因就在于对计算机而言 中序表达式(中缀表达式，我们常用的数学表达式的表示方式，带有括号，并且有运算优先级) 是非常复杂的结构。相对的，逆波兰式在计算机看来却是比较简单易懂的结构。因为计算机普遍采用的内存结构是栈式结构，它执行先进后出的顺序。

中缀表达式：3 + (51 * 2) - 80 / (4 - 2)
后缀表达式：转换后的形式为 3 51 2 * + 80 4 2 - / -

后缀表达式的计算
从左到右开始读取后缀表达式：
(1) 读到 3，入栈。此时栈：[3]
(2) 读到 51，入栈。此时栈：[3, 51]
(3) 读到 2，入栈。此时栈：[3, 51, 2]
(4) 读到 ∗ * ∗，取出栈顶两个数字进行乘法运算：51 * 2 = 102，结果入栈。此时栈：[3, 102]
(5) 读到 + + +，取出栈顶两个数字进行加法运算：3 + 102 = 105，结果入栈。此时栈：[105]
(6) 读到 80，入栈。此时栈：[105, 80]
(7) 读到 4，入栈。此时栈：[105, 80, 4]
(8) 读到 2，入栈。此时栈：[105, 80, 4, 2]
(9) 读到 − - −，取出栈顶两个数字进行减法运算：4 - 2 = 2，结果入栈。此时栈：[105, 80, 2]
(10) 读到 / / /，取出栈顶两个数字进行除法运算：80 / 2 = 40，结果入栈。此时栈：[105, 40]
(11) 读到 − - −，取出栈顶两个数字进行减法运算：105 - 40 = 65，结果入栈。此时栈：[65]

计算结束，栈中只剩下一个数字，这就是最终结果。因此，表达式 3 51 2 * + 80 4 2 - / - 的计算结果是65。

现在计算下面中缀表达式的后缀表达并求值：
在这里插入图片描述

求解思路
  1. 使用正则表达式将输入字符串分割成 tokens。
['(', '-', '5', '+', '3', ')', '*', '2', '-', '4', '/', '(', '2', '-', '√', '(', '16', '-', '2', ')', ')', '+', '3', '^', '2']

遍历 tokens，使用栈来处理运算符和括号。

  1. 定义运算优先级，并根据运算符优先级决定何时将运算符加入输出或压入栈。
    def precedence(op):
        """定义运算符优先级"""
        if op in {'+', '-'}:
            return 1
        if op in {'*', '/'}:
            return 2
        if op == '^':
            return 3
        if op == '√':
            return 4
        return 0
  1. 将运算符号和数学计算对应起来
operators = {
        '+': lambda x, y: x + y,
        '-': lambda x, y: x - y,
        '*': lambda x, y: x * y,
        '/': lambda x, y: x / y if y != 0 else float('inf'),  # 处理除以零的情况
        '^': lambda x, y: math.pow(x, y),
        '√': lambda x: math.sqrt(x) if x >= 0 else float('nan')  # 处理负数开方的情况
    }
  1. 计算得到的后缀表达式的值
Python3程序
import re
import math

def infix_to_postfix(expression):
    def precedence(op):
        """定义运算符优先级"""
        if op in {'+', '-'}:
            return 1
        if op in {'*', '/'}:
            return 2
        if op == '^':
            return 3
        if op == '√':
            return 4
        return 0

    def is_operator(token):
        """检查token是否为运算符"""
        return token in {'+', '-', '*', '/', '^', '√'}

    output = []  # 用于存储后缀表达式
    stack = []   # 用于临时存储运算符
    # 使用正则表达式分割表达式为token
    tokens = re.findall(r'√|\d+\.?\d*|\+|\-|\*|\/|\^|\(|\)', expression)

    i = 0
    while i < len(tokens):
        token = tokens[i]
        if token.replace('.', '').isdigit():
            # 处理数字
            if i > 0 and (tokens[i-1] == ')' or tokens[i-1].replace('.', '').isdigit()):
                # 在两个数字或右括号和数字之间插入乘号（处理隐式乘法）
                while stack and precedence(stack[-1]) >= precedence('*'):
                    output.append(stack.pop())
                stack.append('*')
            output.append(token)
        elif token == '(':
            # 处理左括号
            if i > 0 and (tokens[i-1] == ')' or tokens[i-1].replace('.', '').isdigit()):
                # 在数字和左括号之间插入乘号（处理隐式乘法）
                while stack and precedence(stack[-1]) >= precedence('*'):
                    output.append(stack.pop())
                stack.append('*')
            stack.append(token)
        elif token == ')':
            # 处理右括号
            while stack and stack[-1] != '(':
                output.append(stack.pop())
            if stack and stack[-1] == '(':
                stack.pop()  # 弹出左括号
            else:
                raise ValueError("括号不匹配")
        elif is_operator(token):
            # 处理运算符
            if token == '√':
                # 处理根号
                if i + 1 < len(tokens) and tokens[i+1] == '(':
                    # 如果根号后面跟着左括号，找到匹配的右括号
                    bracket_count = 1
                    j = i + 2
                    while j < len(tokens) and bracket_count > 0:
                        if tokens[j] == '(':
                            bracket_count += 1
                        elif tokens[j] == ')':
                            bracket_count -= 1
                        j += 1
                    if bracket_count != 0:
                        raise ValueError("括号不匹配")
                    # 递归处理根号内的表达式
                    sub_expr = ''.join(tokens[i+2:j-1])
                    sub_postfix = infix_to_postfix(sub_expr)
                    output.extend(sub_postfix)
                    output.append(token)
                    i = j - 1  # 更新索引到右括号的位置
                else:
                    # 如果根号后面不是左括号，按普通运算符处理
                    while stack and precedence(stack[-1]) >= precedence(token):
                        output.append(stack.pop())
                    stack.append(token)
            else:
                # 处理一元减号
                if token == '-' and (i == 0 or tokens[i-1] == '(' or is_operator(tokens[i-1])):
                    output.append('0')
                while stack and precedence(stack[-1]) >= precedence(token):
                    output.append(stack.pop())
                stack.append(token)
        i += 1

    # 将栈中剩余的运算符添加到输出
    while stack:
        if stack[-1] == '(':
            raise ValueError("括号不匹配")
        output.append(stack.pop())

    return output

def evaluate_rpn(tokens):
    """计算后缀表达式的值"""
    stack = []
    operators = {
        '+': lambda x, y: x + y,
        '-': lambda x, y: x - y,
        '*': lambda x, y: x * y,
        '/': lambda x, y: x / y if y != 0 else float('inf'),  # 处理除以零的情况
        '^': lambda x, y: math.pow(x, y),
        '√': lambda x: math.sqrt(x) if x >= 0 else float('nan')  # 处理负数开方的情况
    }

    for token in tokens:
        if token in operators:
            if token == '√':
                # 处理一元运算符（开方）
                if not stack:
                    raise ValueError("无效的表达式：√ 缺少操作数")
                a = stack.pop()
                result = operators[token](a)
            else:
                # 处理二元运算符
                if len(stack) < 2:
                    raise ValueError(f"无效的表达式：{token} 缺少操作数")
                b = stack.pop()
                a = stack.pop()
                result = operators[token](a, b)
            stack.append(result)
        else:
            # 将数字转换为浮点数并压入栈
            try:
                stack.append(float(token))
            except ValueError:
                raise ValueError(f"无效的token: {token}")

    # 确保最后栈中只剩一个数（结果）
    if len(stack) != 1:
        raise ValueError("无效的表达式")
    return stack[0]

def calculate(expression):
    """主计算函数，处理异常并返回结果"""
    try:
        postfix = infix_to_postfix(expression)
        result = evaluate_rpn(postfix)
        return result
    except Exception as e:
        return f"错误: {str(e)}"


if __name__ == '__main__':
    # 测试
    expressions = '(-5 + 3) * 2 - 4 / (2 - √(16-2)) + 3^2'
    postfix = infix_to_postfix(expressions)
    result = evaluate_rpn(postfix)
    print(f"中缀表达式: {expressions}")
    print(f"后缀表达式: {' '.join(postfix)}")
    print(f"计算结果: {result}")

结果

中缀表达式: (-5 + 3) * 2 - 4 / (2 - √(16-2)) + 3^2
后缀表达式: 0 5 - 3 + 2 * 4 2 16 2 - √ - / - 3 2 ^ +
计算结果: 7.296662954709577
AnFany
关注
专栏目录
python数据结构与算法 pdf_数据结构与算法：Python语言描述.pdf
weixin_39570777的博客
11-23 3668
本书基于Python语言介绍了数据结构与算法的基本知识，主要内容包括抽象数据类型和Python面向对象程序设计、线性表、字符串、栈和队列、二叉树和树、集合、排序以及算法的基本知识。本书延续问题求解的思路，从解决问题的目标来组织教学内容，注重理论与实践的并用。更多关于数据结构与算法的资源请访问：更多相关资源：出版者的话专家指导委员会译者序前言第1章引论第2章算法分析第3章表、栈和队列第4章树第5章散...
这是mooc平台上数据结构与算法（Python版）课后编程题记录.zip
01-03
数据结构与算法是计算机科学中的核心课程，Python作为一种高级编程语言，因其简洁易读的语法特性，被广泛用于教学和实践。在这个“数据结构与算法（Python版）”的课程中，学生会接触到一系列关于如何高效存储和处理...
头歌实践平台（python数据结构）(1-6)
2401_84204034的博客
04-19 1674
任务描述本关任务：编写代码实现栈的基本操作。相关知识为了完成本关任务，你需要掌握：栈抽象数据类型；Python 中 List 的操作方法。栈抽象数据类型抽象数据类型“栈”是一个有次序的数据集。 在栈中，数据项的加入和移除都仅发生在同一端，这一端被称为栈顶，相对地，把另一端称为栈底。距离栈底越近的数据项， 留在栈中的时间就越长，而最新加入栈的数据项会被最先移除。这种次序通常称为“后进先出”（ LIFO ）：Last in First out。下图是一个栈的抽象模型：图1 栈模型抽象数据类型“栈”定义为如下的操
数据结构python吕云翔_数据结构(PYTHON版)/吕云翔
weixin_32431435的博客
01-14 1407
章绪论 1.1引言 1.1.1学习目的 1.1.2课程内容 1.2基本概念 1.2.1数据与数据结构 1.2.2数据类型与抽象数据类型 1.3算法 1.3.1算法的概念 1.3.2算法描述 1.3.3算法分析 小结 习题1 第2章线性表 2.1线性表及其基本操作 2.1.1线性表的基本概念 2.1.2抽象数据类型描述 2.1.3线性表的存储和实现 2.2线性表的顺序存储 2.2.1顺序表 2.2....
Python实现数据结构的基础操作
华数云图小分队的博客
06-24 1273
数据结构是计算机科学中非常重要的概念，它用于存储和组织数据以便有效地进行操作。Python作为一种功能强大且易于学习的编程语言，提供了许多内置的数据结构和相关操作。在本篇博客中，我们将介绍Python中常用的数据结构（如列表、字典、集合等）以及它们的基础操作方法，帮助读者理解和应用这些基本的数据结构。
从零开始学习数据结构与算法：Python实现
一键难忘的博客
03-17 3228
数据结构与算法是计算机科学中至关重要的概念之一，对于任何想要成为优秀程序员的人来说，深入理解它们是必不可少的。本文将介绍如何从零开始学习数据结构与算法，并使用Python语言实现一些基本的数据结构和算法，帮助读者入门。
【久远讲算法】栈——后进先出的数据结构
nruuu的博客
11-07 2478
你好我是久远，我们先来复习一下上周我们讲的知识。 什么是链表？ 在计算机科学中，链表是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针。 链表的优点 由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比数组快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而顺序表相应的时间复杂度分别是O(logn)和O(1)。使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活
探索Python数据结构与算法：解锁编程的无限可能
忆~遂愿的博客
01-17 3094
Python是一种简洁而强大的编程语言，它提供了广泛的数据结构和算法库，为开发者们解锁编程的无限可能。本文探索了Python中常用的数据结构和算法，旨在帮助读者深入理解并灵活运用这些工具。首先，我们介绍了Python内置的基本数据结构，如列表、元组、集合和字典，并讨论了它们的特点和适用场景。然后，我们深入研究了常见的高级数据结构，如堆、栈、队列和链表，以及它们的实现原理和应用领域。接下来，我们重点关注了Python的算法库，包括排序算法、搜索算法和图算法等。
Python 数据结构与算法
2401_84204413的博客
04-22 1087
Python 是一种强大且灵活的编程语言，非常适合用于实现各种数据结构和算法。数据结构和算法是计算机科学中的基础概念，对于解决实际问题、优化程序性能以及提高代码的可读性和可维护性至关重要。### 数据结构数据结构是计算机存储、组织和管理数据的方式。以下是一些在 Python 中常见的数据结构：1. **列表 (List)**: 有序的元素集合，允许重复。 2. **元组 (Tuple)**: 不可变的有序元素集合，允许重复。 3. **字典 (Dictionary)**: 无序的键值对集合，键唯一。 4.
深入探索数据结构技术：理论、实践与应用
热门推荐
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
04-16 3万+
数据结构技术的学习是一个逐步深入的过程，需要理论与实践相结合，不断通过编程练习巩固所学知识。只有扎实掌握数据结构，才能在面对复杂数据处理问题时游刃有余，为软件开发、数据分析、算法设计等领域的专业发展打下坚实基础。希望通过本文的引导，读者能够系统地学习并掌握数据结构技术，不断提升自身的编程素养与问题解决能力。
数据结构与算法：通往编程高地的必修课
m0_64336780的博客
08-23 8205
计算机科学的奥秘，就藏在那些看似晦涩的代码和算法背后。你是否曾因数据结构与算法而感到困惑？是否觉得它们彼此纠缠，难以分辨？别担心，今天我们将为你揭开这个谜团，深入探讨它们之间的联系与共生。
数据结构与算法(Python版)《数据结构课程设计》教学大纲.pdf
07-09
数据结构与算法是计算机科学与技术专业的重要课程，Python版的数据结构课程设计旨在深化学生对这一领域的理解和应用能力。这门课程以60个学时，4个学分的形式进行，要求学生具备基础的数据结构知识，如链表、树、图...
Python数据结构课件.rar
12-20
Python数据结构是编程基础的重要组成部分，它涉及到如何有效地组织和管理数据，以便高效地执行各种操作。本课件集合了关于Python数据结构的详细讲解，是期末考试复习的理想资源，同时也适合希望深入理解数据存储和...
数据结构与算法Python版学习笔记一
12-21
在学习数据结构与算法的过程中，Python作为一种流行的编程语言，被广泛用于实现各种算法。这篇学习笔记主要关注在Python中处理输入输出（I/O）时的一些关键点，这对于在在线判题平台（Online Judge，简称OJ）上测试...
零基础征服数据结构算法Python版2023
04-14
《零基础征服数据结构算法Python版》课程以985院校为授课标准，结合大厂面试所需技能，课程具有严谨、知识面广、通俗易懂、理论与实践相结合的特点，能够帮助学员在轻松的学习过程中征服数据结构与算法。 不管你是...
简单题101. 对称二叉树 （python）20240922
Sep21m_wyy的博客
09-22 368
【代码】简单题101. 对称二叉树 （python）20240922。
【工具】Windows｜两款开源桌面窗口管理小工具Deskpins和WindowTop
qq_46106285的博客
09-21 916
写这篇的初衷是怕自己忘了这两个工具的名字。
python 将 aac 转为 mp3，保持原有目录结构
最新发布
nongcunqq的博客
09-23 421
2f。
Python 类class的用法详解
十七次方
09-22 786
在 Python 中，使用 class 关键字来定义一个类。类定义通常包括类变量、实例变量和方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

AnFany

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值