Python基础学习笔记 —— 数据结构与算法_数据结构与算法python笔记

最新推荐文章于 2024-09-27 10:11:28 发布
最新推荐文章于 2024-09-27 10:11:28 发布
阅读量809 收藏 14
点赞数 11
文章标签： python 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_87368642/article/details/142430678
版权

sort(key=None,reverse=False)默认升序，修改reverse=True则为降序

arr.sort()

arr.sort(reverse=True)

清空

对数组进行清空，输出[]

arr.clear()

截取

按步长截取，顾头不顾尾

数组名[起始索引（不写则默认包含数组开始的所有元素），终止索引（不写则默认包含到数组结束的所有元素），步长（默认为1）]

print(arr[::2]) # [1, 3, 5]

print(arr[::-1]) # [1, 5, 4, 3, 2, 1]

print(arr[:-1]) # [1, 2, 3, 4, 5]


### 1.2 链表


  

**1. 链表的基本结构**


链表主要包括单向链表和双向链表，这是一种无须在内存中顺序存储即可保持数据之间逻辑关系的数据结构。


链表是由一个个结点（Node）连接而成的，每个结点都是包含数据域（Data）和指针域（Next）的基本单元。其基本元素如下：


* 链表结点：每个结点分为两部分，即数据域和指针域
	+ 数据域：数据域内一般存储的是整型、浮点型等数字类型
	+ 指针域：指针域内一般存储的是下一个结点所在的内存空间地址
* 头结点：指向链表的第一个结点
* 尾结点：指向链表的最后一个结点
* None：链表的最后一个结点的指针域，为空


单链表


单链表的每个结点的指针域只指向下一个结点，整个链表是无环的


![在这里插入图片描述](https://img-blog.csdnimg.cn/f1150625bdfb4a38b256a81a5f050daf.png)


双向链表


![在这里插入图片描述](https://img-blog.csdnimg.cn/e79865be4b5a46b5af7dd6c0bbad2bd1.png)


单向循环链表


![在这里插入图片描述](https://img-blog.csdnimg.cn/3fac32af1c44423cbb3c027f1ead18c2.png)


相比于数组，在链表中执行插入、删除等操作可以使得操作效率大大提高。


以单链表为例，在数组内如想要删除或者插入元素到某一位置，该位置之后的所有元素都需要象前或者向后移动，这样一来，时间复杂度就与数组的长度有关，为O(n)；但是在单链表中，仅仅需要通过改变所要删除或者插入位置前后结点的指针域即可，时间复杂度为O(1)。


**2. 单链表的实现与基本操作**

链表结点

class Node(object):
def __init__(self, item):
self.item = item
self.next = None

单链表

class SingleLink(object):
# 选择该初始化方法，调用时使用 SingleLink(node)
def __init__(self, node=None):
self.head = node

# 选择该初始化方法，调用时就不能使用上面的 SingleLink(node)，初始化只能通过append添加结点
# def \_\_init\_\_(self):
# self.head = None

# 判断单链表是否为空
def is\_empty(self):
    if self.head is None:
        return True
    else:
        return False

# 获取链表长度
def length(self):
    cur = self.head
    count = 0
    while cur is not None:
        cur = cur.next
        count += 1
    return count

# 遍历链表
def travel(self):
    cur = self.head
    while cur is not None:
        print(cur.item, end=" ")
        cur = cur.next

# 链表头部增加结点
def add(self, item):
    node = Node(item)
    node.next = self.head
    self.head = node

# 链表尾部增加结点
"""

注意：如果链表为空链表，cur是没有next的，只需self.head=node
“”"

def append(self, item):
    node = Node(item)
    if self.is_empty():
        self.head = node
    else:
        cur = self.head
        while cur.next is not None:
            cur = cur.next
        cur.next = node

# 链表指定位置增加结点
"""

注意：这个只适用于链表中不存在重复元素的，要区别LeetCode203. 移除链表元素（这个题链表里会存在重复元素）
“”"
def insert(self, pos, item):
if pos == 0:
self.add(item)
elif pos >= self.length():
self.append(item)
else:
node = Node(item)
cur = self.head
count = 0
while count < pos - 1:
cur = cur.next
count += 1
node.next = cur.next
cur.next = node

# 删除结点
def remove(self, item):
    cur = self.head
    pre = None
    while cur is not None:
        # 找到了要删除的元素
        if cur.item == item:
            # 如果要删除的位置在头部
            if cur == self.head:
                self.head = cur.next
            # 要删除的位置不在头部
            else:
                pre.next = cur.next
            return  # 删除元素后及时退出循环
        # 没有找到要删除的元素
        else:
            pre = cur
            cur = cur.next

# 查找结点
def search(self, item):
    cur = self.head
    while cur is not None:
        if cur.item == item:
            return True
        cur = cur.next
    return False


### 1.3 队列


  

**1. 队列的基本结构**


队列最基本的特点就是先进先出，在队列尾部加入新元素，在队列头部删除元素，分为双端队列和一般的单端队列。



> 
> 队列的作用：对于任务处理类的系统，即先把用户发起的任务请求接收过来存到队列中，然后后端开启多个应用程序从队列中取任务进行处理，队列起到了 **缓冲压力** 的作用
> 
> 
> 


**2. 队列的实现与基本操作**


利用列表来简单地模拟队列

class Queue(object):
def __init__(self):
self.items = []

# 入队
def enqueue(self, item):
    self.items.append(item)

# 出队
def dequeue(self):
    self.items.pop(0)

# 队列的大小
def size(self):
    return len(self.items)

# 判断队列是否为空
def is\_empty(self):
    return self.items == []


对于队列这种数据结构，Python的 queue 类模块中提供了一种先进先出的队列模型 Queue，可以限制队列的长度也可以不限制，在创建队列时利用 `Queue(maxsize=0)`，maxsize小于等于0表示不限制，否则表示限制。


我们在编程的过程中也可以通过调用现有类来实现队列

from queue import Queue

队列的定义

q = Queue(maxsize=0)

put() 在队列尾部添加元素

q.put(1)
q.put(2)

print(q) # <queue.Queue object at 0x0000020095EE82B0>

print(q.queue) # deque([1, 2])

get() 在队列头部取出元素，返回队列头部元素

q.get()
print(q.queue) # deque([2])

empty() 判断队列是否为空

print(q.empty()) # False

full(0 判断队列是否达到最大长度限制

print(q.full()) # False

qsize() 队列当前的长度

print(q.qsize()) # 1


**3. 双端队列的实现与基本操作**


双端队列（deque，全名double-ended queue ）， 是一种具有队列和栈的性质的数据结构  
 双端队列中的元素可以从两端弹出，其限定插入和删除操作在表的两端进行。双端队列可以在队列任意一端入队和出队。

class deque(object):
def __init__(self):
self.items = []

# 判断是否为空
def is\_empty(self):
    return self.items == []

# 队列的大小
def size(self):
    return len(self.items)

# 头部添加数据
def add\_front(self, item):
    self.items.insert(0, item)

# 尾部添加数据
def add\_rear(self, item):
    self.items.append(item)

# 头部删除数据
def remove\_front(self):
    self.items.pop(0)

# 尾部删除数据
def remove(self):
    self.items.pop()


### 1.4 栈


  

**1. 栈的基本结构**


栈最突出的特点是先进后出，其插入、删除操作均在栈顶进行。栈一般包括入栈、出栈操作，并且有一个顶指针（top）用于指示栈顶的位置


**2. 栈的实现与基本操作**

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

# 进栈
def push(self, item):
    self.items.append(item)

# 出栈
def pop(self):
    self.items.pop()

# 遍历
def travel(self):
    for i in self.items:
        print(i)

# 栈的大小
def size(self):
    return len(self.items)

# 栈是否为空
def is\_empty(self):
    return self.items == []
    # return len(self.items) == 0

# 返回栈顶元素
def peek(self):
	if self.is_empty():
		return "栈空"
    return self.items[self.size()-1]
    # return self.items[-1]


### 1.5 堆


  

Python 中 `heapq` 模块是 **小顶堆**


实现 **大顶堆** 方法： 小顶堆的插入和弹出操作均将元素 **取反** 即可

from heapq import *
from random import shuffle

data = list(range(10))
shuffle(data)
print(f’原始数据为:{data}‘)
small_heap = []
for num in data:
heappush(small_heap, num)
print(f’创建的小顶堆为:{small_heap}’)

heap = []
for num in data:
heappush(heap, -num)
print(heap)
big_heap = [-heappop(heap) for _ in range(len(heap))]
print(f’输出的大顶堆为:{big_heap}')

总体思路：负负得正


[参考]( )


### 1.6 二叉树


  

**1. 树**


树是一种数据结构，它是由 n 个有限结点组成的一个具有层次关系的集合。


树的基本性质如下：


![在这里插入图片描述](https://img-blog.csdnimg.cn/f41e51f8c29c469bac4013452b8eda6c.png)


**2. 二叉树的基本结构**


二叉树则是每个结点最多有两个子树的树结构，通常子树被称作“左子树”和“右子树”。


二叉树的一般性质：


* 二叉树是有序的（左右子树不能颠倒）
* 二叉树的第 k 层上的结点数目最多为  
 
 
 
 
 
 2 
 
 
 
 k 
 
 
 − 
 
 
 1 
 
 
 
 
 
 2^{k-1} 
 
 
 2k−1
* 深度为 h 的二叉树最多有  
 
 
 
 
 
 2 
 
 
 h 
 
 
 
 − 
 
 
 1 
 
 
 
 2^h-1 
 
 
 2h−1 个结点
* 设非空二叉树中度为0、1 和 2 的结点个数分别为 
 
 
 
 
 
 n 
 
 
 0 
 
 
 
 
 n\_0 
 
 
 n0​ 、 
 
 
 
 
 
 n 
 
 
 1 
 
 
 
 
 n\_1 
 
 
 n1​ 和  
 
 
 
 
 
 n 
 
 
 2 
 
 
 
 
 n\_2 
 
 
 n2​，则  
 
 
 
 
 
 n 
 
 
 0 
 
 
 
 = 
 
 
 
 n 
 
 
 2 
 
 
 
 + 
 
 
 1 
 
 
 
 n\_0 = n\_2+1 
 
 
 n0​=n2​+1（叶子结点比二分支结点多一个）



> 
> **注意：这里的层数 k ，深度 h 均是从 1 开始的**
> 
> 
> 


其他常见的二叉树：


![在这里插入图片描述](https://img-blog.csdnimg.cn/222b1bea030443cbb8f578a08339a1fd.png)



> 
> 注意：
> 
> 
> * 如果按层序从0开始编号，结点 i 的左孩子为：2i+1，结点 i 的右孩子为：2i+2，结点 i 的父结点为：(i-1)//2
> * 如果结点按层序从0开始编号，假设共有 n 个结点，若 i <= n//2-1 ，该结点为非终端结点，若 i > n//2-1 ，该结点为终端结点
> 
> 
> 


![在这里插入图片描述](https://img-blog.csdnimg.cn/d417a57a3d354c13951a9adc9bbd176c.png)



> 
> 二叉树通常以链式存储
> 
> 
> 


**3. 二叉树的实现与基本操作**

定义结点类

class Node(object):
def __init__(self, item):
self.item = item
self.lchild = None
self.rchild = None

定义二叉树

class BinaryTree(object):
def __init__(self, node=None):
self.root = node

"""

思路分析：首先在队列中插入根结点，取出该结点，再判断该结点的左右子树是否为空，
左子结点不空，将其入队，右子结点不空，将其入队，
再分别判断左右结点的左右子结点是否为空，
循环往复，直到发现某个子结点为空，即把新结点添加进来
“”"

# 添加结点
def add(self, item):
    node = Node(item)
    # 二叉树为空
    if self.root is None:
        self.root = node
        return

    # 二叉树不空
    queue = []
    queue.append(self.root)
    # 编译环境会提示，也可以直接写成：queue = [self.root]

    while True:
        # 从队头取出数据
        node1 = queue.pop(0)
        # 判断左结点是否为空
        if node1.lchild is None:
            node1.lchild = node
            return
        else:
            queue.append(node1.lchild)
        # 判断右结点是否为空
        if node1.rchild is None:
            node1.rchild = node
            return
        else:
            queue.append(node1.rchild)

# 广度优先遍历，也叫层次遍历
def breadth(self):
    if self.root is None:
        return

    queue = []
    queue.append(self.root)
    while len(queue) > 0:
        # 取出数据
        node = queue.pop(0)
        print(node.item, end=" ")

        # 判断左右子结点是否为空
        if node.lchild is not None:
            queue.append(node.lchild)
        if node.rchild is not None:
            queue.append(node.rchild)

# 深度优先遍历
# 先序遍历（根左右）
def preorder\_travel(self, root):
    if root is not None:
        print(root.item, end=" ")
        self.preorder_travel(root.lchild)
        self.preorder_travel(root.rchild)

# 中序遍历（左根右）
def inorder\_travel(self, root):
    if root is not None:
        self.inorder_travel(root.lchild)
        print(root.item, end=" ")
        self.inorder_travel(root.rchild)

# 后序遍历（左右根）
def postorder\_travel(self, root):
    if root is not None:
        self.postorder_travel(root.lchild)
        self.postorder_travel(root.rchild)
        print(root.item, end=" ")

if name == “__main__”:
tree = BinaryTree()
tree.add(1)
tree.add(2)
tree.add(3)
tree.add(4)

# 添加结点的代码逻辑就是将添加第一个结点设置为根结点
print(tree.root)
print()

# 层序遍历
tree.breadth()  # 1 2 3 4
print()
# 前序遍历（根左右）
tree.preorder_travel(tree.root)  # 1 2 4 3
print()

# # 中序遍历（左根右）
tree.inorder_travel(tree.root)  # 4 2 1 3
print()

# # 后序遍历（左右根）
tree.postorder_travel(tree.root)  # 4 2 3 1



> 
> 注意：
> 
> 
> * 广度优先遍历基于队列
> * 深度优先遍历基于栈
> 
> 
> 


**试试 LeetCode 相关题目吧**


* [102. 二叉树的层序遍历]( )
* [107. 二叉树的层序遍历 II]( )
* [144.二叉树的前序遍历]( )
* [94. 二叉树的中序遍历]( )
* [145. 二叉树的后序遍历]( )
* [589. N 叉树的前序遍历]( )
* [590. N 叉树的后序遍历]( )
* [429. N 叉树的层序遍历]( )



> 
> 注意：二叉树遍历相关的题目在LeetCode环境中，省略了添加结点的代码逻辑，以及定义二叉树类中的初始化，要注意区分、根据具体题目应变。另外，其输入输出都是列表的形式，要注意
> 
> 
> 


**4. 由遍历结果反推二叉树结构**


![在这里插入图片描述](https://img-blog.csdnimg.cn/6ace3ef1371f4a7684f145b85f4ca91d.png)


## 2 排序算法


  

**算法的稳定性**：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变则称这种排序算法是稳定的，否则称为不稳定的


* 不稳定的排序算法：选择排序、快速排序、希尔排序、堆排序
* 稳定的排序算法：冒泡排序、插入排序、归并排序、基数排序


### 2.1 冒泡排序


  

对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，依次对所有的数据进行操作，直至所有数据按要求完成排序


如果有n个数据进行排序，总共需要比较 n-1 次


每一次比较完毕，下一次的比较就会少一个数据参与


![在这里插入图片描述](https://img-blog.csdnimg.cn/1d7883ac5e544ee7b51a0228e65f194a.png)

def bubble_sort(lis):
n = len(lis)
# 控制比较的轮数
for j in range(n - 1):
count = 0
# 控制每一轮的比较次数
# -1是为了让数组不要越界
# -j是每一轮结束之后, 我们就会少比一个数字
for i in range(n - 1 - j):
if lis[i] > lis[i + 1]:
lis[i], lis[i + 1] = lis[i + 1], lis[i]
count += 1
# 算法优化
# 如果遍历一遍发现没有数字交换，退出循环，说明数列是有序的
if count == 0:
break

if name == “__main__”:
lis = [2, 7, 3, 6, 9, 4]
bubble_sort(lis)
print(lis)



> 
> 总结：
> 
> 
> * 冒泡排序是稳定的
> * 最坏时间复杂度为 
>  
>  
>  
>  
>  O 
>  
>  
>  ( 
>  
>  
>  
>  n 
>  
>  
>  2 
>  
>  
>  
>  ) 
>  
>  
>  
>  O(n^2) 
>  
>  
>  O(n2)
> * 最优时间复杂度为 
>  
>  
>  
>  
>  O 
>  
>  
>  ( 
>  
>  
>  n 
>  
>  
>  ) 
>  
>  
>  
>  O(n) 
>  
>  
>  O(n)，遍历一遍发现没有任何元素发生了位置交换终止排序
> 
> 
> 


### 2.2 快速排序


  

快速排序算法中，每一次递归时以第一个数为基准数 ，找到数组中所有比基准数小的。再找到所有比基准数大的。小的全部放左边，大的全部放右边，确定基准数的正确位置。

def quick_sort(lis, left, right):
# 递归的结束条件：left > right
if left > right:
return

# 存储临时变量，left0始终为0，right0始终为len(lis)-1
left0 = left
right0 = right

# 基准值
base = lis[left0]

# left != right
while left != right:
    # 从右边开始找寻小于base的值
    while lis[right] >= base and left < right:
        right -= 1

    # 从左边开始找寻大于base的值
    while lis[left] <= base and left < right:
        left += 1

    # 交换两个数的值
    lis[left], lis[right] = lis[right], lis[left]

# left=right
# 基准数归位
lis[left0], lis[left] = lis[left], lis[left0]

# 递归操作
quick_sort(lis, left0, left - 1)
quick_sort(lis, left + 1, right0)  # quick\_sort(lis, left + 1, right0)

if name == ‘__main__’:
lis = [1, 2, 100, 50, 1000, 0, 10, 1]
quick_sort(lis, 0, len(lis) - 1)
print(lis)



> 
> 总结：
> 
> 
> * 快速排序算法不稳定
> * 最好的时间复杂度： 
>  
>  
>  
>  
>  O 
>  
>  
>  ( 
>  
>  
>  n 
>  
>  
>  l 
>  
>  
>  o 
>  
>  
>  
>  g 
>  
>  
>  2 
>  
>  
>  
>  n 
>  
>  
>  ) 
>  
>  
>  
>  O(nlog\_2n) 
>  
>  
>  O(nlog2​n)，初始序列大小均匀，每一次选择的基准值将待排序的序列划分为均匀的两部分，递归深度最小，算法效率最高
> * 最坏的时间复杂度： 
>  
>  
>  
>  
>  O 
>  
>  
>  ( 
>  
>  
>  
>  n 
>  
>  
>  2 
>  
>  
>  
>  ) 
>  
>  
>  
>  O(n^2) 
>  
>  
>  O(n2)，初始序列有序或逆序，每次选择的基准值都是靠边的元素，递归深度最大，算法效率最低
> 
> 
> 


### 2.3 （简单）选择排序


  

第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾，以此类推，直到全部待排序的数据元素的个数为零。


![在这里插入图片描述](https://img-blog.csdnimg.cn/53611e8afe094dedbb39f0dc9afb3852.png)

def select_sort(lis):
n = len(lis)
# 控制比较的轮数
for j in range(n - 1):
# 假定最小值的下标
min_index = j
# 控制每一轮的比较次数
for i in range(j + 1, n):
# 进行比较获得最小值下标
if lis[min_index] > lis[i]:
min_index = i
# 如果假定的最小值下标发生了变化，那么就进行交换
if min_index != j:
lis[min_index], lis[j] = lis[j], lis[min_index]

if name == “__main__”:
lis = [2, 7, 3, 6, 9, 4]
select_sort(lis)
print(lis)



> 
> 总结：
> 
> 
> * 选择排序是不稳定的
> * 最坏时间复杂度为O(n^2)
> * 最优时间复杂度为O(n^2)
> 
> 
> 


### 2.4 堆排序


  

堆排序是指利用堆（必须是一种完全二叉树）这种数据结构所设计的一种排序算法


其核心思想是：


* 建立（大或小）根堆：
	+ 从最后一个非终端结点开始，把所有的非终端结点都检查一遍，是否满足（大或小）根堆的要求，如不满足，则与更（大或小）的结点进行交换，元素互换可能会破坏下一层的堆，需要采用相同的方法进行调整，得到（大或小）根堆。
* 排序：
	+ 每一趟排序将堆顶元素加入有序子序列（堆顶元素与待排序序列中最后一个元素交换），并将待排序元素序列再次调整为（大或小）根堆


堆排序有以下两种：


* 大根堆：每个结点的值都大于等于其左右孩子结点的值，满足`arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]`，基于**大根堆的堆排序得到递增序列**
* 小根堆：每个结点的值都小于等于其左右孩子结点的值，满足`arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2]`，基于**小根堆的堆排序得到递减序列**



> 
> 注意：
> 
> 
> * 如果结点按层序从0开始编号，结点 i 的左孩子为：2i+1，结点 i 的右孩子为：2i+2，结点 i 的父结点为：(i-1)/2
> * 如果结点按层序从0开始编号，假设共有 n 个结点，若 i <= n/2-1 ，该结点为非终端结点，若 i > n/2-1 ，该结点为终端结点
> 
> 
> 


以大根堆为例，小根堆同理

def adjust(arr, parent, length):
# parent：父结点的索引，length：参与调整的数组长度（结点个数）
# 左孩子的索引
child = parent * 2 + 1
while child < length:
# 如果右孩子存在，且右孩子大于左孩子
if child + 1 < length and arr[child + 1] > arr[child]:
child += 1 # child变成右孩子的索引
# 父结点的值小于左、右孩子，交换
if arr[parent] < arr[child]:
arr[parent], arr[child] = arr[child], arr[parent]
parent = child
# 此时，temp和child索引都指向了子结点与父结点交换后，原来的父结点应该插入的位置（原来的子结点的位置）
# 但是我们不确定这是不是这个结点的最终位置，也就是不确定原来的父元素（小元素）往下调整时会不会破坏下面的大根堆结构

        child = parent \* 2 + 1  # 原来的子结点变成了父结点，再找它的左孩子，如果存在左孩子继续循环，调整根堆
    else:  # 父结点的值大于等于左、右孩子，不交换
        break

def sort(arr):
# 建堆
# 从最后一个非终端结点【索引len(arr) // 2 - 1】开始向前遍历到根结点【索引0】
for i in range(len(arr) // 2 - 1, -1, -1):
adjust(arr, i, len(arr))

# 每一趟将堆顶元素加入有序子序列（堆顶元素与待排序列中的最后一个元素交换）
# i：待排序列中最后一个元素的索引
# 最后一个元素分别是从最后一个结点【索引len(arr) - 1】开始向前遍历到的第二个结点【索引1】
for i in range(len(arr) - 1, 0, -1):
    # 堆顶和最后一个元素互换位置
    arr[0], arr[i] = arr[i], arr[0]
    # 从顶开始重新调整堆
    adjust(arr, 0, i)
return arr

if name == “__main__”:
arr = [53, 17, 78, 9, 45, 65, 87, 32]
print(sort(arr))



> 
> 总结：
> 
> 
> * 堆排序是不稳定的
> * 建堆的时间复杂度为：O(n)，排序的时间复杂度为：O(nlogn)，总的时间复杂度为：O(nlogn)
> 
> 
> 


### 2.5 （直接）插入排序


  

插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序


插入算法把要排序的数组分成两部分：


* 第一部分是有序的数字（这里可以默认数组第一个数字为有序的第一部分）
* 第二部分为无序的数字（这里除了第一个数字以外剩余的数字可以认为是无序的第二部分）

def insert_sort(lis):
n = len(lis)
# 控制比较的轮数，即无序数据的个数，一个数肯定是有序的，不用比较
for j in range(1, n):
# 控制每一轮的比较次数
# i取值范围[j,j-1,j-2,j-3,1]
# 取出无序部分的首个，在有序部分从后向前比较，插入到合适的位置
for i in range(j, 0, -1):
# 找到合适的位置安放无序数据
if lis[i] < lis[i - 1]:
lis[i], lis[i - 1] = lis[i - 1], lis[i]
else:
break

if name == “__main__”:
lis = [2, 7, 3, 6, 9, 4]
insert_sort(lis)
print(lis)



> 
> 总结：
> 
> 
> * 直接插入排序是稳定的
> * 最坏时间复杂度为O(n^2)，本身倒序
> * 最优时间复杂度为O(n)，本身有序，每一轮只需比较一次
> 
> 
> 


### 2.6 归并排序

def merge_sort(nums):
if len(nums) <= 1:
return nums

mid = len(nums) // 2
left = merge_sort(nums[:mid])
right = merge_sort(nums[mid:])
return merge(left, right)

def merge(left, right):
merged = []
i = j = 0

while i < len(left) and j < len(right):
    if left[i] <= right[j]:
        merged.append(left[i])
        i += 1
    else:
        merged.append(right[j])
        j += 1

while i < len(left):
    merged.append(left[i])
    i += 1

while j < len(right):
    merged.append(right[j])
    j += 1

return merged



> 
> 总结：
> 
> 
> * 归并排序是稳定的
> * 假设数组长度为 n，则在归并排序的过程中，需要进行 logn 次划分，每次划分需要 O(n) 的合并操作，因此，归并排序的总体时间复杂度为  
>
2401_87368642
关注
《数据结构与算法 python语言描述》学习笔记（一）————绪论
qq_42056492的博客
10-01 2537
第一部分：学习内容概要 程序开发过程 问题求解 算法和算法分析 数据结构 第二部分：学习笔记 程序开发过程   框架图 分析，严格化——设计——编码——检查，翻译——测试/调试 - 牛顿迭代法 0.对给定正实数x和允许误差e，令变量y取任意正实数值，如：y = x; 1.如果y*y与x足够接近，即 | y * y - x | &amp;amp;amp;lt; e，计算结束并把y作为结果； 2.取z =（y + x...
python数据结构与算法40题_Python数据结构与算法分析（笔记与部分作业）
weixin_39982269的博客
12-19 2399
最近为了给写搬砖脚本增加一些算法知识，脑残的看起来算法书。Python数据结构与算法分析，本人英语比较差，看的是翻译版本的。网上有免费的原版的：https://runestone.academy/runestone/books/published/pythonds/index.html不废话，开笔记，第一章Python基础，最后的反向思路就稍微卡住了我一下。第1章，导论计算机科学的研究对象是问题、...
Python基础学习笔记 —— 数据结构与算法_数据结构与算法python笔记(1)
2401_84182318的博客
05-10 964
树是一种数据结构，它是由 n 个有限结点组成的一个具有层次关系的集合。二叉树则是每个结点最多有两个子树的树结构，通常子树被称作“左子树”和“右子树”。2k−12^{k-1}2k−12h−12^h-12h−1 个结点n0n_0n0​ 、n1n_1n1​ 和n2n_2n2​，则n0n21n0​=n2​+1（叶子结点比二分支结点多一个）其他常见的二叉树：二叉树通常以链式存储。
Python基础学习笔记 —— 数据结构与算法_数据结构与算法python笔记(2)
2401_84182337的博客
05-10 658
Python 中heapq模块是实现方法： 小顶堆的插入和弹出操作均将元素即可。
用Python解决数据结构与算法问题（一）：Python基础
种树最好的时间是10年前，其次是现在！！！
09-30 2万+
python学习之路 - 从入门到精通到大师 文章目录[python学习之路 - 从入门到精通到大师](https://blog.csdn.net/TeFuirnever/article/details/90017382)1.7.回顾Python基础1.8.数据入门1.8.1.内置的原子数据类型1.8.2.内置的集合数据类型 1.7.回顾Python基础 在本节中，我们将回顾 Python 编程语...
蓝桥杯Python这一篇就够了-训练系统题库合集（包括VIP试题）&数据结构与算法
热门推荐
Harry______的博客
11-13 11万+
第一版写于2020-11-13，第十一届蓝桥杯国赛前夕，老师和同学建议说写博文可以让学习更高效，陆陆续续写一些题解和学习笔记，在我的代码中我加了很多有助于理解程序的注释，希望这篇博客可以帮助你在蓝桥杯比赛或python学习取得进展。 一起进步，冲！ 目录一、蓝桥杯题库1.1入门训练1.2基础练习 一、蓝桥杯题库 1.1入门训练 Fibonacci数列 圆的面积 序列求和 A+B问题 1.2基础练习 数列排序 十六进制转八进制 十六进制转十进制 ...
【Python数据结构与算法】（一）基本概念和算法分析
阿里云专家博主、数据科学领域优质创作者、统计er在读
06-02 2268
✨本文收录于[《Python数据结构与算法》专栏，此专栏主要记录如何python学习数据结构与算法笔记以及练习题。 🌸个人主页：JoJo的数据分析历险记 📝个人介绍：小编大四统计在读，目前保研到统计学top3高校继续攻读统计研究生 💌如果文章对你有帮助，欢迎✌关注、👍点赞、✌收藏、👍订阅专栏 介绍数据结与算法基础概念、如何判断算法的时间复杂度，以及主项定理的介绍。...
数据结构与算法（Python语言实现）学习笔记
storyfull
11-01 1398
数据结构与算法（Python语言实现）整理算法和数据结构的知识！
python数据结构与算法学习路线
⛄
03-12 1706
更新进度：■■■■■■■■■■□□□□□□□□□□|50%
数据结构与算法Python版学习笔记一
12-21
在学习数据结构与算法的过程中，Python作为一种流行的编程语言，被广泛用于实现各种算法。这篇学习笔记主要关注在Python中处理输入输出（I/O）时的一些关键点，这对于在在线判题平台（Online Judge，简称OJ）上测试...
常见数据结构与算法的Python实现及学习笔记.zip
06-17
本资源"常见数据结构与算法的Python实现及学习笔记.zip"包含了对这些重要概念的深入理解和实践，特别适合初学者和进阶者提升技能。以下是关于数据结构和算法的一些主要知识点，以及Python中的实现方法。 1. **数组*...
数据结构与算法 Python语言描述-裘宗燕
10-01
《数据结构与算法 Python语言描述》是裘宗燕教授撰写的一本专著，主要面向希望深入理解数据结构和算法，并且希望通过Python语言实现这些概念的读者。这本书是北京大学的教学资源，因其深入浅出的讲解方式而备受推崇...
《数据结构与算法之美》的学习笔记和python代码实现.zip
06-16
《数据结构与算法之美》的学习笔记和Python代码实现提供了一条深入理解这些概念的途径，尤其适合大学生以及初学者，无论你是C/C++/JAVA还是Python的爱好者。 一、数据结构 数据结构是组织和管理大量数据的方式，它...
VeighNa：强大的Python开源量化交易平台
Unity打怪升级
09-26 674
VeighNa（简称 VN 或 vn.py）是一个基于 Python 的开源量化交易平台，专为量化交易爱好者和专业交易员设计。VeighNa 是由国内开发者社区推动的开源项目，旨在提供一个功能丰富、灵活且易于扩展的量化交易解决方案。该框架不仅支持多种资产类别的交易，如股票、期货、期权、加密货币等，还支持多种交易接口和协议，使得用户能够轻松进行多市场、多品种的交易策略开发和部署。
第二百五十四节 JPA教程 - JPA 多对多映射示例
最新发布
2301_78772942的博客
09-27 692
第二百五十四节 JPA教程 - JPA 多对多映射示例
Python精选200Tips：171-175
AnFany
09-26 1219
Python深度学习的项目
python中的深浅拷贝以及总体框架了解
AgostoDu的博客
09-26 1147
1、当b使用copy.deepcopy()深拷贝的时候，可以理解为b不仅外面的整体开辟了一个新的内存地址，b里面包含的列表也开辟了新的内存地址和a里面的内存地址没有任何关系，所以当a修改里面列表元素的值时不会影响b里面列表元素的值。print(mr) #{'name': 'lis', 'age': 18, 'scroe': 100}<br>备注：已经存在的值的优先级>默认值<br>6.3 直接修改 值，显示最新修改值 （修改默认值优先级小于直接添加的字典值）<br>
ubuntu安装libtorch
meng_152634的博客
09-25 742
nouveau是由第三方为NVIDIA显卡开发的一个开源3D驱动，ubuntu默认集成了nouveau驱动，安装NVIDIA驱动前必须禁用系统自带的显卡驱动nouveau，否则安装NVIDIA驱动时会报错。，一定要确定好安装的CUDA版本是否支持显卡的算力，否则安装成功也无法使用GPU加速。如果cmake版本低于3.18，会出现下面的报错，这是由于低于3.18的cmake不支持CUDA17的编译，需要更新cmake版本。因为安装的CUDA版本为12.1，这里选择最新版的CUDNN 9.4.0进行安装。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值