【python与数据结构】（leetcode算法预备知识）

最新推荐文章于 2024-05-01 21:37:48 发布
最新推荐文章于 2024-05-01 21:37:48 发布
阅读量1.1k 收藏 3
点赞数 1
分类专栏： Python学习 数据结构 文章标签： 算法 python 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44319595/article/details/134097973
版权

笔记为自我总结整理的学习笔记，若有错误欢迎指出哟~

python与数据结构

Python 中常见的数据类型

1.数字类型：

  • 整数（int）：表示整数值，例如 1、-5、100。
  • 浮点数（float）：表示带有小数部分的数字，例如 3.14、-0.5、2.0。
  • 复数（complex）：表示实部和虚部的复数，例如 2+3j。

2.布尔类型（bool）：

  • 表示真（True）或假（False）的逻辑值。

3.字符串类型（str）：

  • 表示文本数据，使用单引号或双引号括起来，例如 ‘Hello’、“World”。

4.列表类型（list）：

  • 表示有序的可变序列，可以包含不同类型的元素，使用方括号括起来，例如 [1, 2, ‘a’, True]。

5.元组类型（tuple）：

  • 类似于列表，但是不可变，使用圆括号括起来，例如 (1, 2, ‘a’, True)。

6.集合类型（set）：

  • 表示无序且唯一的元素集合，使用花括号括起来，例如 {1, 2, 3}。

7.字典类型（dict）：

  • 表示键值对的映射关系，使用花括号括起来，例如 {‘name’: ‘Alice’, ‘age’: 25}。

数据结构

1.数组（Array）

列表类型（list）

2.链表（Linked List）

在这里插入图片描述

class ListNode:
	def __init__(self,x):
		self.val = x
		self.next = None

3.哈希表（Hash Table）

字典类型（dict）

4.队列（Queue）

在这里插入图片描述

list

进队：append()

出队：pop(0)

l = [1,2,3,4,5]

l.append(6)
l
#[1, 2, 3, 4, 5, 6]

l.pop(0)
l
#[2, 3, 4, 5, 6]

deque(类似双端队列)

deque 是 Python 中的一个内置模块 collections 中的类，用于实现双端队列（double-ended queue）。双端队列是一种具有队列和栈特性的数据结构，支持在两端进行插入和删除操作。

deque 提供了以下常用操作：

  1. 创建双端队列：
    • 使用 deque() 函数创建一个空的双端队列。
    • 例如：from collections import deque，d = deque()。
  2. 在队列两端插入元素：
    • 使用 append(item) 在队列的右端插入一个元素。
    • 使用 appendleft(item) 在队列的左端插入一个元素。
    • 例如：d.append(1)，d.appendleft(2)。
  3. 在队列两端删除元素：
    • 使用 pop() 删除并返回队列右端的元素。
    • 使用 popleft() 删除并返回队列左端的元素。
    • 例如：d.pop()，d.popleft()。
  4. 访问队列两端的元素：
    • 使用 [-1] 索引访问队列右端的元素。
    • 使用 [0] 索引访问队列左端的元素。
    • 例如：d[-1]，d[0]。
  5. 获取队列长度：
    • 使用 len(d) 获取队列中的元素个数。
  6. 判断队列是否为空：
    • 使用 not d 或 len(d) == 0 判断队列是否为空。

deque 还支持其他一些方法，如旋转队列、计数元素出现次数、反转队列等。双端队列在实际应用中常用于需要高效地在两端进行插入和删除操作的场景，比如实现缓存、任务调度等。

右进：append()

右出：pop()

左进：appendleft()

左出：popleft()

from collections import deque
q = deque([1,2,3])

q.append(4)
q
#deque([1, 2, 3, 4])

q.pop()
q
#deque([1, 2, 3])

q.appendleft(4)
q
#deque([4, 1, 2, 3])

q.popleft()
q
#deque([1, 2, 3])

使用：先进后出

#使用方法1：队头<---   队列   <---队尾
#append()	队尾
#popleft()	队头

from collections import deque
q = deque([1,2,3])

q.append(4)
q
#deque([1, 2, 3, 4])

q.popleft()
q
#deque([2, 3, 4])

#使用方法2：队尾--->   队列   --->队头
#appendleft()	队尾
#pop()	队头

from collections import deque
q = deque([1,2,3])

q.appendleft(4)
q
#deque([4, 1, 2, 3])

q.pop()
q
#deque([4, 1, 2])

5.栈（Stack）

在这里插入图片描述

list

进栈：append()

出栈：pop()

l = [1,2,3,4,5]

l.append(6)
l
#[1, 2, 3, 4, 5, 6]

l.pop()
l
#[1, 2, 3, 4, 5]

deque

右进：append()

右出：pop()

左进：appendleft()

左出：popleft()

使用：先进先出，后进后出

6.堆（Heep）

在这里插入图片描述
heapq 是 Python 中的一个内置模块，提供了堆（heap）算法的实现。堆是一种特殊的树形数据结构，满足以下性质：

  • 堆是一棵完全二叉树；
  • 堆中的每个节点都必须大于等于（或小于等于）其子节点。

Python 中的 heapq 模块提供了以下常用函数：

  1. heapify(iterable)：
    • 将一个可迭代对象转化为堆，时间复杂度为O*(*n)。
    • 例如：heapq.heapify([3, 1, 4, 1, 5, 9])。
  2. heappush(heap, item)：
    • 将一个元素加入堆中，时间复杂度为 O(logn)。
    • 例如：heapq.heappush([3, 1, 4, 1, 5, 9], 2)。
  3. heappop(heap)：
    • 弹出堆中最小的元素，时间复杂度为 O(logn)。
    • 例如：heapq.heappop([1, 1, 3, 4, 5, 9])。
  4. heapreplace(heap, item)：
    • 弹出堆中最小的元素，并将新元素加入堆中，时间复杂度为 O*(*logn)。
    • 例如：heapq.heapreplace([1, 1, 3, 4, 5, 9], 2)。
  5. nlargest(n, iterable[, key])：
    • 返回可迭代对象中最大的 n 个元素，时间复杂度为 O*(*nlogk)，其中 k=min(n,len(iterable))。
    • 例如：heapq.nlargest(3, [1, 2, 3, 4, 5, 6, 7, 8, 9])。
  6. nsmallest(n, iterable[, key])：
    • 返回可迭代对象中最小的 n 个元素，时间复杂度为 O*(*nlogk)，其中 k=min(n,len(iterable))。
    • 例如：heapq.nsmallest(3, [9, 8, 7, 6, 5, 4, 3, 2, 1])。

heapq 模块可以用于实现堆排序、优先队列等算法，同时也可以用于解决一些常见的算法问题，如求 top-k 问题、求中位数等。在使用 heapq 模块时，需要注意元素的比较方式，可以通过传递 key 参数来指定比较函数。

from heapq import * 

a = [1,2,3,4,5]
heapify(a)
a
#[1, 2, 3, 4, 5]

heappush(a,-1)
a
#[-1, 2, 1, 4, 5, 3]

heappop(a)
a
#[1, 2, 3, 4, 5]

nlargest(3,a)
#[5, 4, 3]

nsmallest(3,a)
#[1, 2, 3]

7.树（Tree）

在这里插入图片描述

数据类型常见操作

1.数字类型

  • abs()：绝对值
  • max()/min()：最大值/最小值
  • pow(x,y)：xy
  • sqrt(x)：根号x
abs(-5)
#5

max(1,3,6)
#6

min(1,-1,4)
#-1

pow(3,3)
#27

import math
math.sqrt(9)
#3.0

2.布尔类型

bool(0)
#False

bool(2)
#True

bool(-1)
#True

3.字符串类型

  • len(s)：字符串长度，空格也算
  • max(s)：最大字符
  • max(s)：最小字符
  • s.count(‘H’)：统计H的个数
  • s.isupper()：是否为大写
  • s.islower()：是否为小写
  • s.isdigit()：是否为数字
  • s.lower()：转换为小写
  • s.upper()：转换为大写
  • s.swapcase()：大小写转换
  • s.split()：分割字符串
s="Hello world"

len(s)
#11

max(s)
#'w'

s.count("l")
#3

s.isupper()
#False

s.islower()
#False

s.isdigit()
#False

s.lower()
#'hello world'

s.upper()
#'HELLO WORLD'

s.swapcase()
#'hELLO WORLD'

s.split()
#['Hello', 'world']
  • s.strip()：去除两边字符串
  • s.lstrip()：去除左边字符串
  • s.rstrip()：去除右边字符串
  • s.replace()：交换字符串。

注意：strip()不能去除字符串中间的空格，去除中间空格用replace()

a='   hello world   '
a.strip()
#'hello world'

a.lstrip()
#'hello world   '

a.rstrip()
#'   hello world'

a.replace(' ','')
#'helloworld'

4.列表类型

a = [1,54,2,22,4]
  • 增加
    • a.append(元素)
    • a.insert(位置,元素)
a.append(25)
a
#[1, 54, 2, 22, 4, 25]

a.insert(0,2)
a
#[2, 1, 54, 2, 22, 4, 25]
  • 更新
    • a[位置]=元素
a[0]=3
a
#[3, 1, 54, 2, 22, 4, 25]
  • 删除
    • a.pop(位置) 默认最后元素
    • a.remove(元素)
a.pop()
#25

a.remove(3)
a
#[1, 54, 2, 22, 4]

  • 遍历

    • for x in a:

      ​ print(x)

    • for i in range(len(a)):

      ​ print(a[i])

    • b=[x**2 for x in a]:

      ​ print(x)

for x in a:
    print(x)
'''
1
54
2
22
4
'''

for i in range(len(a)):
    print(a[i])
'''
1
54
2
22
4
'''

b=[x**2 for x in a]
b
#[1, 2916, 4, 484, 16]
  • len(l)：列表长度
  • max(l)：最大元素，列表为同一类型
  • max(l)：最小元素，列表为同一类型
  • l.reverse()：翻转
  • l.sort(reverse = True) ：降序排序
  • in：元素是否再列表
  • 切片
  • l.clear()：清空列表
l=[1,2,3,4,5,6]
len(l)
#6

max(l)
#6

min(l)
#1

l.reverse()
l
#[6, 5, 4, 3, 2, 1]

l.sort(reverse = False) #降序
l
#[1, 2, 3, 4, 5, 6]

4 in l
#True

l[0:2]
#[1, 2]

l.clear()
l
#[]

5.元组类型

a=(1,1.5,'abc')
  • 查找
a[0]
#1

a[2]
#'abc'
  • len(a)
  • in
  • 切片
len(a)
#3

1 in a
#True

a[0:2]
#(1, 1.5)

6.集合类型

  • 增加
    • a.add()
    • a.update()
  • 删除
    • a.remove()
a={1,1.5,'abc'}
a.add(2)
a
#{1, 1.5, 2, 'abc'}

a.update({4,5})
a
#{1, 1.5, 2, 4, 5, 'abc'}

a.remove(1.5)
a
#{1, 2, 4, 5, 'abc'}
  • in
  • 集合间的操作
    • a-b：a有b没有
    • a|b：a有或b有
    • a&b：a、b都有
    • a^b：a、b不同时有
a={1,2,3}
b={3,4,5}

a-b
#{1, 2}

a|b
#{1, 2, 3, 4, 5}

a&b
#{3}

a^b
#{1, 2, 4, 5}

7.字典类型

  • 增/改
    • dict[key]=value
  • 删
    • dict.pop(key)
  • in
    • key in dict
s = {'age':18,'name':'小明'}

s['age']=19
s
#{'age': 19, 'name': '小明'}

s['city']='长沙'
s
#{'age': 19, 'name': '小明', 'city': '长沙'}

s.pop('city')
s
#{'age': 19, 'name': '小明'}

'age' in s
#True
  • 遍历
    • key
    • value
    • k,v
for key in s:
    print(key)
#age
#name

for value in s.values():
    print(value)
#19
#小明

for k,v in s.items():
    print(k,v)
#age 19
#name 小明
zz的学习笔记本
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
python 数据结构 算法 LeetCode 牛客 面试 编程之美 动态规划 字典树等等
12-27
python 数据结构 算法 LeetCode 牛客 面试 编程之美 动态规划 字典树 快速排序 树 字符串 数组 链表 全排列 堆排序 位运算 大数相加
Leetcode题解数据结构与算法.zip
12-27
大数据算法在数据分析中发挥着重要的作用，它可以提高分析工作的效率和准确性，为决策提供有力支持。具体来说，大数据算法可以分类、聚类、预测和关联规则分析等，从而发现数据之间的规律和关联关系，挖掘出潜在的价值。
python 数据结构与算法 leetcode 算法题与书籍 刷算法全靠套路与总结
12-27
python 数据结构与算法 leetcode 算法题与书籍 刷算法全靠套路与总结！Crack LeetCode, not only how, but also why.
leetcode，数据结构与算法.zip
12-27
大数据算法在数据分析中发挥着重要的作用，它可以提高分析工作的效率和准确性，为决策提供有力支持。具体来说，大数据算法可以分类、聚类、预测和关联规则分析等，从而发现数据之间的规律和关联关系，挖掘出潜在的价值。
Leetcode题解-数据结构-树（python版）
桑凯旋的博客
03-02 503
文章目录1、递归1.1 树的高度1.2 平衡树1.3 归并两棵树1.4 判断是否存在一条路径和等于一个数1.5 统计路径和等于某个数的路径总数1.6 子树1.7 判断树是否对称1.8 两节点间的最长路径1.9 翻转树1.10 最小路径1.11 统计左叶子结点的和1.12 相同节点的最大路径长度1.13 间隔层序遍历1.14 二叉树中第二小的结点2、层序遍历2.1 二叉树每层节点的平均值2.2 找树左下角的结点2.3 之字形打印二叉树3、前中后序遍历3.1 非递归实现二叉树前序遍历3.2 非递归实现二叉树中序
数据结构__栈和队列
LIUUGNAY的博客
09-29 158
知识框架 栈 概念 栈： 只允许在一端进行掺入或删除操作的线性表。 栈顶： 线性表允许进行插入和删除的那一端。 栈底： 固定的、不允许进行插入和删除的另一端。 空栈： 不含任何元素的空表。 特点：先进后出 栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：判断一个栈是否为空，若栈S为空返回true,否则返回false。 Push(&S, x)：进栈，若栈S未满，将x加入使之成为新栈顶。 Pop(&S, &x)：出栈，若栈S非空，弹出栈
LeetCode刷题 Python实现——常用内置算法和数据结构
欢迎来到我的知识星球！！！
07-07 2195
使用Python刷题经常要使用python 内置模块，一般如果内置的可以满足需求，我们优先使用内置模块， 因为在性能和容错性方面内置模块要好于我们自己实现（比如有些是 c 实现的），列举出一些常见模块供大家参考， 如果有需要最好的学习方式就是参考 Python 的官方文档。很多高级的数据结构我们也可以通过 google 搜索现成的库拿来直接用。...
数据结构与算法LeetCode刷题（Python）
xiaoxy97的博客
10-07 1745
参考资料： 1、《面试算法LeetCode刷题班》 - 小象学院 2、csujedihy / lc-all-solutions 一、链表        1.  链表的必备知识要点(包括基础知识、刷题中使用的STL等知识)      2.  链表逆序(LeetCode 92 ,206. Reverse Linked List 1,2)      3.  求两个链表的交点(LeetCod...
python 在LeetCode中常用的数据结构
weixin_30457551的博客
07-23 427
声明, 本篇的出发点不是数据结构, 而是在python中可以直接用于数据结构的对象. 1. 有序序列 1.1 不可变序列 1.1.1 str 内置的数据结构, 可以直接使用, 不需要导入 常用函数 format(*args, **kwargs) # 用法丰富多样, 算法中可用于字符串形式的进制转换 split(sep=None, maxsplit=-1) # 以sep来分割字符串 strip(...
python数据结构实现（一）：数组和链表及相关LeetCode题
Andrewings
05-11 1268
Python数据结构实现（一）一：数组1. 线性表的顺序存储结构一般特性：2. 支持动态扩容的数组功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchar...
Python数据结构+LeetCode（一）
职业转发抽奖选手的博客
03-15 1334
文章目录一、二分查找（一）二分查找的思想（二）代码二、双指针（一）双指针的思想（二）代码三、哈希表（一）哈希表的思想（二）代码四、滑动窗口算法（一）滑动窗口的思想（二）代码 一、二分查找 （一）二分查找的思想 二分查找又称折半查找 优点是比较次数少，查找速度快，平均性能好 缺点是要求待查表为有序表，且插入删除困难。 因此，折半查找方法适用于不经常变动而查找频繁的有序列表。 充分利用数组nums已经排好序的特点 我们取数组nums的中间位置(mid)的元素n_1，用n_1与目标数字x进行比较，如果
LeetCode刷题——栈（python语言）
qq_26274961的博客
02-18 760
LeetCode刷题——栈（python语言） 一、栈 1.1 定义 栈（Stack）：也称堆栈。一种线性表数据结构，是一种只允许在表的一端进行插入和删除操作的线性表。 我们把栈中允许插入和删除的一端称为[栈顶(top)];另一端则称为[栈底(bottom)]。当表中没有任何数据元素时，称之为[空栈]。 栈的特点： 线性表 后进先出 栈的存储方式有顺序栈和链式栈。 1.2 栈的基本操作 初始化空栈 判断栈是否为空 判断栈是否已满 插入元素 删除元素 获取栈顶元素 1.3 栈的顺序存储实现代码 cl
leetcode刷题用到的基本数据结构 python实现和操作
sinat_41713401的博客
01-13 115
在leetcode刷题的时候经常会用的数据结构和python实现方法
【Python】【LeetCode】数据结构（重要）
myaijarvis notebook
07-25 589
可以和列表一样切片访问。
leetcode-python刷题-数据结构篇（未完）
qq_34764167的博客
04-12 422
文章目录一、队列：先入先出的数据结构知识点补充双边队列python-deque()c++-#include题目622.设计循环队列Cpppython题目346.数据流中的移动平均值python方法一python方法二：双端队列cpp双边队列法二、队列和BFS题目286.墙与门题目200：岛屿数量python-dfs法python-bfs法题目752. 打开转盘锁BFS解题思路题目279.完全平方数...
LeetCode 第一题 (Python)
wangjikun123的博客
04-22 3919
题目内容Given an array of integers, return indices of the two numbers such that they add up to a specific target. You may assume that each input would have exactly one solution, and you may not use the sam
浅谈TopK问题（堆的应用，文件处理，堆排序）
lzh20040919的博客
04-30 467
这些排序方法就不适用了，就比如当数据到达10亿时，再使用冒泡排序，它的时间复杂度就相当恐怖了，这时我们就要用到。，如果我们按上述操作对堆顶元素进行替换，那么也只能不断更新这个最大值，我们能使用的方法有很多，就比如比较简单的冒泡排序，他的时间复杂度是。的性质来满足我们的TopK了，这时它的时间复杂度是。在文件data.txt中找出前K个最大的数据。，循环完成后小堆就剩下前K个最大的数据。堆实现思路：（前K个最大的数据）找出最大或最小的前K个数据。找最大建小堆，找最小建大堆。个数据建大小为K的小堆。
基于模糊PI控制算法的龙格库塔CSTR模型控制系统simulink建模与仿真
熟悉MATLAB/fpga/RK3588/LABVIEW/protus/单片机/dsp/Multisim
04-30 747
基于模糊PI控制算法的龙格库塔CSTR模型控制系统simulink建模与仿真。基于模糊PI控制算法的龙格-库塔（Runge-Kutta, RK）连续搅拌釜反应器（Continuous Stirred Tank Reactor, CSTR）模型控制系统，是将模糊控制理论与经典的数值积分方法相结合的一种先进控制策略。模糊控制是一种基于模糊集合理论和语言变量的控制方法，适用于非线性、时变系统的控制。
c++容器与算法概述
最新发布
北风
05-01 602
简单讲述输入输出运算符重载 以及容器的简单使用及接口哦苦
python数据结构与算法教程
05-05
3. Python 数据结构和算法的书籍：《Python 算法：从入门到实践》和《数据结构与算法 Python 语言描述》 4. Python 数据结构和算法的在线课程：https://www.udemy.com/topic/data-structures-in-python/ 5. 演示 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

zz的学习笔记本

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

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

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

打赏作者

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

抵扣说明：

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

余额充值