数据结构与算法学习笔记(python)——第四节搜索与排序

最新推荐文章于 2023-04-22 21:47:40 发布

AI阅读和图谱

最新推荐文章于 2023-04-22 21:47:40 发布

阅读量247

点赞数

分类专栏：人工智能代码实战 python 文章标签：数据结构数据挖掘 python 机器学习算法

本文链接：https://blog.csdn.net/qq_34740277/article/details/105135142

版权

python 同时被 3 个专栏收录

18 篇文章 0 订阅

订阅专栏

代码实战

14 篇文章 2 订阅

订阅专栏

人工智能

8 篇文章 0 订阅

订阅专栏

前言

本人是一个长期的数据分析爱好者，最近半年的时间的在网上学习了很多关于python、数据分析、数据挖掘以及项目管理相关的课程和知识，但是在学习的过程中，过于追求课程数量的增长，长时间关注于学习了多少多少门课程。事实上，学完一门课之后真正掌握的知识并不多，主要的原因是自己没有认真学习和理解温故而知新的这句话的真正含义。因此，从现在开始，我在学习《数据结构与算法——基于python》的课程内容之后，抽出固定的时间对每天学习的内容进行总结和分享，一方面有助于个人更好的掌握课程的内容，另一方面能和大家一起分享个人的学习历程和相应的学习知识。

第四节搜索与排序

基础知识

内容概述：顺序查找、二分搜索；冒泡排序、选择排序、插入排序、计数排序、归并排序、快速排序、堆排序/二叉树排序、python lib、应用。

1 顺序查找：
对于乱序的集合，查找其中的元素，只能用顺序查找； O（n/2）
程序

def search(num_list, val):
    # If empty
    if num_list == None:
        return -1
    
    for i in range(0, len(num_list)):
        if (num_list[i] == val):
            return i
    return -1
    num_list = [1,2,3,5,7,8,9]
print(search(num_list, 7))
print(search(num_list, 4))

输出结果
在这里插入图片描述
2 折半查找：
对于有序的集合，查找其中的元素，可用折半查找；O(log2n)
程序
递归方式

# 递归方式
def bi_search_re(num_list, val):
    def bi_search(l, h): # 定义一个low和high
        # Not found
        if l > h: # 相交 
            return -1
        
        # Check mid
        mid = (l + h) // 2
        if (num_list[mid] == val):
            return mid;
        elif (num_list[mid] < val):
            return bi_search(mid + 1, h)
        else:
            return bi_search(l, mid - 1)
        
   # return bi_search(0, len(num_list)) 我自己取消这一行程序的
num_list = [1,2,3,5,7,8,9]
print(search(num_list, 7))
print(search(num_list, 4))

输出结果
在这里插入图片描述
非递归方式

def bi_search_iter(alist, item):
    left, right = 0, len(alist) - 1
    while left <= right:
        mid = left +(right - left)//2 # (left + right) // 2
        if alist[mid] < item:
            left = mid + 1
        elif alist[mid] > item:
            right = mid - 1
        else: # alist[mid] = item
            return mid
    return -1
num_list = [1,2,3,5,7,8,9]
print(bi_search_iter(num_list, 9))
print(bi_search_iter(num_list, 4))

输出结果
在这里插入图片描述
3 冒泡排序：
基础知识：
1、重复列表进行排序,比较每对相邻的项目,如果它们的顺序错误,则交换它们。
2、在每次通过时，未排序的最大元素已被“冒泡 ”到阵列末端的合适位置
3、重复列表直到不需要交换，这表明列表已被排序。
属性：
稳定
O(1)额外的空间
O(n2) 比较和交换
适应性:O(n)接近排序时
代码

def _bubble_sort(nums: list, reverse=False):
    start = time.time()
    for i in range(len(nums)):
        # Get (i+1) largest in the correct position
        for j in range(len(nums) - i - 1):
            if nums[j] > nums[j + 1]:
                nums[j], nums[j + 1] = nums[j + 1], nums[j]
    if reverse:
        #nums = nums[::-1]  # why this is not working?
        nums.reverse()
    t = time.time() - start
    return len(nums), t


def bubble_sorted(nums: list, reverse=False) -> list: # reverse=False：表示升序，reverse=True：表示降序
    """Bubble Sort""" 
    nums_copy = list(nums)
    _bubble_sort(nums_copy, reverse=reverse)
    return nums_copy

l = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
l = bubble_sorted(l, reverse=False) # 
print(l)

运行结果
在这里插入图片描述
4 选择排序：
基础知识：
1、列表上的2个线性传递。
2、在每次通过时,它会选择最小（大）的值。
2、用最后一个未分类元素交换它。
属性：
不稳定
O(1)额外的空间
O(n2) 对比
O(n)互换
费适应性
代码

def selection_sort(items):
    start = time.time()
    for i in range(len(items)):   # n
        pos_min = i   #idx  最小元素的index和第一个元素进行交换
        for j in range(i + 1, len(items)):  # n
            if (items[j] < items[pos_min]):
                pos_min = j

        items[i], items[pos_min] = items[pos_min], items[i] # 最小值和第i个值交换位置
    t = time.time() - start
    return len(items), t  
l = [1, 3, 5, 7, 9, 2, 4, 6, 8, 99]
selection_sort(l)
print(l)

输出结果
在这里插入图片描述
5 插入排序：
基础知识：
1、列表上的2个线性传递。
2、在每次通过时,它会选择最小（大）的值。
3、用最后一个未分类元素交换它。
属性：
不稳定
O(1)额外的空间
O(n2) 对比
O(n)互换
费适应性
代码

def insert_sort(items):
    start = time.time()
    for sort_inx in range(1,len(items)):
        unsort_inx = sort_inx
        while unsort_inx > 0 and items[unsort_inx-1] > items[unsort_inx]: # 前一个大于后一个
            items[unsort_inx-1], items[unsort_inx] = items[unsort_inx], items[unsort_inx-1] # 交换前一个和后一个的值
            unsort_inx = unsort_inx-1 # unsort_inx-1 表示前unsort_inx-1已经排好序
    t = time.time() - start
    return len(items), t 
l = [1, 3, 5, 7, 9, 2, 4, 6, 8, 99]
insert_sort(l)
print(l)

输出结果
在这里插入图片描述
6 希尔排序：
基础知识：
1、插入排序的简单扩展，通过允许相隔很远的元素交换来获得速度。
2、逐步缩小要比较的元素之间的差距
3、从相距甚远的元素开始，可以将一些不适合的元素移动到比简单的最近邻居交换更快的位置
属性：
希尔排序的运行时间很大程度上取决于它使用的间隙顺序 * 对于许多实际的变量，确它们的时间复杂度仍然是一个公开的问题
代码

def shell_sort(nums):
    start = time.time()

    gap = len(nums)
    length = len(nums)

    while (gap > 0):
        for i in range(gap, length):
            for j in range(i, gap - 1, -gap):
                if (nums[j - gap] > nums[j]):
                    nums[j], nums[j - gap] = nums[j - gap], nums[j]

        if (gap == 2): 
            gap = 1
        else:
            gap = gap // 2 # 有 gap // 2 个小数组，第一个和第 gap // 2 +1 个是一组，进行排序，如此！再变成 gap // 2//2组。

    t = time.time() - start
    return len(nums), t  
l = [1, 3, 5, 7, 9, 2, 4, 6, 8, 99]
shell_sort(l)
print(l)

输出结果
在这里插入图片描述
7 计数排序：
基础知识
适用于：
1、元素的值比较集中，最大值和最小值差别不大；
2、有很多的重复值；
抽屉/桶原理；从最大值到最小值，每个值都是一个桶，将每个对应的数字放入其中的一个桶中，当所有的元素都被放入每个桶之后，每个桶的值和个数对应好排序。
时间复杂度：O(n)。目前为止，最快的排序方式；但是需要额外的空间来存储数字，所以范围不能太大，这样空间复杂度才比较小；
代码

def count_sort(items):
    start = time.time()    
    mmax, mmin = items[0], items[0]
    for i in range(1, len(items)): # 找到最大值和最小值
        if (items[i] > mmax): mmax = items[i]
        elif (items[i] < mmin): mmin = items[i]
    print(mmax)
    
    nums = mmax - mmin + 1 # 桶的个数，发抽屉；
    counts = [0] * nums # 刚开始 抽屉里面全是0；
    
    for i in range (len(items)):
        counts[items[i] - mmin] = counts[items[i] - mmin] + 1
# items[i] - mmin，得到第几号抽屉，
    pos = 0
    for i in range(nums): # 将数组打印出来
        for j in range(counts[i]):
            items[pos] = i + mmin
            pos += 1
    t = time.time() - start
    return len(items), t   
l = [1,1,2,2,3,3,3,3,8,8,8,8,7,7,7,9,9,9,3,3,3, 32, 2]
count_sort(l)
print(l)

输出结果
在这里插入图片描述
8 归并排序：
基础知识
分而治之
分：
• 递归地拆分数组,直到它被分成两对单个元素数组为止.
• 然后,将这些单个元素中的每一个与它的对合并,然后将这些对与它们的对等合并，直到整个列表按照排序顺序合并为止.
治：
• 将2个排序列表合并为另一个排序列表是很简单的。
• 简单地通过比较每个列表的头,删除最小的,以加入新排序的列表；
先将数组分为一半、再一半、最后每个一组，两两合并排序。然后两个两两合并成四个排序；如此循环，到最后数字就排好序了；
在这里插入图片描述
程序

def _merge(a: list, b: list) -> list:
    """Merge two sorted list"""
    c = []
    while len(a) > 0 and len(b) > 0:
        if a[0] < b[0]:
            c.append(a[0])  
            a.remove(a[0])
        else:
            c.append(b[0])
            b.remove(b[0])

    if len(a) == 0:
        c += b # 新生成的数组加到C里面；
    else:
        c += a
    return c
def _merge_sorted(nums: list) -> list:
    # Won't sort in place
    if len(nums) <= 1: 
        return nums

    m = len(nums) // 2
    a = _merge_sorted(nums[:m]) # 前半部分
    b = _merge_sorted(nums[m:]) # 后半部分
    return _merge(a, b)
# Wrapper
def merge_sorted(nums: list, reverse=False) -> list:
    import time
    start = time.time()
    """Merge Sort"""
    nums = _merge_sorted(nums)
    if reverse:
        nums = nums[::-1]

    t = time.time() - start
    return nums, len(nums), t

l = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
l = merge_sorted(l, reverse=True)[0]
print(l)

输出结果
在这里插入图片描述
9 快速排序：
基础知识
另外一个分而治之；
将数组划分为两部分，然后独立的对部分进行排序；
程序

def _quick_sorted(nums: list) -> list:
    if len(nums) <= 1:
        return nums
    pivot = nums[0] # 
    left_nums = _quick_sorted([x for x in nums[1:] if x < pivot])
    right_nums = _quick_sorted([x for x in nums[1:] if x >= pivot])
    return left_nums + [pivot] + right_nums
def quick_sorted(nums: list, reverse=False) -> list:
    """Quick Sort"""
    start = time.time()
    nums = _quick_sorted(nums)
    if reverse:
        nums = nums[::-1]
    t = time.time() - start
    return nums, len(nums), t
l = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
l = quick_sorted(l, reverse=True)
print(l)

输出结果
在这里插入图片描述

持续更新欢迎大家收藏点赞

AI阅读和图谱

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
3
评论
数据结构与算法学习笔记(python)——第四节搜索与排序

前言本人是一个长期的数据分析爱好者，最近半年的时间的在网上学习了很多关于python、数据分析、数据挖掘以及项目管理相关的课程和知识，但是在学习的过程中，过于追求课程数量的增长，长时间关注于学习了多少多少门课程。事实上，学完一门课之后真正掌握的知识并不多，主要的原因是自己没有认真学习和理解温故而知新的这句话的真正含义。因此，从现在开始，我在学习《数据结构与算法——基于python》的课程内容之后...
复制链接

扫一扫