Python基础学习笔记（九） —— 数据结构与算法

已于 2024-06-06 15:03:59 修改
阅读量2.9k 收藏 20
点赞数 6
分类专栏： 数据结构和算法 python 文章标签： python 学习
于 2023-02-14 22:01:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hu_wei123/article/details/128872399
版权
本文介绍了数据结构的基础概念，包括数组、链表、队列、栈、堆和二叉树的定义、实现与操作。此外，还探讨了排序算法（冒泡排序、快速排序、选择排序、堆排序）和查找算法（二分查找）的基本思想和实现方法。文章以Python语言为例，展示了如何实现这些数据结构和算法。
摘要由CSDN通过智能技术生成

数据结构与算法

1 数据结构基础


本章所需相关基础知识：

self 可以看成当前类的一个对象，可以调用这个类里的函数和变量

1.1 数组


1. 数组的基本结构

数组是最常见的一种数据结构，其由有限个类型相同的变量按照一定的顺序组合构成，在Python中常常利用列表（list）来表示数组。Python定义数组的时候与C/C++中定义数组时的区别在于定义时无序指定长度，可以动态增长，不断向后追加元素，一般不会出现数组溢出的状况，为编程者带来了极大的自由度。

# 一维数组
arr1 = [1, 2, 3, 4]
print(arr1)  # [1, 2, 3, 4]
print(arr1[0])  # 1

# 二维数组
arr2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
print(arr2)  # [[1, 2, 3, 4], [5, 6, 7, 8]]
print(arr2[0][3])  # 4
# 一般通过如下方式定义一个二维数组
arr3 = [[i for i in range(4)] for j in range(3)]
print(arr3)  # [[0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]

2. 数组的基本操作

# 定义
arr = [1, 2, 3, 4, 5, 1]

# 增加
# arr.append(6)
# print(arr) # [1, 2, 3, 4, 5, 1, 6]

# 删除（利用pop()，remove()，del()方法删除元素）
# 1. pop([索引]) 删除指定索引对应的元素，默认删除数组最后一个元素，并返回该值
# arr.pop()
# arr.pop(1)
# 2. remove(元素值) 删除数组里某个值的第一个匹配项
# arr.remove(1)
# 3. del() 按照索引删除元素
# del(arr[2])
# del arr[2]

# 插入
# insert(插入的索引位置，插入的元素)
# arr.insert(0, 100)

# 查找
# 1. 想确定数组中是否含有某一个元素
# if 200 in arr:
#     print("True")
# 2. 想确定某个元素的索引，index(元素值) 查找数组中该元素第一次出现的索引
# arr.index(1)

# 修改
# 通过索引直接访问重新赋值即可
# arr[0] = 9

# 反转
# reverse()方法反转列表，直接对数组进行操作，没有产生额外的空间
# arr.reverse()

# 排序
# 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：链表的最后一个结点的指针域，为空

单链表

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

在这里插入图片描述

双向链表

在这里插入图片描述

单向循环链表

在这里插入图片描述

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

以单链表为例，在数组内如想要删除或者插入元素到某一位置，该位置之后的所有元素都需要象前或者向后移动，这样一来，时间复杂度就与数组的长度有关，为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 个有限结点组成的一个具有层次关系的集合。

树的基本性质如下：

在这里插入图片描述

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 开始的

其他常见的二叉树：

在这里插入图片描述

注意：

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

在这里插入图片描述

二叉树通常以链式存储

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 相关题目吧

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

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

在这里插入图片描述

2 排序算法


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

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

2.1 冒泡排序


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

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

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

在这里插入图片描述

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 （简单）选择排序


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

在这里插入图片描述

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) 的合并操作，因此，归并排序的总体时间复杂度为 O ( n l o g n ) O(nlogn) O(nlogn)
    划分过程：每次将数组划分为两个大小相等的子数组，所需时间复杂度为 O(logn)。
    合并过程：对于每个子数组，需要线性时间将其合并成一个有序的数组。合并的时间复杂度为 O(n)。
  • 归并排序的空间复杂度为 O ( n + l o g n ) = O ( n ) O(n+logn)=O(n) O(n+logn)=O(n)，因为在合并过程中需要创建一个临时数组来存储合并的结果，另外归并排序递归调用的层数最深为 l o g n logn logn

3 查找

3.1 二分查找


二分查找的适用前提：必须有序

非递归方法

def binary_search(lis, num):
    left = 0
    right = len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if num > lis[mid]:
            left = mid + 1
        elif num < lis[mid]:
            right = mid - 1
        else:  # num == arr[mid]
            return mid
    return -1


if __name__ == "__main__":
    lis = [1, 3, 5, 7, 9, 10]
    print(binary_search(lis, 5))  # 2
    print(binary_search(lis, 8))  # -1

递归方法

def binary_search(alist, left, right, item):
    while left <= right:
        mid = (left + right) // 2  # 获取有序数组中间值下标索引
        if item < alist[mid]:
            return binary_search(alist, left, mid - 1, item)
        elif item > alist[mid]:
            return binary_search(alist, mid + 1, right, item)
        else:
            return mid
    return -1


if __name__ == "__main__":
    lis = [1, 3, 5, 7, 9, 10]
    print(binary_search(lis, 0, len(lis) - 1, 9))  # 4
    print(binary_search(lis, 0, len(lis) - 1, 100))  # -1

注意：递归调用函数自身的时候，前面加上return

夏木夕
关注
  • 6
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python数据结构和算法【总结】
qq_35810838的博客
11-24 1698
一。什么是算法 算法是计算机处理信息的本质，因为计算机程序本质上是一个算法来告诉计算机确切的步骤来执行一个指定的任务。一般地，当算法在处理信息时，会从输入设备或数据的存储地址读取数据，把结果写入输出设备或某个存储地址供以后再调用。 通俗的来讲，算法就是你解决问题的思路。 二。算法的五大特性 输入: 算法具有0个或多个输入 输出: 算法至少有1个或多个输出 有穷性: 算法在有限的步骤之后...
《数据结构与算法 python语言描述》学习笔记（一）————绪论
qq_42056492的博客
10-01 2523
第一部分：学习内容概要 程序开发过程 问题求解 算法和算法分析 数据结构 第二部分：学习笔记 程序开发过程   框架图 分析，严格化——设计——编码——检查，翻译——测试/调试 - 牛顿迭代法 0.对给定正实数x和允许误差e，令变量y取任意正实数值，如：y = x; 1.如果y*y与x足够接近，即 | y * y - x | &amp;amp;amp;lt; e，计算结束并把y作为结果； 2.取z =（y + x...
python数据结构与算法（1）
weixin_33895604的博客
11-27 109
数据结构与算法（Python） Why？我们举⼀个可能不太恰当的例⼦：如果将开发程序的过程⽐喻为作战，我们码农便是指挥作战的将军，⽽我们 所写的代码便是⼠兵和武器。那么数据结构和算法是什么？答⽈：兵法！我们可以不看兵法在战场上⾁搏，如此，可能会胜利，可能会失败。即使胜 利，可能也会付出巨⼤的代价。我们写程序亦然：没有看过数据结构和算 法，有时⾯对问题可能会没有任何思路，不知如何下⼿去解决；⼤部分时...
【零基础】学python数据结构与算法笔记
weixin_56760882的博客
12-23 1905
学习python数据结构与算法，学习常用的算法，了解了算法入门概念，复习了递归。
Python 数据结构与算法
最新发布
weixin_44098348的博客
03-12 1196
列表（List）：列表是Python中最常用的数据结构之一，用于存储一组有序的元素。列表使用方括号[]来定义，其中的元素可以是任意数据类型，并且可以动态增加、删除或修改。元组（Tuple）：元组与列表类似，不同之处在于元组使用圆括号()来定义，一旦创建就不能被修改（即元组是不可变的）。字典（Dictionary）：字典是无序的键值对集合，用大括号{}来定义，可以通过键来访问对应的值。字典的键必须是唯一的，但值可以重复。集合（Set）：集合是一种无序的、不重复的数据集合，用大括号{}
Python数据结构与算法
慕白博客
08-23 1688
Python数据结构与算法 一、筛选数据 0x1 列表 列表解析 [x for x in data if x&gt;= 0] filter函数: g = filter(lambda x : x &gt;=0, data) 在python3中，得到的是构造器，要用list才可以得到结果 list(g) 0x2 字典 字典解析 {k:v for k, v i...
《数据结构与算法 python语言描述》学习笔记（二）————抽象数据类型和Python类
qq_42056492的博客
10-05 1491
第一部分：学习内容概要 抽象数据类型 Python的类 第二部分：学习笔记 抽象数据类型   1.抽象数据类型（Abstract Data Type，ADT），通过一套接口阐述说明这一程序部分的可用功能，但不不限制功能的实现方法。   2.抽象数据类型（ADT）的基本想法是把数据定义为抽象地集合，只为他们定义可用的合法操作，并不暴露其内部实现的具体细节，不论是其数据的表示细节还是操作的实现细...
Python-基础学习笔记.docx
11-15
Python 基础学习笔记 本笔记基于《Python 语言程序设计基础（第 2 版）》第一部分 初识 Python 语言，涵盖了计算机的概念、程序设计语言、Python 语言概述、Python 语言开发环境配置、程序的基本编写方法等知识点。...
《数据结构和算法 python语言描述》学习笔记（三）————线性表
qq_42056492的博客
10-19 1305
第一部分：内容概述 线性表的概念和表的抽象数据类型 顺序表的实现 链接表 链表的变形和操作 表的应用 第二部分：学习笔记 线性表的概念和表的抽象数据类型    1. 在一个非空的线性表里，存在着唯一的一个首元素和唯一的一个尾元素（末元素）。除首元素之外，表的每个元素e都有且仅有一个前驱元素；除了尾元素之外的每个元素都有且仅有一个后继元素。    2. 线性表的操作     ① 首先，作为抽象...
数据结构与算法（python）
weixin_42681868的博客
01-31 1109
栈： #栈的实现 ''' 栈的操作： Stark() 创建一个新的栈 push() 压栈 pop() 弹出栈元素 peek() 返回栈顶元素 is_empty() 判断栈是否为空 size() 返回栈的个数 ''' class Stack(): def __init__(self): self.__list =...
PYTHON的数据结构和算法介绍
wui66655的博客
02-23 516
当你听到数据结构时，你会想到什么? 数据结构是根据类型组织和分组数据的容器。它们基于可变性和顺序而不同。可变性是指创建后改变对象的能力。我们有两种类型的数据结构，内置数据结构和用户定义的数据结构。 什么是数据算法-是由计算机执行的一系列步骤，接受输入并将其转换为目标输出。 内置数据结构 列表 列表是用方括号定义的，包含用逗号分隔的数据。该列表是可变的和有序的。它可以包含不同数据类型的混合。 months=['january','february','march','april','may','
【北京大学】数据结构与算法 python 课程笔记
biozhuangxiao的博客
03-24 373
第一节：概述 1.课程定位：Python语言基础之后的进阶课程，将数据组织起来，有效处理以解决问题 2.计算的概念 2.1基于有穷观点的能行方法：有限数量的明确指令——有限步骤后终止——每次执行都能得到唯一结果且可以被精确执行 2.2二十世纪三十年代：递归函数模型、lambda演算模型、post机模型、图灵机模型 2.3图灵机的规则 <状态1，读取字符，改写字符，状态2，状态的操作> e.g.<读写头位于第一个字符处，读取第一个字符a，改写第一个字符a为空格，读写..
PYTHON数据结构与算法学习笔记（一）
qq_43635468的博客
02-26 548
目录算法算法的概念算法的特性算法效率衡量Python内置类型性能分析数据结构概念算法与数据结构的关系抽象数据类型(Abstract Data Type) 算法 算法的概念 算法是独立存在的一种解决问题的方法和思想，是计算机处理信息的本质。 计算机程序本质上是一个算法来告诉计算机确切的步骤来执行一个指定的任务。一般当算法在处理信息时，会从输入设备或数据的存储地址读取数据，把结果写入输出设备或某个存储...
python数据结构与算法讲解_详解python数据结构和算法
weixin_39918682的博客
11-30 320
详解python数据结构和算法
2.Python数据结构与算法 2.1算法和数据结构
LIWEI940638093的博客
03-02 557
Python数据结构与算法算法引入概念第一次尝试算法概念的提出算法的五大特性第二次尝试第一次尝试和第二次尝试的算法分析算法效率衡量执行时间反应算法效率单靠时间值绝对可信吗？时间复杂度与“大O记法”如何理解“大O记法”最坏时间复杂度时间复杂度的几条基本计算规则常见时间复杂度常见时间复杂度之间的关系Python内置类型性能分析list的操作测试list和dict的内置操作的时间复杂度数据结构引入概念算...
Python数据结构和算法笔记总结
xiaoduu的博客
08-17 750
文章目录Python数据结构和算法笔记解决题目的思路时间复杂度重要工具...Python抽象类型如何使用面向对象的方式实现数据结构Python数据结构数组array列表listlist练习两数之和按奇偶排序数组[搜索二维矩阵 II](https://leetcode-cn.com/problems/search-a-2d-matrix-ii/)移除元素合并两个有序数组链表链表的概念概念不同的链表类型单链表(linked list)双链表(double linked list)链表练习如何将一个list构造一
数据结构与算法Python版之北大慕课笔记（三）
冠军阿狗的博客
06-02 1370
数据结构与算法Python版之北大慕课笔记（三）一、散列：Hashing1. 引入散列2. 散列基础知识3. 完美散列函数3.1 散列函数MD5/SHA3.2 Python的散列函数库hashlib二、散列函数最酷应用：区块链三、散列函数设计1. 折叠法2. 平方取中法3. 非数项四、冲突解决方案1. 开放定址2. 数据项链Chaining五、抽象数据类型“映射”：ADT Map 一、散列：Has...
python之常用数据结构和算法
m0_47670683的博客
12-09 308
分解序列 序列：可以是字符串、列表、元组、集合、字典、可迭代对象。 将N个元素的序列分解成N个变量。 word="hello" a,b,c,d,e=word print(a,b,c,d,e) out: h e l l o number=set([1,2,3,4]) a,b,c,d=number print(a,b,c,d) out: 1 2 3 4 n_dict={'a':1,'b':2,'c':3,'d':4} a,b,c,d=n_dict print(a,b,c,d) e,f,g,h=n_di
python数据结构与算法学习路线及系列文章汇总(持续更新。。）
xutiantian1412的博客
10-02 9916
虽然是用python搞机器学习的大项目，还是要从零开始学习数据结构那一套理论。不知不觉数据结构及算法系列的学习及LeetCode刷题已经一大堆，现对此汇总。 如下是一套比较合理的完整的学习路径： 1）数据结构与算法的理论，包括复杂度的思想，从线性表开始(链表，栈和队列)，然后是数组和字符串的初级理论和题目（双指针）；查找算法中深刻理解二分查找及哈希查找。 2）接下来打算学习树及二叉树相关姿势...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值