选择算法总结

最新推荐文章于 2024-07-15 22:38:30 发布
最新推荐文章于 2024-07-15 22:38:30 发布
阅读量1w 收藏 28
点赞数 12
分类专栏： 算法 C++ 算法鸣泣之时 文章标签： 选择算法 BFPRT 排序算法 顺序统计量 中位数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ii1245712564/article/details/45952151
版权
C++ 同时被 3 个专栏收录
40 篇文章 2 订阅
订阅专栏
算法
30 篇文章 1 订阅
订阅专栏
算法鸣泣之时
30 篇文章 6 订阅
订阅专栏

注：本文中的所有代码都在这里

选择算法

选择算法就是用来解决在一堆数里面选出第k大的数的问题。选择算法的设计方法有很多，比如将这堆数据先进行排序，然后取出对应的第k个元素就可以了，这种算法的平均运行时间为 O(nlogn) ,说慢不慢，说快也不快。我们将在后面的内容里面介绍一种在线性时间 O(n) 内就可以完成选择的算法。

在进入正题内容之前,先来介绍几个术语:

  • 顺序统计量:第 k 个顺序统计量就是在含有n个元素的序列里面找到第 k 大的元素.比如最小值是第一个顺序统计量，最大值是第n个顺序统计量
  • 中位数:中位数顾名思义就是找到序列里面排序在中间的那个数。序列元素个数 n 为基数的话，中位数就是第(n+1)/2个顺序统计量，若为偶数，中位数就有两个,一个是下中位数 n/2 ,一个是上中位数 (n+2)/2

选择算法之选取最大数或最小数

选择一个序列里面的最大数或者是最小数是选择算法里面最简单的情形，即选择第一个顺序统计量或者选择最后一个顺序统计量。我们只要遍历一遍数组就可以选择出最大值或者最小值，运行时间为 Θ(n) ,可以在线性时间之内完成最大数/最小数的选取。

选取最大数或最小数代码实现

这里实现了选择数组里面最小值的代码，读者可以以此类推自己写出选择最大值的算法

/**
 * 找到最小的元素
 * @param  array     输入的数组
 * @param  arraySize 数组大小
 * @param  minNumber 输出最小值
 * @return           最小值在数组里面的位置
 */
int findMin(int array[] , int arraySize , int * minNumber)
{
    if(array == NULL || arraySize <= 0 || minNumber == NULL)
        return -1;
    int minPos = -1;
    int minNumberTemp=INT_MAX;
    for (int i = 0; i < arraySize; ++i)
    {
        if(array[i] < minNumberTemp)
        {
            minNumberTemp=array[i];
            minPos = i;
        }
    }
    *minNumber = minNumberTemp;
    return minPos;
}

运行结果：

input array is :
48 18 97 27 13 85 8 38 95 31
find the min number 8 at pos 7

我们从代码里面可以看出for循环运行n次，每次都要进行一次比较if(array[i] < minNumberTemp)，如果我们标记的最小值大于当前的数组元素，就重新标记当前数组元素为最小值。因为这个代码比较简单，这里不再赘述。

选择算法之选取最大数和最小数

条件改变，现在要选择一个序列里面的最大数和最小数，这里和上面讲述过的选择最大数或者最小数有所不同，上面的要做的只是选择最大值或者最小值，而现在我们要同时选择最大值和最小值。

博主第一次看见这个题目时，和只选择最小数的情形一对比，这不是一样的么，只要在循环里面多加一个最大数的比较不就行了？的确是可以，我们来看一下部分代码实现

选取最大数和最小数代码实现

/**
 * 找到最小的元素
 * @param  array     输入的数组
 * @param  arraySize 数组大小
 * @param  minNumber 输出最小值
 * @return           最小值在数组里面的位置
 */
MinMaxPair findMinMax(int array[] , int arraySize , int * minNumber , int * maxNumber)
{
    /** 省略了一些代码 */
    for (int i = 0; i < arraySize; ++i)
    {
        if(array[i] < minNumberTemp)
        {
            minNumberTemp=array[i];
            minPos = i;
        }
        if(array[i] > maxNumberTemp)
        {
            maxNumberTemp = array[i];
            maxPos = i;
        }
    }
    /** 省略了一些代码 */
}

这里在一个循环里面要进行两次比较，于是运行时间为 2n ,虽然也是线性时间里面完成选择，但是常数项的开销明显变多了不少

选取最大数和最小数代码优化

但是对于这个算法我们还是可以进行优化的，我们每次选出两个元素，首先对这两个元素进行对比，将其中小者与标记最小数进行比较，如果小者小于最小数，那么就替换最小数，将其中大者与最大数进行比较，如果大者大于最大数，就替换最大数，这样下来只需要循环 n/2 遍，每遍比较三次，于是运行时间为 3n/2 ,比没有优化之前的代码节省了25%的运行时间

/**
*记录最大值和最小值在数组里面的位置
*/
class MinMaxPair
{
public:
    MinMaxPair(int _minPos = -1 , int _maxPos = -1):minPos(_minPos),maxPos(_maxPos){}
    int minPos;// 最小值在数组里面得位置
    int maxPos;// 最大值在数组里面的位置
    bool operator==(const MinMaxPair & pair)
    {
        return (this->minPos == pair.minPos && this->maxPos == pair.maxPos);
    }
};  

/** 找到一个数组里面的最大值和最小值 */
MinMaxPair findMinMax(int array[] , int arraySize , int * minNumber , int * maxNumber)
{
    if(array == NULL || arraySize <= 0 || minNumber == NULL || maxNumber == NULL)
        return MinMaxPair();
    /** 奇数个元素设置，取出第一个元素作为初始的最大值和最小值 */
    int maxNumberTemp = array[0];
    int minNumberTemp = array[0];
    size_t maxPos=-1;
    size_t minPos=-1;
    int i = 1;
    if(arraySize%2 == 0)// 一共有偶数个元素，取出前两个元素，大的作为最大值的初始值，小的作为最小值的初始值
    {
        i=2;
        // 比较数组前两个元素
        maxNumberTemp = array[0];
        minNumberTemp = array[1];
        maxPos = 0;
        minPos = 1;
        if(array[0] < array[1])
        {
            maxNumberTemp = array[1];
            minNumberTemp = array[0];
            maxPos = 1;
            minPos = 0;
        }
    }
    for (; i < arraySize ; i+=2)
    {
        /** 每次取出两个元素 */
        int temp1 = array[i];
        int temp2 = array[i+1];
        int tempPos1 = i;
        int tempPos2 = i+1;
        /** 比较两个取出的元素 */
        if(array[i] > array[i+1])
        {
            temp1 = array[i+1];
            temp2 = array[i];
            tempPos1 = i+1;
            tempPos2 = i;
        }
        /** 将小者与标识的最小值比较 */
        if(minNumberTemp > temp1)
        {
            minNumberTemp = temp1;
            minPos = tempPos1;
        }

        /** 将大者与标识的最大值比较 */
        if(maxNumberTemp < temp2)
        {
            maxNumberTemp = temp2;
            maxPos = tempPos2;
        }
    }
    // 最后设置输出的元素
    *maxNumber = maxNumberTemp;
    *minNumber = minNumberTemp;
    return MinMaxPair(minPos , maxPos);
}

运行结果
input array is :
69 72 82 53 61 35 43 74 83 76
find the min number 35 at pos 6
find the max number 83 at pos 9

在上面的代码，如果输入数据的长度为奇数，我们就选取第一个元素作为最大值和最小值元素的初始值，并从数组的第二个元素开始每次选出两个元素；如果为偶数，那么取出前两个元素，大的作为最大值的初始值，小的作为最小值的初始值，并从第三个元素开始，每次取出两个元素

快速选择算法

之前讨论的选择最大数和最小数都属于比较极端的情况，要是现在需要选择一个序列里面的第 k 个顺序统计量呢，有什么比较快速的方法呢？首先想到的就是排序以后再选取啦。不过排序的平均运行时间为O(nlogn),相对于接下来介绍的快速选择算法是慢那么一个级别的。

快速选择算法分析

还记得之前讲过的快速排序_QUICKSORT么，快速选择算法就是运用了快速排序算法的思想,假设我们现在有一数组 A[left...right]
1. 首选在数组 A 里面选取一个主元M
2. 遍历一遍数组(从left到right)，将比主元 M 大的元素放在主元的右边,小于等于主元的元素放在主元的左边，此时主元在数组中的位置为i。于是主元 M 就是数组里面的第i个顺序统计量
3. 比较主元位置 i 和目标顺序统计量k，如果 i=k ,就直接返回主元 M ;如果k<i,就更新 right=i−1 ,转到动作(2)继续开始运行;如果 k>i ,那么就更新 left=i+1 , k=i−left ,转到动作(2)继续开始运行。

就这样我们可以找到第 k 个目标顺序统计量，该操作的期望运行时间为O(n)

快速选择算法编码实现

我们在这里采用两个方法来实现快速选择算法的实现，一个是迭代，一种是递归，两种算法实现的思想都一样，只是实现的方式不同而与

递归方式实现

/**
 * 找到数组里面第k大的元素
 * @param  array     输入的数组
 * @param  arraySize 数组大小
 * @param  kthNumber 第k大元素的大小         
 * @param  k         第k大的元素
 */
void randomizedSelect(int array[] , int arraySize , int * kthNumber , int k)
{
    if(array == NULL || arraySize <= 0 || kthNumber == NULL || k <0 || k >= arraySize)
        return;
    randomizedSelectKernel(array, 0 , arraySize-1 , kthNumber , k);
}


/**
 * 找到leftBorder到rightBorder中第k大的元素,递归函数
 * @param  array       输入的数组
 * @param  leftBorder  左边界
 * @param  rightBorder 右边界
 * @param  kthNumber   第k大的元素的实际值
 * @param  k           第k大的元素
 */
void randomizedSelectKernel(int array[], int leftBorder , int rightBorder ,int * kthNumber , int k)
{
    if(leftBorder > rightBorder)
        return ;
    // 这里采用快速排序的思想来完成
    int i = leftBorder-1;
    int j = leftBorder;
    int x = array[rightBorder];
    // 首先找到主元
    for(; j < rightBorder ; ++j)
    {
        if(array[j] <= x)
        {
            exchange(array , j , ++i);
        }
    }
    ++i;
    exchange(array , i , rightBorder);
    // 现在位置i就是需要放置主元的地方
    if(i == leftBorder+k-1)
        *kthNumber = array[i];
    else if(i > leftBorder+k-1)
        randomizedSelectKernel(array , leftBorder , i-1 , kthNumber , k);
    else if(i < leftBorder+k-1)
        randomizedSelectKernel(array , i+1, rightBorder , kthNumber , k-(i-leftBorder+1));
}

运行结果
input array is :
96 47 95 38 53 45 3 92 20 73
2th max number is———————- 20
3 20 45 38 47 53 73 92 96 95
1th max number is———————- 3
3 20 45 38 47 53 73 92 96 95
3th max number is———————- 38
3 20 38 45 47 53 73 92 96 95
6th max number is———————- 53
3 20 38 45 47 53 73 92 96 95

迭代方式实现

/**
 * 找到数组里面第k大的元素
 * @param  array     输入的数组
 * @param  arraySize 数组大小
 * @param  kthNumber 第k大元素的大小         
 * @param  k         第k大的元素
 */
void randomizedSelect(int array[] , int arraySize , int * kthNumber , int k)
{
    if(array == NULL || arraySize <= 0 || kthNumber == NULL || k <0 || k >= arraySize)
        return;
    int left = 0;
    int right = arraySize-1;
    int kTemp = k;
    while(left <= right)
    {
        // 采用快速排序的思想
        // 首先找到主元
        int i = left-1;
        int j = left; 
        int x = array[right];
        for(; j < right ; ++j)
        {
            if(array[j] <= x)
            {
                exchange(array , ++i , j);
            }
        }
        ++i;
        exchange(array , i , right);
        /** 现在位置i就是主元位置 */
        if(i == kTemp+left-1)// 找到第k大的元素
        {
            *kthNumber = array[i];
            return;
        }
        else if (i<kTemp+left-1)
        {
            kTemp = kTemp-(i-left+1);
            left = i+1;
        }
        else if(i > kTemp+left-1)
        {
            right = i-1;
        }
    }
}

运行结果:
input array is :
62 66 70 54 74 98 83 52 80 19
2th max number is———————- 52
19 52 54 62 74 98 83 70 80 66
1th max number is———————- 19
19 52 54 62 66 98 83 70 80 74
3th max number is———————- 54
19 52 54 62 66 98 83 70 80 74
6th max number is———————- 70
19 52 54 62 66 70 74 98 80 83

快速选择算法代码优化

细心的读者可能已经发现，我们在一遍一遍对一个数组进行选择的过程中，数据已经慢慢变的有序起来，我们一开始的输入数组为62 66 70 54 74 98 83 52 80 19,在进行了四遍选择以后，发现数组已经被更新为19 52 54 62 66 70 74 98 80 83,接近有序了。我们知道有序数组对于快速算法是致命的，如果不对快速算法做任何优化，那么快速算法将会达到最差运行时间 O(n2) ，因为有序的数据将会导致快速排序的分组极度不平衡。

快速选择算法里面也是一样的，应该避免输入有序数组导致的分组极度不平衡的情况，所以我们就做了下面的优化，在进行快速选择之前，首先从数组的头部，中部，尾部选出三个元素出来，找出这三个元素中第二大的元素，并与数组的最后一个元素进行交换，这样我们就可以避免分组极度不平衡的情况了，但是只是能保证避免分组极度不平衡的情况，还是有可能分组不平衡的,下面我们要讲解的BFPRT选择算法可以很好的做到平衡分组

我们在每次迭代或者递归进行之前加上下面的代码

/** 省略了好多代码 */
if(leftBorder > rightBorder)
        return ;
    // 这里采用快速排序的思想来完成
    // 为了避免最差的情况发生
    int mid=(leftBorder+rightBorder)/2;
    int midPos = rightBorder;
    // mid元素是第二大的
    if((array[leftBorder] > array[mid] && array[mid] > array[rightBorder]) ||\
    (array[leftBorder] < array[mid] && array[mid] < array[rightBorder]) )
        midPos = mid;
    // left元素是第二大的
    else if((array[mid] > array[leftBorder] && array[leftBorder] > array[rightBorder]) ||
            (array[mid] < array[leftBorder] && array[leftBorder] < array[rightBorder]) )
        midPos = leftBorder;
    if(midPos != rightBorder)
        exchange(array , midPos , rightBorder);

    int i = leftBorder-1;
    int j = leftBorder;
 /** 省略了好多代码 */

BFPRT选择算法

上面我们讲过，在快速排序算法里面如果主元选择的不合适，将会导致快速排序算法的分组极度不平衡，这样大大降低了快速选择算法的效率

1973 年，Blum、Floyd、Pratt、Rivest、Tarjan一起发布了一篇名为 “Time bounds for selection” 的论文，给出了一种在数组中选出第 k 大元素平均复杂度为O(n)的算法，俗称“中位数之中位数算法”。这个算法依靠一种精心设计的 pivot 选取方法，即选取中位数的中位数作为主元，从而保证了在最情况下的也能做到线性时间的复杂度，打败了平均 O(nlogn) 、最坏 O(n2) 复杂度的快速排序算法

BFPRT选择算法主元选择

其实这个算法的最精妙之处在于主元的寻找，该算法可以找到一个主元使得快速排序分组足够平衡

  1. 判断元素个数是否大于五个，如果是，就跳转到步骤(2)，否则就对数组进行排序，如果元素个数为奇数，就返回中位数，若为偶数，就返回下中位数
  2. 将数组进行分组，每组元素里面的元素各个均为五个，至多有一个数组的元素个数小于五个
  3. 将每组元素进行插入排序(元素个数较少的情况下，插入排序性能还是不错的)
  4. 把每一组里面的中位数取出来，就是五个元素里面的第三个；对于不满五个元素的组，如果元素个数为奇数，就取中位数，若为偶数，就取下中位数
  5. 对取出来的中位数组成一个新的数组，并转到步骤(1),开始对取出来的中位数数组取中位数

Alt text
上图中有五个个数为五的组和一个个数为三的组，白色空心点表示每一组的中位数，元素x表示每一组中位数里面的中位数，并且箭头从较大的元素指向较小的元素。

BFPRT选择算法性能分析

每组五个元素，我们对数组进行分组最后会得到 n/5 个组。，除去不满五个元素和包括主元 x 的组，至少有3×(n5−2)≥3n10−6个元素是大于 x 的，类似的，至少有3n10−6个元素小于 x 的，于是在每次分组中，两个组最不平衡的情况的也就是7:3,于是得到递归式,这里140是随便选取的一个常数

T(n)={O(1)T(n5)+T(7n10+6)+O(n),n<140,n≥140

计算上式可以得知运行时间为 O(n)

BFPRT选择算法代码实现

/**
 * 找到数组中的中位数
 * @param  array       输入的数组
 * @param  lefyBorder  数组左边界
 * @param  rightBorder 数组右边界
    const int & arraySize = rightBorder - leftBorder+1;
 * @return             中位数的坐标
 */
int BFPRT(int array[] , int leftBorder , int rightBorder)
{
    if(array == NULL || leftBorder > rightBorder )
        return -1;
    const int & arraySize = rightBorder - leftBorder +1;
    // 判断元素的个数是否大于五个
    if(arraySize <= 5)
    {
        insertSort(array , arraySize);
        return leftBorder+arraySize/2;
    }
    // 如果元素个数大于五个，那么就五五分组
    const int & groupSize = 5;
    int * groupStart=array;
    int midCount=0;
    for (int i = leftBorder+groupSize; i <= rightBorder; i+=groupSize)
    {
        insertSort(groupStart , groupSize);
        exchange(array , leftBorder+midCount , i-3 );//将中位数放在数组的最前面
        ++midCount;
        groupStart+=groupSize;
    }
    // 剩下的不满五个进行排序
    if(arraySize%groupSize != 0)
    {
        insertSort(groupStart , arraySize%groupSize);
        exchange(array , leftBorder+midCount ,leftBorder + arraySize - arraySize%groupSize + (arraySize%groupSize - 1)/2);
        ++midCount;
    }
    // 现在新选出来的所有中位数都在前midCount里面
    // 返回中位数的中位数
    return BFPRT(array , leftBorder , leftBorder+midCount-1);
}

/**
 * 选择第K大的元素
 * @param array       输入的数组
 * @param leftBorder  左边界
 * @param rightBorder 右边界
 * @param k           第k个
 * @param kthNumber   第k大的数
 */
void BFPRTselect(int array[] , int leftBorder , int rightBorder ,int k ,  int * kthNumber)
{
    if(array == NULL || leftBorder > rightBorder || kthNumber == NULL || k >(rightBorder - leftBorder + 1))
        return ;
    /** 选取主元 */
    int index = BFPRT(array , leftBorder , rightBorder);
    if(index == -1)
        return;
    cout<<"lefy--->"<<leftBorder<<" right--->"<<rightBorder<<" index:"<<index<<" midNumber :"<<array[index]<<endl;
    exchange(array , index , rightBorder);
    int i = leftBorder-1;
    int j = leftBorder;
    int x = array[rightBorder];

    for(; j < rightBorder ; ++j)
    {
        if(array[j] <= x)
        {
            exchange(array , ++i , j);
        }
    }
    ++i;
    exchange(array , i , rightBorder);
    if(i == leftBorder+k-1 )
    {
        *kthNumber = array[i];
        return ;
    }
    else if(i < leftBorder+k-1)
    {
        BFPRTselect(array , i+1 ,rightBorder , k-(i - leftBorder+1) , kthNumber);
    }
    else if(i > leftBorder+k-1)
    {
        BFPRTselect(array , leftBorder , i-1 , k , kthNumber);
    }
}

运行结果:
before sort the array:
75 84 30 35 77 60 75 32 64 2
lefy—>0 right—>9 index:0 midNumber :75
lefy—>0 right—>6 index:1 midNumber :32
lefy—>0 right—>1 index:1 midNumber :30
2th max number is———————- 30

2 30 32 60 75 64 35 75 84 77
lefy—>0 right—>9 index:0 midNumber :32
lefy—>0 right—>1 index:1 midNumber :2
1th max number is———————- 2

2 30 32 60 75 64 35 75 84 77
lefy—>0 right—>9 index:0 midNumber :32
3th max number is———————- 32

30 2 32 60 75 64 35 75 84 77
lefy—>0 right—>9 index:0 midNumber :32
lefy—>3 right—>9 index:4 midNumber :84
lefy—>3 right—>8 index:4 midNumber :75
lefy—>3 right—>6 index:5 midNumber :35
lefy—>4 right—>6 index:5 midNumber :75
lefy—>4 right—>5 index:5 midNumber :60
lefy—>5 right—>5 index:5 midNumber :64
6th max number is———————- 64
2 30 32 35 60 64 75 75 77 84

after sort the array:
2 30 32 35 60 64 75 75 77 84

注：本文中的所有代码都在这里

qeesung
关注
  • 12
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法总结java
05-13
java算法总结
活动选择问题的贪心算法
04-23
活动选择问题的C#实现 S:1,3,0,5,3,5,6,8,8,2,12 f:4,5,6,7,9,9,10,11,12,14,16 以上是测试数据
快速选择算法与快速排序算法
最新发布
qq_56740121的博客
07-15 332
快速排序算法，时间复杂度为O(n log n)，最坏的情况是O(n^2)。实现思想：选择一个基准元素，将数组分成两部分：比基准元素小的元素和比基准元素大的元素。小的元素，它通过分治的方式，在每次分区后只递归地处理包含目标元素的那一半数组。1. 选择基准元素，可以是第一个元素、最后一个元素、中间元素，或者随机选择。2. 设定两个指针，左指针指向数组的起始位置，右指针指向数组的结束位置，移动这两个指针，将数组分成两部分。使用两个指针，left 指向数组的起始位置，right 指向数组的末尾位置。
“选择算法”
lxiaoxiaot的专栏
08-13 7828
翻译自维基百科：http://en.wikipedia.org/wiki/Selection_algorithm         在计算机科学里，选择算法（selection algorithm）是一种用于在一个列表中查找第K小的数的算法（这个数也被称之为第K个顺序统计量）。这
选择算法
yangwenxiao123456的博客
07-17 860
选择算法是一种排序算法 它是将无序组的最值取出放在有序组的后面，即无序组的第一位 1、遍历数据 2、找到无序组的最值（监哨值法） 3、将最值与无序组第一位交换位置 代码如下： ...
5分钟搞定快速选择算法
菜籽爱编程
05-26 1523
快速选择思想 快速选择思想源于快速排序，但我们只进行部分快速排序，只要找到我们要的位置上的元素，排序就不再进行下去。快速选择的方法跟快速排序基本一致，差别在于我们有给定要找的元素位置，在排序基准值时，把基准值的位置和我们要找的位置进行比较。如果我们要找小于基准值位置的元素，便缩小至左子区间继续查找；如果我们要找大于基准值位置的元素，便缩小至右子区间继续查找。 一个例子让你掌握快速选择 我们给定一个数组，假设要找排完序后数组的第3个位置上元素的值。我们定义临时变量temp存放基准值，定义左标志位定位至数组第一
选择问题的算法（详细分析）
xiaobai_qian的博客
05-31 3977
根据 北京大学 屈婉玲老师的 MOOC视频记录来写。
天线选择算法总结.zip_VSTZ_bridgeetu_天线选择 穷_天线选择算法_穷举法MIMO
07-14
MIMO天线选择算法中，基于最优选择算法和范数选择算法和随机选择算法的程序，能够简化硬件结构，降低通信算法的复杂度，提高通信的可靠性。穷举法，递减，递增等。
算法总结 .zip
12-13
本压缩包文件"算法总结 .zip"显然是一个关于算法学习和总结的资源集合，可能包含了各种算法的讲解、示例和实践应用。以下是针对算法这个主题的一些详细知识点： 1. **排序算法**： - 冒泡排序：最简单的排序算法之...
贪心算法总结
11-27
### 贪心算法总结 #### 一、贪心算法定义及原理 **定义：** 贪心算法是一种在解决问题时始终作出当前看来最优选择的算法。这种方法并不保证总是能够找到全局最优解，而是追求每一步的局部最优解，希望能够通过一...
聚类算法总结
10-24
总结，聚类算法是数据挖掘的重要工具，适用于各种领域，但选择合适的聚类方法需考虑数据特性、应用场景及目标需求。通过深入理解并灵活运用这些算法，我们可以更好地揭示隐藏在大量数据背后的模式和规律。
Java中的经典算法之选择排序（SelectionSort）
weixin_34185512的博客
04-23 158
Java中的经典算法之选择排序（SelectionSort） 神话丿小王子的博客主页 a)原理：每一趟从待排序的记录中选出最小的元素，顺序放在已排好序的序列最后，直到全部记录排序完毕。也就是：每一趟在n-i+1(i=1，2，…n-1)个记录中选取关键字最小的记录作为有序序列中第i个记录。基于此思想的算法主要有简单选择排序、树型选择排序和堆排序。（这里只介绍常用的简单选择排序） b)简单选...
选择排序算法
生活需要深度
06-29 1881
本章介绍排序算法中的选择排序。目录 1. 选择排序介绍 2. 选择排序图文说明 3. 选择排序的时间复杂度和稳定性 4. 选择排序实现 4.1 选择排序C实现 4.2 选择排序C++实现 4.3 选择排序Java实现转载请注明出处：选择排序 - 如果天空不死 - 博客园更多内容：数据结构与算法系列 目录选择排序(Selection sort)是一种简单直观的排序算法。 它的基本思想是：首先在未排序的数列中找到最小(or最大)元素，然后将其存放到数列的起始位置；接着，再从剩余未排序的元素中继续寻找最小(or最
选择算法(顺序统计量)
ocfbnj的博客
04-04 1373
代码如下，具体思路请参考《算法导论》 #include <iterator> template <typename RanIt> inline RanIt partition(RanIt first, RanIt last) { if (first == last) return first; --last; // pivot RanIt it = first; ...
常用特征选取算法（转载）
数据分析经验积累
08-01 772
今天正好进行特征选择相关的工作，看到一篇总结详细的攻略，与各位分享~ 原文链接：https://www.cnblogs.com/wymlnn/p/4569437.html 特征选取的功能 特征选取是机器学习建模前的常见步骤，主要有两个功能： （1）减少特征数量、降维，使模型泛化能力更强，减少过拟合 （2）增强度特征和特征值之间的理解 常用的特征选取方法 一、去掉取值变化小的特征 考察某个特征下，样...
快速选择算法
热门推荐
qq_40692109的博客
10-23 1万+
简介 在构造kd-tree中，我们需要对方差最大维度上的中位数进行计算。中位数计算方法的好坏一定程度上影响了树的构造时间。要计算中位数，我们一般想到的是将数据进行排序，然后取中间的数。排序算法最快的时间复杂度为O（nlogn）。但是实际上我们要求中位数，不需要将所有数据进行排序，有的排序步骤是无用的。所以有了选择算法，其平均时间复杂度为O（n），最坏时间复杂度为O（n2）。在Rob Hess 的s...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值