算法基础之搜索和经典排序

目录

简介

搜索算法

二分法查找

排序算法

冒泡排序(Bubble Sort)

选择排序(Selection Sort)

插入排序(Insert Sort)

快速排序(Quick Sort)

归并排序(Merge Sort)

堆排序Heap Sort)

希尔排序(Shell Sort)

计数排序(count_sort)

桶排序(Bucket Sort)

基数排序(Radix Sort)

总结


简介

定义和特征

  定义:算法(Algorithm)是指解题方案的准确而完整的描述,是一系列解决问题的清晰指令,算法代表着用系统的方法描述解决问题的策略机制。也就是说,能够对一定规范的输入,在有限时间内获得所要求的输出。如果一个算法有缺陷,或不适合于某个问题,执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。

  一个算法应该具有以下五个重要的特征:

  • 有穷性:算法的有穷性是指算法必须能在执行有限个步骤之后终止;
  • 确切性:算法的每一步骤必须有确切的定义;
  • 输入项:一个算法有0个或多个输入,以刻画运算对象的初始情况,所谓0个输入是指算法本身定出了初始条件;
  • 输出项:一个算法有一个或多个输出,以反映对输入数据加工后的结果,没有输出的算法是毫无意义的;
  • 可行性:算法中执行的任何计算步骤都是可以被分解为基本的可执行的操作步,即每个计算步都可以在有限时间内完成(也称之为有效性)。
     

设计要求

算法设计的要求: 

  • 确定性: 指的是算法至少应该有输入,输出和加工处理无歧义性,能正确反映问题的需求,能够得到问题的正确答案。确定性大体分为四个层次:
  1. 算法程序无语法错误;
  2. 算法程序对于合法的输入产生满足要求的输出;
  3. 对于非法输入能够产生满足规格的说明;
  4. 算法程序对于故意刁难的测试输入都有满足要求的输出结果。 
  • 可读性: 程序便于阅读,理解交流。 
  • 健壮性: 当输入数据不合法时,算法也能作出相关处理,而不是产生异常,崩溃或者莫名其妙的结果。 
  • 时间效率高和存储量低。

算法效率的度量方法

  事后统计方法:主要是通过设计好的测试程序和数据,利用计算机计时器对不同算法编制的程序的运行时间进行比较,从而确定算法效率的高低,但这种方法有很大缺陷,一般不予采纳。

  事前分析估算方法:在计算机程序编制前,依据统计方法对算法进行估算。

  一个用高级语言编写的程序在计算机上运行时所消耗的时间取决于以下因素:

  1. 算法采用的策略,方法;(算法好坏的根本)
  2. 编译产生的代码质量;(由软件来支持)
  3. 问题的输入规模;(由数据决定)
  4. 机器执行指令的速度。(看硬件的性能)

算法时间复杂度

  定义:在进行算法分析时,语句总的执行次数T(n)是关于问题规模n的函数,进而分析T(n)随n的变化情况并确定T(n)的数量级。算法的时间复杂度,也就是算法的时间量度,记作:T(n) = O(f(n))。它表示随问题规模n的增大,算法执行时间的增长率和f(n)的增长率相同,称作算法的渐近时间复杂度,简称为时间复杂度。其中f(n)是问题规定n的某个函数。

根据定义,求解算法的时间复杂度的具体步骤是:

  1. 找出算法中的基本语句;算法中执行次数最多的那条语句就是基本语句,通常是最内层循环的循环体。
  2. 计算基本语句的执行次数的数量级;只需计算基本语句执行次数的数量级,这就意味着只要保证基本语句执行次数的函数中的最高次幂正确即可,可以忽略所有低次幂和最高次幂的系数。这样能够简化算法分析,并且使注意力集中在最重要的一点上:增长率。
  3. 用大Ο记号表示算法的时间性能。将基本语句执行次数的数量级放入大Ο记号中。

如何推导大o阶呢?下面是基本的推导方法:

  1. 用常数1取代运行时间中的所有加法常数。
  2. 在修改后的运行次数函数中,只保留最髙阶项。
  3. 如果最高阶项存在且不是1,则去除与这个项相乘的常数。

简单的说,就是保留求出次数的最高次幂,并且把系数去掉。  如T(n)=n2+n+1 =O(n2)

一些例子

######复杂度O(1)
print("this is wd")######复杂度O(n)
for i in range(n):print(i)######复杂度O(n2)
for i in range(n):for j in range(n):print(j)######复杂度O(n3)
for i in range(n):for j in range(n):for k in range(n):print('wd')######复杂度O(log2n)
while n > 1:print(n)n = n // 2

常见的复杂度按效率排序:O(1)<O(logn)<O(n)<O(nlogn)<O(n2)<O(2nlogn)<O(n2)

常见的时问复杂度如表所示。

空间复杂度 

空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度。一个算法在计算机存储器上所占用的存储空间,包括存储算法本身所占用的存储空间,算法的输入输出数据所占用的存储空间和算法在运行过程中临时占用的存储空间这三个方面。算法的输入输出数据所占用的存储空间是由要解决的问题决定的,是通过参数表由调用函数传递而来的,它不随本算法的不同而改变。存储算法本身所占用的存储空间与算法书写的长短成正比,要压缩这方面的存储空间,就必须编写出较短的算法。算法在运行过程中临时占用的存储空间随算法的不同而异,有的算法只需要占用少量的临时工作单元,而且不随问题规模的大小而改变,这种算法是节省存储的算法;有的算法需要占用的临时工作单元数与解决问题的规模n有关,它随着n的增大而增大,当n较大时,将占用较多的存储单元。

如当一个算法的空间复杂度为一个常量,即不随被处理数据量n的大小而改变时,可表示为O(1);当一个算法的空间复杂度与以2为底的n的对数成正比时,可表示为0(log2n);当一个算法的空间复杂度与n成线性比例关系时,可表示为0(n).若形参为数组,则只需要为它分配一个存储由实参传送来的一个地址指针的空间,即一个机器字长空间;若形参为引用方式,则也只需要为其分配存储一个地址的空间,用它来存储对应实参变量的地址,以便由系统自动引用实参变量。 

最坏情况与平均情况

我们查找一个有n 个随机数字数组中的某个数字,最好的情况是第一个数字就是,那么算法的时间复杂度为O(1),但也有可能这个数字就在最后一个位置上待着,那么算法的时间复杂度就是O(n),这是最坏的一种情况了。

最坏情况运行时间是一种保证,那就是运行时间将不会再坏了。 在应用中,这是一种最重要的需求, 通常, 除非特别指定, 我们提到的运行时间都是最坏情况的运行时间。

而平均运行时间也就是从概率的角度看, 这个数字在每一个位置的可能性是相同的,所以平均的查找时间为n/2次后发现这个目标元素。平均运行时间是所有情况中最有意义的,因为它是期望的运行时间。也就是说,我们运行一段程序代码时,是希望看到平均运行时间的。可现实中,平均运行时间很难通过分析得到,一般都是通过运行一定数量的实验数据后估算出来的。一般在没有特殊说明的情况下,都是指最坏时间复杂度。

搜索算法

搜索是在一个数据集合中找到一个特定数据的算法,通常的答案是真的或假的。搜索的常见方法有二分查找、哈希查找等

二分法查找

二分查找又称折半查找,优点是比较次数少,查找速度快,平均性能好。缺点是要求待查表为有序表。因此,折半查找方法适用于不经常变动而查找频繁的有序列表。

二分查找的工作原理

  • 首先,假设表中元素是按升序排列,将表中间位置记录的关键字与查找关键字比较,如果两者相等,则查找成功。
  • 否则利用中间位置记录将表分成前、后两个子表,如果中间位置记录的关键字大于查找关键字,则进一步查找前一子表,否则进一步查找后一子表。
  • 重复以上过程,直到找到满足条件的记录,使查找成功,或直到子表不存在为止,此时查找不成功。

二分查找的实现

def binary(l, val):max = len(l)min = 0while min <=  max:mid = (max + min) // 2if l[mid] > val:max = mid - 1elif l[mid] < val:min = mid + 1elif l[mid] == val:print(mid)breakelse:print('no')def binary_rec(l, val, min, max):mid = (max + min) // 2if min > max:print('no')return 'no'if l[mid] == val:print(mid)return midelif l[mid] < val:return binary_rec(l, val, mid+1, max)elif l[mid] > val:return binary_rec(l, val, min, mid-1)

排序算法

冒泡排序(Bubble Sort)

  • 时间复杂度:最优时间复杂度:O(n),最坏时间复杂度:O(n²)。
  • 优点:稳定,简单
  • 缺点:效率不很高,运行时间较长

原理如下:

  1. 比较相邻的元素,如果第一个比第二个大,就交换他们两个;
  2. 对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。做完以后,最后的元素会是最大的数,这里可以理解为走了一趟;
  3. 针对所有的元素重复以上的步骤,除了最后一个;
  4. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较,最后数列就是从大到小一次排列;

代码实现

def bubble_sort(data):"""冒泡排序:param data: :return: """for i in range(len(data)-1):  # 趟数for j in range(len(data)-i-1):  # 遍历数据,依次交换if data[j]>data[j+1]:  # 当较大数在前面data[j],data[j+1]=data[j+1],data[j] #交换两个数的位置

优化版本:当某一趟走完以后发现并没有进行数据交换,那么此时的数列已经排列好了,没有必要在进行下去。例如:极端情况下,数列本来已经排序好的,我们只需要走一趟即可完成排序。

def bubble_sort(data):"""冒泡排序优化版:param data: :return: """for i in range(len(data)-1):  # 趟数exchange=False   # 交换标志for j in range(len(data)-i-1):  # 遍历数据,依次交换if data[j]>data[j+1]:  # 当较大数在前面data[j],data[j+1]=data[j+1],data[j]  # 交换两个数的位置exchange = True  # 改变标志if not exchange: # 如果某一趟没有进行交换,代表排序完成breakreturn i  # 返回次数的趟数

选择排序(Selection Sort)

  • 时间复杂度:最优时间复杂度:O(n²);最坏时间复杂度:O(n²)
  • 稳定性:不稳定
  • 优点:移动次数少
  • 缺点:比较次数多

工作原理

  1. 每一次从待排序的列表中选出一个元素,并将其与其他数依次比较,若列表中的某个数比选中的数小,则交换位置,把所有数比较完毕,则会选出最小的数,将其放在最左边(这一过程称为一趟);
  2. 重复以上步骤,直到全部待排序的数据元素排完;

实现

def select_sort(data):"""选择排序:param data: 待排序的数据列表:return: """for i in range(len(data)-1):  #趟数min_index=i  # 记录i趟开始最小的数的索引,我们从最左边开始for j in range(i+1,len(data)): # 每一次趟需要循环的次数if data[j] < data[min_index]:  # 当数列中的某一个数比开始的数要小时候,更新最小值索引位置min_index=jdata[i],data[min_index]=data[min_index],data[i]  # 一趟走完,交换最小值的位置,第一趟最小

插入排序(Insert Sort)

  • 时间复杂度:最优时间复杂度:O(n);最坏时间复杂度:O(n²)
  • 稳定性:稳定
  • 优点:稳定,比较快
  • 缺点:比较次数不确定,数据量越大,该算法越渣

工作原理如下:

  1. 以从小到大排序为例,元素0为第一个元素,插入排序是从元素1开始,尽可能插到前面。
  2. 插入时分插入位置和试探位置,元素i的初始插入位置为i,试探位置为i-1,在插入元素i时,依次与i-1,i-2······元素比较,如果被试探位置的元素比插入元素大,那么被试探元素后移一位,元素i插入位置前移1位,直到被试探元素小于插入元素或者插入元素位于第一位。
  3. 重复上述步骤,最后完成排序

实现

def insert_sort(data):"""插入排序:param data: 待排序的数据列表:return: """for i in range(1, len(data)): # 无序区域数据tmp = data[i] # 第i次插入的基准数for j in range(i, -1, -1):if tmp < data[j - 1]:  # j为当前位置,试探j-1位置data[j] = data[j - 1]  #  移动当前位置else:  # 位置确定为jbreakdata[j] = tmp  # 将当前位置数还原

快速排序(Quick Sort)

  • 时间复杂度:
  • 最优时间复杂度:O(nlogn)遍历每个数是O(n),访问每个数是O(logn),最终是O(nlogn)可以转换为求二叉树深度的思想
  • 最坏时间复杂度:O(n²)
  • 稳定性:不稳定
  • 优点:效率高,数据移动比较少,数据量越大,优势越明显
  • 缺点:不稳定

快速排序(Quicksort),又称划分交换排序(partition-exchange sort)。通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序。整个排序过程可以递归进行,以此达到整个数据变成有序序列。

工作原理如下:

  1. 从数列中随机挑选出一个数作为基数;
  2. 重新排列数列,使得比基数小的元素在左边,比基数大元素在右边,相等的元素放左边或者右边都可以,最后使得该基数在处于数列中间位置,这个称为分区操作;
  3. 递归上述操作,完成排序

实现

def quick_sort(data,left,right):"""快速排序:param data: 待排序的数据列表:param left: 基准数左边元素的索引:param right: 基准数右边元素的索引:return: """if left < right:mid = partition(data,left,right)  # 分区操作,mid代表基数所在的索引quick_sort(data,left,mid-1)   # 对基准数前面进行排序quick_sort(data,mid+1,right)  # 对基准数后面进行排序def partition(data,left,right):tmp=data[left]  # 随机选择的基准数,从最左边开始选while left < right:while left < right and data[right] >= tmp:  # 右边的数比基准数大right-=1  # 保留该数,然后索引指针往左移动data[left]=data[right]   # 否则此时右边数比基数小,则将该数放到基准位置while left < right and data[left] <= tmp: # 右边的数比基准数小left+=1  # 此时保持该数位置不动,索引指针往前移动data[right]=data[left]  # 否则此时左边的数比基数大,则将该数放到右边data[left] = tmp  # 最后将基准数量放回中间return left  # 返回基准数位置

归并排序(Merge Sort)

  • 最优时间复杂度:O(nlogn)最坏时间复杂度:O(nlogn)
  • 稳定性:稳定
  • 优点:稳定,数据量越大越优秀
  • 缺点:需要额外空间

归并排序(MergeSort)是采用分治法的一个非常典型的应用。归并排序的思想就是先递归分解数组,再合并数组。

归并排序是一种稳定的排序方法。和选择排序一样,归并排序的性能不受输入数据的影响,但表现比选择排序好的多,因为始终都是O(nlogn)的时间复杂度。代价是需要额外的内存空间。

工作原理如下:

  • 申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列;
  • 设定两个指针,最初位置分别为两个已经排序序列的起始位置;
  • 比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置;
  • 重复步骤3直到某一指针达到序列尾;
  • 将另一序列剩下的所有元素直接复制到合并序列尾

å¨è¿éæå¥å¾çæè¿°
实现

def merge(data, low, mid, high):"""合并函数:param data: 数据列表:param low: 列表开头位置:param mid: 分割中间位置:param high: 列表最后位置:return: """i = low  # 第一个指针j = mid + 1  # 第二个指针tmp = []  # 临时存放的列表while i <= mid and j <= high:  # 分割的列表当两边都有数才进行if data[i] < data[j]:tmp.append(data[i])i += 1  # 低的指针往右移动else:tmp.append(data[j])  # 右边大,存右边的数j += 1  # 同时指针右移动while i <= mid:  # 左边分割有剩下tmp.append(data[i])i += 1while j <= high:  # 右边有剩下tmp.append(data[j])j += 1data[low:high + 1] = tmp  # 最后将tmp中的数写入到原来的列表中def merge_sort(data, low, high):"""归并排序:param data: 待排序的数据列表:param low: 数据列表开始位置:param high: 数据列表结束位置:return: """if low < high:  # 至少有两个元素才进行mid = (low + high) // 2  # 分割merge_sort(data, low, mid)  # 递归分割上一部分merge_sort(data, mid + 1, high)  # 递归分割下一部分merge(data, low, mid, high)  # 合并

堆排序Heap Sort)

  • 时间复杂度:最优时间复杂度:O(nlogn),最坏时间复杂度:O(nlogn)
  • 稳定性:不稳定

本质是一个完全二叉树,如果根节点的值是所有节点的最小值称为小根堆,如果根节点的值是所有节点的最大值,称为大根堆。

原理:

  1. 将待排序数据列表建立成堆结构(建立堆);
  2. 通过上浮(shift_up)或下沉(shift_down)等操作得到堆顶元素为最大元素(已大根堆为例);
  3. 去掉堆顶元素,将最后的一个元素放到堆顶,重新调整堆,再次使得堆顶元素为最大元素(相比第一次为第二大元素);
  • 重复3操作,直到堆为空,最后完成排序;  
# -*- coding:utf8 -*-
import randomdef sift(li, low, high):# li表示树, low表示树根, high表示树最后一个节点的位置tmp = li[low]i = lowj = 2 * i + 1 # 初识j指向空位的左孩子# i指向空位,j指向两个孩子while j <= high: # 循环退出的第二种情况: j>high,说明空位i是叶子节点if j + 1 <= high and li[j] < li[j+1]: #如果右孩子存在并且比左孩子大,指向右孩子j += 1if li[j] > tmp:li[i] = li[j]i = jj = 2 * i + 1else: # 循环退出的第一种情况:j位置的值比tmp小,说明两个孩子都比tmp小breakli[i] = tmpdef heap_sort(li):n = len(li)# 1. 构造堆for low in range(n//2-1, -1, -1):sift(li, low, n-1)# 2. 挨个出数for high in range(n-1, -1, -1):li[0], li[high] = li[high], li[0] # 退休 棋子sift(li, 0, high-1)import copyli = list(range(1000))
random.shuffle(li)
heap_sort(li)
print li

希尔排序(Shell Sort)

  • 最优时间复杂度:根据步长序列的不同而不同,最优是1.3,根据数学运算算出的gap
  • 最坏时间复杂度:O(n²)
  • 稳定性:不稳定
  • 优点:平均时间短,数据移动少
  • 缺点:不稳定

希尔排序(Shell Sort)是插入排序的一种,也称缩小增量排序,是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法,是DL.Shell于1959年提出的。

工作原理如下:

  1. 先取一个小于n的整数d1作为第一个增量,把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。
  2. 先在各组内进行直接插入排序;
  3. 取第二个增量d2<d1重复上述的分组和排序,直至所取的增量  =1(  <  …<d2<d1),即所有记录放在同一组中进行直接插入排序为止。

å¨è¿éæå¥å¾çæè¿°

def shell_sort(data):"""希尔排序:param data:待排序的数据列表 :return: """d1 = len(data) // 2  # 设置分割大小为d1,while d1 > 0:for i in range(d1, len(data)):  # 在插入排序中 d1 为 1tmp = data[i]  # 当前分割元素位置j = i - d1  # 上一个分割元素位置while j >= 0 and tmp < data[j]:  # 上一个元素分割位置比当前分割位置要大,则需要调整位置data[j + d1] = data[j]  # 后移动当前分割元素位置j -= d1  # 往前移d1data[j + d1] = tmpd1 //= 2  # 继续分割

计数排序(count_sort)

  • 时间复杂度:最优时间复杂度:O(n),最坏时间复杂度:O(n)
  • 稳定性:稳定
  • 优点:速度快
  • 缺点:有局限性,范围不能太大,只能是整数

计数排序不是基于比较的排序算法,其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序,计数排序要求输入的数据必须是有确定范围的整数。

计数排序是一个稳定的排序算法。当输入的元素是 n 个 0到 k 之间的整数时,时间复杂度是O(n+k),空间复杂度也是O(n+k),其排序速度快于任何比较排序算法。当k不是很大并且序列比较集中时,计数排序是一个很有效的排序算法。

算法描述

  • 找出待排序的数组中最大和最小的元素;
  • 统计数组中每个值为i的元素出现的次数,存入数组C的第i项;
  • 对所有的计数累加(从C中的第一个元素开始,每一项和前一项相加);
  • 反向填充目标数组:将每个元素i放在新数组的第C(i)项,每放一个元素就将C(i)减去1。

def count_sort(li, max_num):count = [0 for i in range(max_num + 1)]  #设置计数序列并初始化为0for num in li:count[num] += 1i = 0for num,m in enumerate(count):for j in range(m):li[i] = numi += 1

桶排序(Bucket Sort)

  • 时间复杂度:最优时间复杂度:O(n),最坏时间复杂度:O(n)
  • 稳定性:稳定
  • 缺点:如果数据分布集中,如只分布在一个桶,效果不好。需要额外空间

桶排序是计数排序的升级版。它利用了函数的映射关系,高效与否的关键就在于这个映射函数的确定。桶排序 (Bucket sort)的工作的原理:假设输入数据服从均匀分布,将数据分到有限数量的桶里,每个桶再分别排序(有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排)。

桶排序最好情况下使用线性时间O(n),桶排序的时间复杂度,取决与对各个桶之间数据进行排序的时间复杂度,因为其它部分的时间复杂度都为O(n)。很显然,桶划分的越小,各个桶之间的数据越少,排序所用的时间也会越少。但相应的空间消耗就会增大。 

算法描述

  • 设置一个定量的数组当作空桶;
  • 遍历输入数据,并且把数据一个一个放到对应的桶里去;
  • 对每个不是空的桶进行排序;
  • 从不是空的桶里把排好序的数据拼接起来。 

def bucket_sort(data):buckets = [0] * ((max(data) - min(data)) + 1)  # 初始化桶元素为0for i in range(len(data)):buckets[data[i] - min(data)] += 1  # 遍历数组a,在桶的相应位置累加值ret_data = []for i in range(len(buckets)):if buckets[i] != 0:ret_data += [i + min(data)] * buckets[i]print(ret_data)return ret_data

基数排序(Radix Sort)

  • 时间复杂度:最优时间复杂度:O(n),最坏时间复杂度:O(n)
  • 稳定性:稳定
  • 缺点:只能处理正整数。需要额外空间

基数排序是按照低位先排序,然后收集;再按照高位排序,然后再收集;依次类推,直到最高位。有时候有些属性是有优先级顺序的,先按低优先级排序,再按高优先级排序。最后的次序就是高优先级高的在前,高优先级相同的低优先级高的在前。

基数排序基于分别排序,分别收集,所以是稳定的。但基数排序的性能比桶排序要略差,每一次关键字的桶分配都需要O(n)的时间复杂度,而且分配之后得到新的关键字序列又需要O(n)的时间复杂度。假如待排数据可以分为d个关键字,则基数排序的时间复杂度将是O(d*2n) ,当然d要远远小于n,因此基本上还是线性级别的。

基数排序的空间复杂度为O(n+k),其中k为桶的数量。一般来说n>>k,因此额外空间需要大概n个左右。

算法描述

  • 取得数组中的最大数,并取得位数;
  • arr为原始数组,从最低位开始取每个位组成radix数组;
  • 对radix进行计数排序(利用计数排序适用于小范围数的特点);

def radix_sort(li):max_num = max(li)i = 0while (10 ** i <= max_num):buckets = [[] for _ in range(10)]for val in li:digit = val // (10 ** i) % 10buckets[digit].append(val)li.clear()for bucket in buckets:for val in bucket:li.append(val)i += 1

总结

十大经典排序算法(动图演示) - 一像素 - 博客园

Python算法基础 - W-D - 博客园

python实现常见算法_流浮生的博客-CSDN博客_python实现算法

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/454245.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

背景宽高随文本变化_中科大提出ContourNet:更准确的任意形状场景文本检测新方法...

点击上方“CVer”&#xff0c;选择加"星标"置顶重磅干货&#xff0c;第一时间送达本文转载自&#xff1a;CSIG文档图像分析与识别专委会本文简要介绍2020年被CVPR录用的论文“ContourNet: Taking a Further Step toward Accurate Arbitrary-shaped Scene Text Detect…

算法面试题汇总(更新中)

1、根据数字返回相应位置数字 def get_digit(num, i):# i0 个位 1 十位 2 百位...return num // (10 ** i) % 10# print(get_digit(12345, 6)) 2、列表反转&#xff0c;不用内置函数 def reverse_list(li):n len(li)for i in range(n // 2):li[i], li[n-i-1] li[n-i-1], …

使用Jmeter对mysql进行性能测试入门

使用Jmeter对mysql进行性能测试入门 第一步&#xff1a;测试环境准备&#xff1a; 1&#xff09;、mysql> select version(); ----------- | version() | ----------- | 5.5.13 | ----------- ms数据库数据&#xff1a; mysql> select count(*) from account; ----------…

算法基础之数据结构

whats the 数据结构 数据结构是指相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成。 简单来说&#xff0c;数据结构就是设计数据以何种方式组织并存储在计算机中。 比如&#xff1a;列表、集合与字典等都是一种数据结构。 通常情况下&#xff…

soap接口怎么不返回tuple python_Python 中的接口

Python 是动态类型语言, 只在运行时做 Duck Typing 检查.利: 灵活, 方便弊: 代码混乱, 缺少规范标准自带两类接口支持: abc 和 typing.Protocol, 有他们协助给天马行空的程序员套上枷锁, Python 的大工程才可以"上道"abcabc 就是 Abstract Base Class, 虚基类. 跟 Ja…

java 第11次作业:你能看懂就说明你理解了——this关键字

this 代表当前对象 转载于:https://www.cnblogs.com/qingyundian/p/7736699.html

c#多线程操作界面控件的简单实现

一个小功能&#xff0c;早有人实现了。自己在一个项目中用到&#xff0c;觉得有必要记录一下&#xff0c;写下来。代码 从上面你可能已经看出如何多线程操作同一个控件的&#xff0c;就是通过一个委托&#xff0c;然后定义委托方法&#xff0c;判断控件的InvokeRequired属性&am…

ssh 免密_Linux下配置SSH免密通信 “sshkeygen”的基本用法

利用 SSH 协议可以有效防止远程管理过程中的信息泄露问题。SSH最初是UNIX系统上的一个程序&#xff0c;后来又迅速扩展到其他操作平台。1 什么是SSH引用百度百科的说明:SSH 为 Secure Shell的缩写&#xff0c;由 IETF 的网络小组(Network Working Group)所制定&#xff1b;它是…

Python 第三方模块之 NumPy - 科学计算

NumPy 简介 NumPy 发展历史 1995年 Jim HugUNin开发了Numeric。随后&#xff0c;Numarray包诞生。Travis Oliphants整合Numeric和Numarray&#xff0c;开发Numpy&#xff0c;于2006年发布第一个版本。Numpy&#xff08;Numeric Python&#xff09;提供了许多高级的数值编程工…

Python 第三方模块之 matplotlib - 绘图库

简介 matplotlib是受MATLAB的启发构建的。MATLAB是数据绘图领域广泛使用的语言和工具。MATLAB语言是面向过程的。利用函数的调用&#xff0c;MATLAB中可以轻松的利用一行命令来绘制直线&#xff0c;然后再用一系列的函数调整结果。 matplotlib有一套完全仿照MATLAB的函数形式…

微软P2V工具之Disk2VHD

虚拟化经过最近几年的发展&#xff0c;已经有很多的应用和服务迁移到了虚拟化的平台上了。在实施虚拟化的过程中就会涉及到将原来老旧的服务器来迁移到虚拟化平台的运行&#xff0c;这就是P2V&#xff0c;物理机转换为虚拟机。谈到P2V大家会想到很多的工具&#xff0c;例如Vmwa…

生成n套数位加减乘除_leetcode 算法汇总(四)位运算

一、 运算符& 与运算&#xff1a; 两个位都是 1 时&#xff0c;结果才为 1&#xff0c;否则为 0| 或运算&#xff1a; 两个位都是 0 时&#xff0c;结果才为 0&#xff0c;否则为 1^ 异或运算&#xff1a; 两个位相同则为 0&#xff0c;不同则为 1~ 取反运算&#xff1a;0 …

机器学习算法之 K-means、层次聚类,谱聚类

k-means 和层次聚类都属于划分聚类&#xff0c;实际中最常用的是k-means&#xff0c;k-means效果不好的情况下才会采用其他聚类 K-means算法 K-means算法&#xff0c;也称为K-平均或者K-均值&#xff0c;是一种使用广泛的最基础的聚类算法 假设输入样本为TX1,X2,…,Xm;则算法…

mapper注解的主要作用_Mybatis中mapper的xml解析详解

上一篇文章分析了mapper注解关键类MapperAnnotationBuilder&#xff0c;今天来看mapper的项目了解析关键类XMLMapperBuilder。基础介绍回顾下之前是在分析configuration的初始化过程&#xff0c;已经进行到了最后一步mapperElement(root.evalNode("mappers"))&#x…

机器学习之梯度下降法(GD)和坐标轴下降法(CD)

梯度下降法 梯度下降法&#xff08;Gradient Descent, GD&#xff09;常用于求解无约束情况下凸函数&#xff08;Convex Function&#xff09;的极小值&#xff0c;是一种迭代类型的算法&#xff0c;因为凸函数只有一个极值点&#xff0c;故求解出来的极小值点就是函数的最小值…

阿里云Https部署网站

0、开始之前 文章图片很多&#xff0c;注意流量 首先你得准备好一个已经备案成功的域名&#xff0c;并且有一个在阿里云的服务器部署了的网站。 然后就是你迫切的希望升级网站为HTTPS部署。 那么我们开始吧&#xff01; 1、申请CA证书 1.1登录阿里云控制台&#xff0c;选择菜单…

rabbitmq direct 多个消费者_一文解析 RabbitMQ 最常用的三大模式

Direct 模式所有发送到 Direct Exchange 的消息被转发到 RouteKey 中指定的 Queue。Direct 模式可以使用 RabbitMQ 自带的 Exchange: default Exchange&#xff0c;所以不需要将 Exchange 进行任何绑定(binding)操作。消息传递时&#xff0c;RouteKey 必须完全匹配才会被队列接…

C# 读取保存App.config配置文件的完整源码参考

最近出差在北京做一个小项目&#xff0c;项目里需要读取配置文件的小功能&#xff0c;觉得挺有参考意义的就把代码发上来给大家参考一下。我们选择了直接用微软的读取配置文件的方法。 这个是程序的运行设计效果&#xff0c;就是把这些参数可以进行灵活设置&#xff0c;灵活保存…

TensorFlow 简介

TensorFlow介绍 Tagline&#xff1a;An open-source software library for Machine Intelligence.Definition&#xff1a;TensorFlow TM is an open source software library fornumerical computation using data flow graphs.GitHub&#xff1a;https://github.com/tensorfl…

webbrowser设置为相应的IE版本

注册表路径&#xff1a; HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\Internet Explorer\Main\FeatureControl\FEATURE_BROWSER_EMULATION 或者HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Internet Explorer\Main\FeatureControl\FEATURE_BROWSER_EMULATION 究竟选择哪一个…