数据结构-排序/二分查找

最新推荐文章于 2022-12-25 12:20:45 发布
最新推荐文章于 2022-12-25 12:20:45 发布
阅读量917 收藏 18
点赞数 5
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36047533/article/details/89300622
版权

数据结构-排序/二分查找

1.排序

实现归并排序、快速排序、插入排序、冒泡排序、选择排序、堆排序（选做）（完成leetcode上的返回滑动窗口中的最大值(239)

0.1 算法分类

排序算法可以分为两大类：
比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。
非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。
在这里插入图片描述

0.2 算法复杂度

在这里插入图片描述

0.3 相关概念

稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。
不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。
时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。
空间复杂度：是指算法在计算机
内执行时所需存储空间的度量，它也是数据规模n的函数。

以上内容来自以下链接：
https://www.cnblogs.com/onepixel/articles/7674659.html

1.1 冒泡排序

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

1.1 算法描述

  • 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
  • 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
  • 针对所有的元素重复以上的步骤，除了最后一个；
  • 重复步骤1~3，直到排序完成。

1.2 代码实现

# In[]
def bubbling_sort(lista):
    for i in range(len(lista)-1):
        for j in range(len(lista)-i-1):
            if lista[j]>lista[j+1]:
                temp=lista[j]
                lista[j]=lista[j+1]
                lista[j+1]=temp
    return lista
listb=bubbling_sort(lista)

1.2 快速排序

上面参考链接详细展示了十大经典排序算法（动图演示）快速排序法的核心思想是选定一个基准点后，两个哨兵往中间移动，对比与基准点的大小关系来决定是否要交换数值。一般来说，基准点是最左端的位置，当然也可以产生随机基准点。、、
注意要右边先移动，次序很重要
详细的原理解析见参考链接：
https://blog.csdn.net/sinat_20177327/article/details/76560079#commentBox

def swap(arr,a,b):    
    temp=arr[a]
    arr[a] = arr[b]
    arr[b] = temp
    return arr

def fastsort(arr,left,right):
    if left>=right:
        return
    i=left
    j=right
    temp=arr[left]
    while i!=j:
        while arr[j]>=temp and i<j:    # 右边的先动，这个很关键
            j-=1
        while arr[i]<=temp and i<j:
            i+=1    
        if i<j:
            swap(arr,i,j)
    if arr[i]<temp:    ## i==j时，判断相遇点与temp（基准）的大小
        swap(arr,left,i)
    fastsort(arr,left,i-1)
    fastsort(arr,i+1,right)
 # In[] 
#arr=[7,6,5,8]  
arr = [1,4,7,2,3,6,5,8]
fastsort(arr,0,len(arr)-1)

参考链接：

https://blog.csdn.net/sinat_20177327/article/details/76560079#commentBox

还有 堆排序、 归并排序、插入排序、选择排序等，后续再展开

1.3 滑动窗口中的最大值

leetcode上的返回滑动窗口中的最大值(239)
在这里插入图片描述
这题目用python 来写真的挺简单的

class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        s=[]
        if nums==[]:
            return []
        elif len(nums)<=k:
            s.append(max(nums))
            return s
        else:            
            for i in range(len(nums)-k+1):
                s.append(max(nums[i:i+k]))
            return(s)

1.4 第K 大元素

编程实现 O(n) 时间复杂度内找到一组数据的第 K 大元素（面试遇到了此问题）
结合快速排序法，排完第一轮后， left 和 right 指针相遇时，判断一下后半段的长度L与K 的大小关系，如果K 值比L 大，那么从左半段中继续寻找（K-L)大值，否则，从右半段中寻找第K大元素 开始新一轮的快速排序，直到找完第K大元素。

def swap(arr,a,b):    
    temp=arr[a]
    arr[a] = arr[b]
    arr[b] = temp
    return arr

def Find_Max_K(arr,left,right,K):
#    if left>=right:
#        return
    i=left
    j=right
    temp=arr[left]
    while i!=j:
        while arr[j]>=temp and i<j:    # 右边的先动，这个很关键
            j-=1
        while arr[i]<=temp and i<j:
            i+=1    
        if i<j:
            swap(arr,i,j)
    if arr[i]<temp:    ## i==j时，判断相遇点与temp（基准）的大小
        swap(arr,left,i)

    if i==K:
        print("第%d大值是:%d"%((len(arr)-K),arr[i]))
        return i
    elif i<K:
        Find_Max_K(arr,i+1,right,K)
    else:
        Find_Max_K(arr,left,i-1,K)
  
     # In[] 
#arr=[7,6,5,8]  
arr = [4,1,2,7,9,3,6,5,10,8]
mark=2
K=len(arr)-mark
Find_Max_K(arr,0,len(arr)-1,K)

在这里插入图片描述

2. 二分查找

二分查找常用的有这么七种：

①是否 存在数字t ——返回下标或者-1

②找到 大于t的第一个数 ——返回下标或者-1

③找到 大于等于t的第一个数 ——返回下标或者-1

④找到 小于t的第一个数 ——返回下标或者-1

⑤找到 小于等于 t的第一个数 ——返回下标或者-1

⑥是否 存在数字t，返回 第一个t ——返回下标或者-1

⑦是否 存在数字t，返回 最后一个t ——返回下标或者-1

2.1 代码实现

①是否 存在数字t ——返回下标或者-1
这是最简单原始的二分查找

# In[] 是否 存在数字t  ——返回下标或者 False
def findData(lista,target):
    left=0
    right=len(lista)
    m_last=0
    while left<=right:        
        m=int((left+right)/2)
        if m_last==m:
            break       
        if lista[m]==target:
            return m
        elif lista[m]<target:
            left=m
        else:
            right=m
        m_last=m
    return False

print(findData(lista,target))

②找到 大于t的第一个数 ——返回下标或者-1

# In[] 找出大于t的第一个数
def findData_2(lista,target):
    left=0
    right=len(lista)
    m_last=0
#    mark=0
    while left<=right:        
        m=int((left+right)/2)    
        if m_last==m or lista[m]==target:
            break
        elif lista[m]<target:
            left=m
        else:
            right=m
        m_last=m

    if m==len(lista):
        return m
    else:
        while m<len(lista):
            if lista[m]>target:
                return m
            m+=1  
        return False      
print(findData_2(lista,target))

③找到 大于等于t的第一个数 ——返回下标或者-1

# In[] 找出大于等于t的第一个数
def findData_3(lista,target):
    left=0
    right=len(lista)
    m_last=0
#    mark=0
    while left<=right:        
        m=int((left+right)/2)    
        if m_last==m or lista[m]==target:
            break
        elif lista[m]<target:
            left=m
        else:
            right=m
        m_last=m

    if lista[m]==target:   # 当前位置的值是target，往前去寻找第一个target 值
        while m>=0:
            if lista[m]<target:
                return m+1
            m-=1
    else:
        while m<len(lista):   # 没有找到等于target值的位置，往前找第一个大于target值的数
            if lista[m]>target:
                return m
            m+=1 
        return False
print(findData_3(lista,target))

④找到小于的第一个数 ——返回下标或者-1

# In[] 找到 小于t的第一个数 ——返回下标或者-1
def findData_4(lista,target):
    left=0
    right=len(lista)
    m_last=0
#    mark=0
    while left<=right:        
        m=int((left+right)/2)    
        if m_last==m or lista[m]==target:
            break
        elif lista[m]<target:
            left=m
        else:
            right=m
        m_last=m

    if  m==0:
        if lista[m]<target:  #若当前位置是第一位,且数值比target值小，那么返回第一位，否则False
            return m
        else:
            return False
    else:
        while m>=0:        #若当前位置不是第一位， 向前找出最靠近target的一位
            if lista[m]<target:
                return m
            m-=1 
        return False
print(findData_4(lista,target))

⑤找到小于等于 t的第一个数 ——返回下标或者-1

# In[] 找到 小于等于t的第一个数 ——返回下标或者-1
def findData_5(lista,target):
    left=0
    right=len(lista)
    m_last=0
#    mark=0
    while left<=right:        
        m=int((left+right)/2)    
        if m_last==m or lista[m]==target:
            break
        elif lista[m]<target:
            left=m
        else:
            right=m
        m_last=m
        
    print(m)
        
    if m==0:
        if lista[m]<=target:
            return m
        else:
            return False   # 当前位置的值是target，往前去寻找第一个target 值
    else:
        if lista[m]==target: # 当前位置的值是target，往前去寻找第一个target 值
            while m>=0:
                if lista[m]<target:
                    return m+1
                print(m)
                m-=1 
                
        else:    
            while m>=0:   # 没有找到等于target值的位置，往前找第一个小于target值的数
                if lista[m]<target:
                    return m
                m-=1 
            return False

print(findData_5(lista,target))

⑥是否 存在数字t，返回 第一个t ——返回下标或者-1

# In[] 是否 存在数字t，返回 第一个t ——返回下标或者-1
def findData_6(lista,target):
    left=0
    right=len(lista)
    m_last=0
#    mark=0
    while left<=right:        
        m=int((left+right)/2)    
        if m_last==m or lista[m]==target:
            break
        elif lista[m]<target:
            left=m
        else:
            right=m
        m_last=m

    if lista[m]==target:   # 当前位置的值是target，往前去寻找第一个target 值
        while m>=0:
            if lista[m]<target:
                return m+1
            m-=1
    else:
        return False   ## 没有找到该值，返回-1
print(findData_6(lista,target))

⑦是否 存在数字t，返回 最后一个t ——返回下标或者-1

# In[] 是否 存在数字t，返回 最后t ——返回下标或者-1
def findData_7(lista,target):
    left=0
    right=len(lista)
    m_last=0
#    mark=0
    while left<=right:        
        m=int((left+right)/2)    
        if m_last==m or lista[m]==target:
            break
        elif lista[m]<target:
            left=m
        else:
            right=m
        m_last=m

    if lista[m]==target:   # 当前位置的值是target，往后去寻找最后target 值
        if m==len(lista):  # 若当前位置已是最末端，return
            return m
        else:            
            while m<len(lista):
                if lista[m]>target:
                    return m-1
                m+=1
    else:
        return False   ## 没有找到该值，返回-1
print(findData_7(lista,target))

参考链接

https://blog.csdn.net/Hide_in_Code/article/details/76549317

2.7 sqrt函数的实现

Sqrt(x) （x 的平方根）

英文版：https://leetcode.com/problems/sqrtx/
中文版：https://leetcode-cn.com/problems/sqrtx/

class Solution:
    def mySqrt(self, x: int) -> int:
        if x==1 or x==0:
            return x
        else:
            left=0
            right=x
            while left<right:
                temp=(left+right)/2
                if int(temp)**2<=x and int((temp+1))**2>=x:                
                    if int((temp+1))**2==x:
                        temp=int((temp+1))
                    return(int(temp))
                    break        
                elif int(temp)**2<x and int(temp+1)**2<x:
                    left=temp             
                else:
                    right=temp

在这里插入图片描述

紫砂痕
关注
  • 5
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构---排序与二分查找
szyuan的博客
03-08 281
排序与二分查找 文章目录**排序与二分查找**一、排序1.1 归并排序1.2 快速排序1.3 插入排序1.4 冒泡排序1.5 选择排序1.6 堆排序1.7leetcode上的返回滑动窗口中的最大值(239)1.8 编程实现 O(n) 时间复杂度内找到一组数据的第 K 大元素二、二分查找2.1 有序数组的二分查找2.2 模糊二分查找（比如大于等于给定值的第一个元素）2.3 LeetCode练习题 一...
数据结构快速排序二分法查找
11-02
适合有点基础的人使用,于软件水平考试,计算机等级考试等复习使用
数据结构-二分排序
CJD的博客
12-18 1115
接触到二分排序是在看二叉树的资料里看到的。 建议如果还不会二分排序的先去看懂二分查询再来看就会很简单。 以下，是我对二分排序进行的个人理解分块： public class Main { public static void main(String[] args) { int[] a = { 2, 5, 6, 9, 7, 4, 3 };
数据算法与结构——归并排序、二分查找
L_Clarity的博客
04-01 268
1.归并排序 归并排序是采用分治法的一个非常典型的应用。归并排序的思想就是先递归分解数组，再合并数组。 将数组分解最小之后，然后合并两个有序数组，基本思路是比较两个数组的最前面的数，谁小就先取谁，取了后相应的指针就往后移一位。然后再比较，直至一个数组为空，最后把另一个数组的剩余部分复制过来即可。 1.1归并排序的实现 def merge_sort(alist): if len(alist...
二分查找和排序
SJCHEN1221的博客
10-28 676
二分查找，主要是针对排序问题进行查找 我们先算出数组的长度 len = sizeof(a) / sizeof(a[0]) 我们先设置 int left = 0; int right = Len - 1; int mid = (left + right ) / 2; 如果K大于mid，那么 left = mid + 1; 小于 right = mid -1; #include &...
c++数据结构---二分查找
03-15
4. **数组排序**：二分查找的前提条件是数组已经排序，本示例代码未对数组进行排序处理，因此在实际应用中需要先对数组进行排序。 综上所述，二分查找是一种高效的查找算法，尤其适用于大型有序数组。在C++中，通过...
数据结构学习---查找
06-25
二分查找仅适用于有序的数据结构，如有序数组。它通过不断将查找区间对半缩小来快速定位目标元素。首先，比较中间元素与目标值，如果目标值小于中间元素，则在左半部分继续查找；反之，在右半部分查找。每次查找都...
数据结构PPT：二分查找
12-18
**二分查找算法详解** 二分查找，又称为折半查找或二分搜索，是一种高效地在有序数组中查找特定元素的算法。...理解和掌握二分查找对于学习数据结构和算法至关重要，也是解决实际问题的重要工具。
漫话数据结构-顺序查找和折半查找.pptx
11-03
折半查找，又称为二分查找，是针对有序数组的一种高效查找算法。它的基础是每次比较都使搜索范围减半。首先，我们找到数组的中间元素，然后将目标值与中间元素比较。如果目标值等于中间元素，查找结束；如果目标值...
C++数据结构实验五：查找排序
最新发布
01-16
3. 掌握查找的概念、静态查找与动态查找、顺序查找、二分查找、索引查找等算法思想。 4. 掌握二叉排序树的概念、平衡二叉树等算法思想。 5. 掌握哈希查找、直接插入排序、快速排序、冒泡排序、简单选择排序等算法...
快速排序对数组排序，二分查找。
06-16
C实现的两种二分查找。 先用快速排序对数组排序，再二分查找。
c语言 二分查找（乱序 顺序）
qq_63250879的博客
12-25 470
c语言 实现二分查找 （乱序 顺序）
数据结构与算法之二分法插入排序
Weirenren_027的专栏
11-21 3044
一.算法思想： 插入排序算法思想：将插入的数与有序的数组各数比较，按照大小关系插入，保持原有大小顺序。（按照数组尾到数组头的顺序遍历） 而二分法插入：首先取出原有序中间数与新插的数比较，然后插入新数大小包含于其中的一半数组，再次取该数组中间数,如此重复下去，直至最后得到数组个数为一，将最后得到的数之后的数后移，然后将新插入的数放在该索引处。 二.模拟源码： #include usi
数据结构-排序-二分法插入排序
qq_40731414的博客
05-17 1297
数据结构-排序-二分法插入排序
数据结构-查找-顺序查找+二分查找
wh52013141314的博客
12-02 956
查找 定义 查找表：是由一组记录组成的表或文件，而每个记录由若干个数据项组成，并假设每个记录都有一个能唯一标识该记录的关键字。 简单点来说就是：再数据项（可以是数据，也可以是线性表）中找到这个数据。 一般来说查找分为内查找与外查找，我们这里主要研究内查找。 若在查找的同时对表做修改操作（如插入和删除），则相应的表称之为动态查找表；否则称之为静态查找表。 ​ 查找运算时间主要花费在关键字比较上，通常把查找过程中执行的关键字平均比较个数（称为平均查找长度）作为衡量一个查找算法效率优劣的标准。平
数据结构——二分法
Leeyuqq的博客
09-22 694
算法思想： 先设想一个不大于100数，你可以几次猜出。首先猜50，大了；再猜25，小了；再猜······ 代码实现： int fun(int *a, int n, int key) { int low,high,mid; low = 0; high = n-1; while(low <= high) { mid = (low+high)/2; if(key < a[...
Python 二分查找
weixin_33709609的博客
07-24 60
（非递归实现） def binary_search(alist, item): first = 0 last = len(alist)-1 while first<=last: midpoint = (first + last)/2 if alist[midpoint] == item: ...
数据结构之二分法以及八大排序算法的理解与代码实现（Java）
yyf4321的博客
10-28 2078
二分法 顾明思意，二分法就是将我们的数组一分为二，然后拿我们要查找的数去和中间的那个元素比较，如果刚好等于中间那个元素，那么就返回中间位置的下标。如果比中间的元素小，那么再使用相同的方式从中间元素的前面部分去找；相反如果比中间元素更大，那么就在中间元素后面的部分去找。如此循环，这样就叫二分法，相信大家都意识到了，二分法之所以能这样做的前提是：数组已经是有序的（通常情况下是升序）。下面看一下二分法的具体实现： ![在这里插入图片描述](https://img-blog.csdnimg.cn/2
数据结构二分法算法的步骤_数据结构:二分法插入排序
weixin_39952190的博客
12-23 751
二分法插入排序算法思想简单描述：在插入第i个元素时，对前面的0～i-1元素进行折半，先跟他们中间的那个元素比，如果小，则对前半再进行折半，否则对后半进行折半，直到left>right，然后再把第i个元素前1位与目标位置之间的所有元素后移，再把第i个元素放在目标位置上。二分法没有排序，只有查找。所以当找到要插入的位置时。移动必须从最后一个记录开始，向后移动一位，再移动倒数第2位，直到要插入的位...
C++数据结构算法模板：快速排序、归并排序与二分查找
在本文档中，提供了四个关于数据结构的C++代码模板，分别对应于快速排序、归并排序、整数二分搜索以及浮点数二分搜索。这些模板是编程竞赛或解决实际问题中常用的算法实现，对于理解和应用数据结构有重要作用。 1. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值