两种线性时间选取第i小的元素的方法+ python实现（未完结）

最新推荐文章于 2021-07-07 10:07:01 发布
最新推荐文章于 2021-07-07 10:07:01 发布
阅读量621 收藏 2
点赞数 1
分类专栏： 算法 文章标签： 线性时间 获取元素 排列位序 算法 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tuboshuShaoBaTu/article/details/102840806
版权

先看第一种比较简单并且也比较容易理解的`
思路如下：
快速排序的核心过程可以直接得到我们当前选择元素在最后将所有元素排好序后当前元素所在位置。
所以我们可以考虑对快速排序进行改编，由于我们不需要知道每个元素的具体位置所以，我们可以选择性地执行快速排序的核心过程。

随机选取元素然后和第一个元素进行交换，并且最终将所有小于和大于当前选取的元素的其他元素进行重新排序，小的排在左边大的排在右边。

代码如下：

import numpy as np
import random

A = [random.randint(1, 100) for i in range(10)]

def randomizedPartition(A, p, r):
    i = np.random.randint(p, r+1)
    print(i,A[i])
    A[r], A[i]= A[i], A[r]
    x = A[r]
    i = p-1
    for j in range(p,r):
        if A[j]<=x:
            i+=1
            A[i], A[j]=A[j], A[i]

    A[i+1], A[r] = A[r], A[i+1]
    print(A)
    return i+1

randomizedPartition(A, 0,len(A)-1)

def randomizedSelect(A, p, r, i):
    if p==r:
        return A[p]
    q=randomizedPartition(A, p ,r)
    k=q-p+1
    if i==k:
        return A[q]
    elif i<k:
        return randomizedSelect(A,p,q-1,i)
    else:
        return randomizedSelect(A,q+1,r,i-k)

    pass

print(randomizedSelect(A,0, len(A)-1, int(input('请输入你要的第i位'))))

运行结果如图：


4 59
[30, 59, 100, 89, 65, 67, 94, 86, 68, 64]
请输入你要的第i位5
9 64
[30, 59, 64, 89, 65, 67, 94, 86, 68, 100]
4 65
[30, 59, 64, 65, 100, 67, 94, 86, 68, 89]
9 89
[30, 59, 64, 65, 67, 86, 68, 89, 94, 100]
6 68
[30, 59, 64, 65, 67, 68, 86, 89, 94, 100]
67

Process finished with exit code 0

另一种升级版本的方法，思路：我们不断获取中位数，比上面的随机选取数要靠谱很多，并且我们还可以改革数据存储结构，让获取中位数更加简单一些
我们尽量把数变成奇数行尽量方的一堆数

例如假设数组一共有100个元素那么我们可以把它变形成11行10列其中最后一列只有第一个行有元素

我们先通过快速排序的核心方法取出每一列的中位数，放在每一列的中间然后将小的元素放在中间元素的上面，大的放在下面。

之后我们把所有的列通过中位数的大小从小到大排序，小的放左边，大的放右边

这时候我们发现在整个数组最中间的就是这个数组真正的中位数，中位数左方肯定都是不比它大的数，右边肯定都是不比它小的数。我们这样分类，每次将目标缩小到原来的四分之3（由1/4和1/2组成）

我们第一次对根号n个列找中位数通过快速排序核心算法每个最多花费根号n的时间
所以

T（n） = T（n/2）+ T（n/4）+ O（n）

由主定理推导 a=1 b=4 fn = n

属于
fn比在这里插入图片描述大的时候fn为主导，复杂度为fn即n线性时间就可以完成

下面的代码实现了将A中的所有列的中位数的中位数放在最中间，并且小的放在左边大的放在右边

# 这个算法我失败了我的心有点乱

import numpy as np
import random


maxNum = 10000
aimLength = random.randint(100, 10000)
print(aimLength)
# 我们要获取的第aimI小的元素位序
aimI = random.randint(0, aimLength)


rowNum = int(aimLength**0.5)


A = [random.randint(1, maxNum) for i in range(aimLength)]

# 判断A之后要分成多少行
if rowNum%2 ==1:
    pass
else:
    rowNum +=1

# 下面我们进行判断我们准备把数组化成二维但是可能出现排不满的情况，所以进行添加，用足够大的数进行添加。
if aimLength%rowNum ==0:
    pass
else:
    while True:
        aimLength+=1
        A.append(maxNum)
        if aimLength%rowNum ==0:
            break


A = np.array(A).reshape((rowNum, int(aimLength/rowNum)))
print(A)
# 完成对初始数组A的处理


# resultCol =

def randomizedPartition(A, p, r):
    i = np.random.randint(p, r+1)
    A[r], A[i]= A[i], A[r]
    x = A[r]
    i = p-1
    for j in range(p,r):
        if A[j]<=x:
            i+=1
            A[i], A[j]=A[j], A[i]

    A[i+1], A[r] = A[r], A[i+1]
    return i+1

# 对所有数据进行操作
def randomizedListPartition(currentrow, p, r):

    global A
    i = np.random.randint(p, r+1)
    print(A)
    # 进行交换
    A[:, [i, r]] = A[:, [r, i]]
    print(A)
    x = A[currentrow, r]
    i = p-1
    for j in range(p,r):
        if A[currentrow,j]<=x:
            i+=1
            A[:, [i, j]] = A[:, [j, i]]


    A[:, [i+1, r]] = A[:, [r, i+1]]
    return i+1


def randomizedSelect(A, p, r, i):
    if p==r:
        return A[p]
    q=randomizedPartition(A, p ,r)
    k=q-p+1
    if i==k:
        return A[q]
    elif i<k:
        return randomizedSelect(A,p,q-1,i)
    else:
        return randomizedSelect(A,q+1,r,i-k)



# 和上面唯一的不同是我们是对所有数据进行位置替换
def randomizedListSelect(A,currentrow,  p, r, i):

    if p==r:
        return A[currentrow][p]
    q=randomizedListPartition(currentrow, p ,r)
    print('93*****')
    print(A)
    k=q-p+1
    if i==k:
        return A[currentrow][q]
    elif i<k:
        return randomizedListSelect(A,currentrow,p,q-1,i)
    else:
        return randomizedListSelect(A,currentrow,q+1,r,i-k)



def colMidPartition(aimLength, rowNum):
    global A
    currentResultArray = []

    for i in range(int(aimLength/rowNum)):
        currentList = []
        for temp in A[:, i:i+1].tolist():
            currentList.append(temp[0])
        randomizedSelect(currentList, 0, len(currentList)-1, int(len(currentList)/2))
        currentResultArray.append(currentList)

    A = np.array(currentResultArray).T
    print('A', A)

# 和上面的方法不同的是这个是对整个A进行操作 比较每个位的中位数  返回 的结果中 比 每个中位数的 中位数小的列 在左大的列 在右
def colMidListPartition(aimLength, rowNum):
    global A
    # 列的数量
    colNum = int(aimLength / rowNum)
    # 我们的目的就是求第colNum/2 小的元素 它就是所有列中位数的中位数
    int(colNum/2)
    currentrow = int(rowNum/2)

    # 返回的就是整个A的所有中位数的中位数
    currentResult = randomizedListSelect(A, currentrow, 0, colNum-1, int(colNum/2))
    print('sadasdasd')
    print(A[currentrow,])




    pass

colMidPartition(aimLength, rowNum)


colMidListPartition(aimLength, rowNum)


# def getAimINum(aimI,aimLength,rowNum):
#     global A

运行结果如下：

4476
[[ 2570   788  1211 ...  7760  9688  1732]
 [ 8841  9728  4773 ...  4501  9534  7511]
 [ 9961  4225  7874 ...  5886  4074  9658]
 ...
 [  988  5257   424 ...  8832  5714  2550]
 [ 9960  8824  4501 ...  4604  8593  8048]
 [ 4397  8708  4380 ... 10000 10000 10000]]
A [[  857   788  1211 ...  1189   564  1732]
 [  278    33   618 ...  1302   460  1886]
 [ 1795   795   150 ...  1846   701  1483]
 ...
 [ 9263  6386  9099 ...  8832  8840  8475]
 [ 9960  8824  9403 ...  6385  8593  9994]
 [ 9612  9353  7985 ...  9398  9951 10000]]
[[  857   788  1211 ...  1189   564  1732]
 [  278    33   618 ...  1302   460  1886]
 [ 1795   795   150 ...  1846   701  1483]
 ...
 [ 9263  6386  9099 ...  8832  8840  8475]
 [ 9960  8824  9403 ...  6385  8593  9994]
 [ 9612  9353  7985 ...  9398  9951 10000]]
[[ 857  788 1211 ... 1189  564  349]
 [ 278   33  618 ... 1302  460 2384]
 [1795  795  150 ... 1846  701   38]
 ...
 [9263 6386 9099 ... 8832 8840 7381]
 [9960 8824 9403 ... 6385 8593 9356]
 [9612 9353 7985 ... 9398 9951 8488]]
93*****
[[ 857 1569  357 ... 1189  564 3638]
 [ 278  482  557 ... 1302  460  476]
 [1795 1202  643 ... 1846  701 2688]
 ...
 [9263 9149 9954 ... 8832 8840 7929]
 [9960 9222 7390 ... 6385 8593 8463]
 [9612 9621 8311 ... 9398 9951 9046]]
[[ 857 1569  357 ... 1189  564 3638]
 [ 278  482  557 ... 1302  460  476]
 [1795 1202  643 ... 1846  701 2688]
 ...
 [9263 9149 9954 ... 8832 8840 7929]
 [9960 9222 7390 ... 6385 8593 8463]
 [9612 9621 8311 ... 9398 9951 9046]]
[[ 857 1569  357 ... 1189  564  856]
 [ 278  482  557 ... 1302  460  989]
 [1795 1202  643 ... 1846  701 1046]
 ...
 [9263 9149 9954 ... 8832 8840 8458]
 [9960 9222 7390 ... 6385 8593 8329]
 [9612 9621 8311 ... 9398 9951 9023]]
93*****
[[ 857 1569  357 ...  292 1389 3382]
 [ 278  482  557 ...  384 1765 4168]
 [1795 1202  643 ...  171 3162 2644]
 ...
 [9263 9149 9954 ... 9652 9814 9132]
 [9960 9222 7390 ... 8223 9539 5882]
 [9612 9621 8311 ... 9805 9065 7695]]
[[ 857 1569  357 ...  292 1389 3382]
 [ 278  482  557 ...  384 1765 4168]
 [1795 1202  643 ...  171 3162 2644]
 ...
 [9263 9149 9954 ... 9652 9814 9132]
 [9960 9222 7390 ... 8223 9539 5882]
 [9612 9621 8311 ... 9805 9065 7695]]
[[ 857 1569  357 ...  292 1389 3382]
 [ 278  482  557 ...  384 1765 4168]
 [1795 1202  643 ...  171 3162 2644]
 ...
 [9263 9149 9954 ... 9652 9814 9132]
 [9960 9222 7390 ... 8223 9539 5882]
 [9612 9621 8311 ... 9805 9065 7695]]
93*****
[[ 857 1569  357 ...  292 1389 3382]
 [ 278  482  557 ...  384 1765 4168]
 [1795 1202  643 ...  171 3162 2644]
 ...
 [9263 9149 9954 ... 9652 9814 9132]
 [9960 9222 7390 ... 8223 9539 5882]
 [9612 9621 8311 ... 9805 9065 7695]]
[[ 857 1569  357 ...  292 1389 3382]
 [ 278  482  557 ...  384 1765 4168]
 [1795 1202  643 ...  171 3162 2644]
 ...
 [9263 9149 9954 ... 9652 9814 9132]
 [9960 9222 7390 ... 8223 9539 5882]
 [9612 9621 8311 ... 9805 9065 7695]]
[[ 857 1569  357 ...  292 1389 3382]
 [ 278  482  557 ...  384 1765 4168]
 [1795 1202  643 ...  171 3162 2644]
 ...
 [9263 9149 9954 ... 9652 9814 9132]
 [9960 9222 7390 ... 8223 9539 5882]
 [9612 9621 8311 ... 9805 9065 7695]]
93*****
[[ 857 1569  357 ...  292 1389 3382]
 [ 278  482  557 ...  384 1765 4168]
 [1795 1202  643 ...  171 3162 2644]
 ...
 [9263 9149 9954 ... 9652 9814 9132]
 [9960 9222 7390 ... 8223 9539 5882]
 [9612 9621 8311 ... 9805 9065 7695]]
[[ 857 1569  357 ...  292 1389 3382]
 [ 278  482  557 ...  384 1765 4168]
 [1795 1202  643 ...  171 3162 2644]
 ...
 [9263 9149 9954 ... 9652 9814 9132]
 [9960 9222 7390 ... 8223 9539 5882]
 [9612 9621 8311 ... 9805 9065 7695]]
[[ 857 1569  357 ...  292 1389 3382]
 [ 278  482  557 ...  384 1765 4168]
 [1795 1202  643 ...  171 3162 2644]
 ...
 [9263 9149 9954 ... 9652 9814 9132]
 [9960 9222 7390 ... 8223 9539 5882]
 [9612 9621 8311 ... 9805 9065 7695]]
93*****
[[ 857 1569  357 ...  292 1389 3382]
 [ 278  482  557 ...  384 1765 4168]
 [1795 1202  643 ...  171 3162 2644]
 ...
 [9263 9149 9954 ... 9652 9814 9132]
 [9960 9222 7390 ... 8223 9539 5882]
 [9612 9621 8311 ... 9805 9065 7695]]
sadasdasd
[4296 4327 3955 4438 4044 3895 4515 4235 4277 3888 3669 4199 4532 4761
 4920 4573 4629 4903 4725 4888 4893 4783 4836 4597 4815 4579 4905 4928
 4995 4938 4998 4999 5044 5060 5177 5164 5185 5091 5054 5168 5127 5100
 5241 5262 5364 5657 5403 5369 5462 5613 5571 5312 5462 5598 5458 5657
 5763 6732 5821 6002 5758 6125 5769 6120 6026 5764 8575]

Process finished with exit code 0

之后我们考虑对上面的代码反复调用从而实现需求，

# 这个算法我失败了我的心有点乱

import numpy as np
import random


maxNum = 10000
aimLength = random.randint(100, maxNum)
print(aimLength)
# 我们要获取的第aimI小的元素位序
aimI = random.randint(0, aimLength)
print('我们要的是第',aimI,'小的元素')
A = [random.randint(1, maxNum) for i in range(aimLength)]
rowNum = 0


def makeUpListaAndOtherParams():
    global rowNum
    global aimLength
    global A
    rowNum = int(aimLength ** 0.5)
    # 判断A之后要分成多少行
    if rowNum % 2 == 1:
        pass
    else:
        rowNum += 1
    # 下面我们进行判断我们准备把数组化成二维但是可能出现排不满的情况，所以进行添加，用足够大的数进行添加。
    if aimLength % rowNum == 0:
        pass
    else:
        while True:
            aimLength += 1
            A.append(maxNum)
            if aimLength % rowNum == 0:
                break
    A = np.array(A).reshape((rowNum, int(aimLength / rowNum)))
    print(A)
    # 完成对初始数组A的处理

resultCol = 0  # 额。。。。这里指的是顺序而不是位序是位序加一
resultRow = 0
# 获取我们要的i到底是在第几行第几列 并且赋值给resultCol， resultRow
def getResultColAndRow(aimI, aimLength, rowNum):
    global resultCol
    global resultRow

    if aimI*rowNum % aimLength==0:   # 如果整除那就证明aimI是落在某行的最后面的一个
        resultCol = int(aimI*rowNum/aimLength)
        resultRow = int(aimLength/rowNum)
    else:
        resultCol = int(aimI * rowNum / aimLength)+1
        resultRow = int(aimI%(int(aimLength/rowNum)))


# 并且我们通过coreCode执行之后比中位数大的元素都会出现在 最中间的所有原色的中位数的右边和下边，这时  我们的aimI要是会出现在右下方我们就应
def coreCode(aimLength, rowNum):

    def randomizedPartition(A, p, r):
        i = np.random.randint(p, r + 1)
        A[r], A[i] = A[i], A[r]
        x = A[r]
        i = p - 1
        for j in range(p, r):
            if A[j] <= x:
                i += 1
                A[i], A[j] = A[j], A[i]

        A[i + 1], A[r] = A[r], A[i + 1]
        return i + 1

    # 对所有数据进行操作
    def randomizedListPartition(currentrow, p, r):

        global A
        i = np.random.randint(p, r + 1)
        print(A)
        # 进行交换
        A[:, [i, r]] = A[:, [r, i]]
        print(A)
        x = A[currentrow, r]
        i = p - 1
        for j in range(p, r):
            if A[currentrow, j] <= x:
                i += 1
                A[:, [i, j]] = A[:, [j, i]]

        A[:, [i + 1, r]] = A[:, [r, i + 1]]
        return i + 1

    def randomizedSelect(A, p, r, i):
        if p == r:
            return A[p]
        q = randomizedPartition(A, p, r)
        k = q - p + 1
        if i == k:
            return A[q]
        elif i < k:
            return randomizedSelect(A, p, q - 1, i)
        else:
            return randomizedSelect(A, q + 1, r, i - k)

    # 和上面唯一的不同是我们是对所有数据进行位置替换
    def randomizedListSelect(A, currentrow, p, r, i):

        if p == r:
            return A[currentrow][p]
        q = randomizedListPartition(currentrow, p, r)
        print('93*****')
        print(A)
        k = q - p + 1
        if i == k:
            return A[currentrow][q]
        elif i < k:
            return randomizedListSelect(A, currentrow, p, q - 1, i)
        else:
            return randomizedListSelect(A, currentrow, q + 1, r, i - k)

    def colMidPartition(aimLength, rowNum):
        global A
        currentResultArray = []

        for i in range(int(aimLength / rowNum)):
            currentList = []
            for temp in A[:, i:i + 1].tolist():
                currentList.append(temp[0])
            randomizedSelect(currentList, 0, len(currentList) - 1, int(len(currentList) / 2))
            currentResultArray.append(currentList)

        A = np.array(currentResultArray).T
        print('A', A)

    # 和上面的方法不同的是这个是对整个A进行操作 比较每个位的中位数  返回 的结果中 比 每个中位数的 中位数小的列 在左大的列 在右
    def colMidListPartition(aimLength, rowNum):
        global A
        # 列的数量
        colNum = int(aimLength / rowNum)
        # 我们的目的就是求第colNum/2 小的元素 它就是所有列中位数的中位数
        int(colNum / 2)
        currentrow = int(rowNum / 2)


        # 返回的就是整个A的所有中位数的中位数
        currentResult = randomizedListSelect(A, currentrow, 0, colNum - 1, int(colNum / 2))
        print('sadasdasd')
        print(A[currentrow,])
        # 返回的是顺序号而不是位序号
        return currentrow+1,int(colNum / 2) , currentResult, int(colNum/2) + (currentrow)*(rowNum-1)
        pass

    colMidPartition(aimLength, rowNum)
    return colMidListPartition(aimLength, rowNum)

def getAimINum(aimLength,rowNum):

    global A
    global resultCol
    global resultRow
    global aimI

    # 初始化参数
    makeUpListaAndOtherParams()
    # 获取resultCol和resultRow
    getResultColAndRow(aimI, aimLength, rowNum)
    currentrow, currentcol, currentResult, currentAim= coreCode(aimLength, rowNum)
    if resultCol == currentcol and resultRow == currentrow:
        print('这个数是：', currentResult)
        return currentResult
    else:
        # 我们在这里对参数进行修改之后再次调用自身方法
        if aimI > currentAim:
            # 我们要的是更大的数 说明肯定比当前中位数的中位数小的元素都可以不要
           # 

            pass




        pass




getAimINum(aimI,aimLength,rowNum)
tuboshuShaoBaTu
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python线性时间内寻找元素（递归与分治）
04-20
【问题描述】每次都是优化选出一个元素（分组后的中位数）为划分基准，在线性时间内寻找第i小元素。提示：分组时的组的个数为n/5的向下取整；分组后的中位数取第（num_group/2向上取整）小的元素。 【输入形式】在屏幕上输入若干整数，各数间都以一个空格分隔。再输入要寻找的元素是数组从小到大顺序中第几个位置。 【输出形式】第一次划分基准元素，和数组从小到大顺序中要寻找的那个位置的元素。 【样例1输入】 2 9 8 0 7 10 1 12 3 14 5 13 6 11 4 3 【样例1输出】 7 2 【样例1说明】 输入：15个整数，以空格分隔。要寻找第3小元素。 输出：7表示第一划分基准元素为7，2表示第3小元素为2。
线性时间选择 python实现 计算机算法设计与分析
T_T7729的博客
10-25 1868
   最近算法老师布置了很多作业啊，其中一项就是要求实现书上《计算机算法设计与分析》28页的算法，实现过程如下：  
线性时间选择算法
aijianxie8808的博客
07-23 305
在一个由 n 个元素组成的集合中，第 i 个顺序统计量（order statistic）是该集合中第 i 小的元素。也就是说，最小值是第 1 个顺序统计量（i = 1），最大值是第 n 个顺序统计量（i = n）。 中位数（median）是它所在集合的中点元素。当 n 为奇数时，中位数是唯一的，出现在 i = (n + 1)/2 处。当 n 为偶数时，存在两个中位数，下中位数 i = ...
最坏线性时间的python实现 。
u010565244的专栏
03-17 683
def short_find(a, rank):     a.sort()     return a[rank - 1] # Find the rank'th-smallest value in a, in worst-case linear time. def find(a, rank):     n = len(a)     assert 1     if n  
线性时间内求数组中第i大小的元素
weixin_30508241的博客
10-20 177
一、题目描述 设有一个算法Median能在O(n)的时间内计算一个数组的中位值(即将数组的元素按大小顺序排列正好位于中间的值)。给定一个有n个元素的数组，能否以Median算法为基础设计一个算法，对任意的整数1≤i≤n，该算法在O(n)的时间内求出数组中第i大小的元素。如果能，请给出一个这样的算法并分析其最坏时间复杂性。 二、算法分析 1.将输入的数组A[n]中的n个元素分为n/5组，每组5...
讲解Python3中NumPy数组寻找特定元素下标的两种方法
09-18
本文将介绍两种方法来实现这一功能。 首先，我们可以使用`np.where()`函数。`np.where()`是NumPy提供的一个条件索引函数，它根据指定的条件返回满足条件的元素的索引。语法为`np.where(conditions, [x, y])`，其中`...
preceptron_without_bp_python实现线性二分类_cloudj3u_线性回归分类_
10-02
标题中的"preceptron_without_bp_python实现线性二分类"是指使用Python编程语言实现的感知机（Perceptron）算法，而"cloudj3u_线性回归分类"则可能是作者或项目的名字，暗示我们将讨论如何用线性回归模型进行分类...
线性规划-单纯形法-窗体实现(python)
03-27
在本项目中，"线性规划-单纯形法-窗体实现(python)"是用Python编程语言实现的一种交互式解决方案，它结合了数学概念与用户友好的图形界面。 单纯形法是线性规划的标准解法，由乔治·丹齐格在1947年提出。这种方法...
两种主成分分析（PCA）的python实现算法
06-27
在Python中，PCA的实现主要有两种方式：第一种是通过`sklearn.decomposition`库中的`PCA`类；第二种是通过手动计算，包括计算协方差矩阵、特征值和特征向量等步骤。 ### 1. 使用`sklearn.decomposition.PCA` `...
python中线性规划中的单纯形法、scipy库与非线性规划求解问题
12-21
线性规划是一种优化技术，用于在满足一组线性约束条件下最大化或最小化一个线性目标函数。当线性规划问题的变量数大于方程个数时，可能存在多个解，这时可以使用单纯形法来求解。单纯形法由丹·佐敦在1947年提出，是...
线性时间选择算法实现
05-25
线性时间选择问题，采用不生成随机数的算法
[Python3]Sherwood 型线性时间选择算法
...
06-13 736
# sherwood algorithm import time import random def time_calculate(): start = time.perf_counter() mid_value = main() end = time.perf_counter() return mid_value, end - start def s...
找出数组中第i小元素(时间复杂度Θ(n)--最坏情况为线性的选择算法
外太空的博客
07-07 508
找出数组中第i小元素 期望时间复杂度：Θ(n) 最坏情况的时间复杂度Θ(n^2) int randomized_select(int *array,int start,int end,int index){ if(start == end) return array[start]; int middle = randomized_partition(array,start,end); int position = middle - start + 1; if
Python小程序——线性时间排序
weixin_33909059的博客
04-10 58
1 '''最好让k的值与list的元素数量n差不多，如果是n的幂的话就不合适了''' 2 3 4 def init_part(k,out_list): 5 #k is the max int of out_list.Value in out_list is larger than >= 0. 6 Assist_list = [] 7 ...
【算法导论】线性时间选择---从数组中选择第i小的数
Harry的专栏
10-12 5238
问题：从数组中选择第i小的数，并且要求问题的时间复杂度为O(n)。 代码用到了随机化的快速排序中的分组方法。 其基本原理为：用快速排序的分组方法，随机的选择一个数组元素，使其大于左边的元素，小于右边的元素。然后，看这个元素的下表与要求元素中第i小的值是否相等，如果小于i则表示要查找的元素在当前分组元素的右边，如果大于i表示在左边。这样递归进行，可以达到很高的运行效率。 c++实现的代码如下：
选择问题：线性时间内找到序列的第k小的元素
weixin_34166847的博客
03-05 271
      选择问题——在序列中按顺序找到某个元素。这可以用排序方法做到，即先排个序，在找到指定元素，但是这样就按最快的堆排序、合并排序啥的都得是O(nlgn)数量级的，这里采取的方法可以在期望为O(n)的时间内完成。 具体的做法如同快速排序，因为快速排序最好情况时间也为O(nlogn)，但是在实际情况下，遇到的代拍序列并不是最好的。因此，一种改进的方式是快速排序的随机化版本。利用随机化方式应用...
Sherwood 型线性时间选择算法（python实现）
ohh-hl的博客
06-26 1423
实验内容 给定任意几组数据，利用舍伍德型选择算法，找出数组中的中值并输出（若数 组为奇数个则输出中值，若数组为偶数个则输出第 n/2 小元素）。 实验原理 设 A 是一个确定性算法，当它的输入实例为 x 时所需的计算时间记为 tA(x)。 设 Xn 是算法 A 的输入规模为 n 的实例的全体，则当问题的输入规模为 n 时， 算法 A 所需的平均时间为 1。这显然不能排除存在 x∈Xn 使得的 2 可能性。希望获得一个随机化算法 B，使得对问题的输入规模为 n 的每一个实例均有 3。 这就是舍伍德算法设计的基
python-线性查找
deep learning
09-03 207
def linear_search(L, e): found = False for i in range(len(L)): # go through all elements if e == L[i]: found = True break # with a break to stop loop while found, Complexity O(n) return found L =[1, 2, 3, 5, 6,
python在画另外的图时如何选取这前两种颜色，给出代码
最新发布
05-31
你可以使用Seaborn库中的`color_palette()`函数来获取Set1调色板的颜色列表，然后根据需要选择前两种...接着，我们用`sns.scatterplot()`和`sns.lineplot()`函数画了一张散点图和一条线性回归线，分别使用了两种颜色。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值