Python 中间值求TopK算法 
算法思想
以下以找出TopK 的最大值为例，最小值的可以自己修改一下下就可以
重点就是找出这个中间值
如何找出中间值
结合代码和注释看

算法思想
首先我们要思考，我要做什么？解决什么问题？

TopK问题，找出一组数据中的前K个最大值或者最小值，这个数据是否重复？要做去重处理？

ok 我们明确我们做什么了 ，那介绍的python处理的topK 算法过程是怎么样的呢？

~~要找出前K个最大值最小值我们可以用排序来做，然后用切片去完事了 ~~ 如果用排序那就没必要引入topK 了，当数据强大的时候选取TopK 可以省略很多排序的计算，至于有多优化自己去思考下，就比如排列组合的C，A的区别，一个是抽取，一个是抽取并排列…
以下以找出TopK 的最大值为例，最小值的可以自己修改一下下就可以
介绍的算法思想是利用中间值，将数列分为三部分 ，

【比中间值大的列表】，中间值，【比中间值小的列表】
那么我们当比较

【比中间值大的列表】的个数 == k

的时候就可以得出前K个最大值了，因此
重点就是找出这个中间值
如何找出中间值
以列表的第一个数开始为中间值，拆分为三部分

if  【比中间值大的列表】的个数 == k：return 中间值  #程序出口，结束。
if    【比中间值大的列表】的个数 < k ：

·····继续在【比中间值小的列表】找

·····K - 【比中间值大的列表】的个数 -1 个数

（为什么要减一，1是前一次的中间值，分的三部分，前部分后部分都没有包含中间值，因此…）

if    【比中间值大的列表】的个数 > k ：

…也就是说比中间值大的列表比K还大，那就在这个列表中继续找就行
结合代码和注释看
，如果要找最小值，只需要改一下就ok ,还可以设置一个布尔值的输入，来做前K个最大值最小值
#2019 11 04
#author 半斤地瓜烧
#TopK 算法，找出序列中前K个最大值的

#输入一个seq
# 输出以seq[0]为中间值 划分的三个部分，中间值，比这个值大的seq ,比这个值小的seq，
# 即splitNum,theBig,theSmall
def Split_Seq(seq):
    splitNum = seq[0]
    seq = seq[1:]#两个部分都不包含中间值，因此切片去除seq[0]
    theBig = [x for x in seq if x >= splitNum]
    theSmall = [x for x in seq if x < splitNum]
    return splitNum,theBig,theSmall

#找出中间值
def topKNum(seq,k):
    splitNum, theBig, theSmall = Split_Seq(seq)
    theBigLen = len(theBig)
    
    if  k == theBigLen:
        return splitNum#出口,返回这个中间值,
    # 为什么不直接返回thebig?因为存在递归的原因thebig 不是在初始的seq找出来的
    #需要重新Split,即可，读者自己思考

    # 大值的列表中还未够K个数的情况，
    if k > theBigLen:
        return topKNum(theSmall,k-theBigLen-1)

    # 大值的列表中大于K个数的情况
    return topKNum(theBig,k)

#由中间值找出TopK个值，<list>
def getTopK(seq,k):
    
    return [i for i in seq if i > topKNum(seq, k)]


if __name__ == '__main__':
    alist = [7, 3, 5, 1,885,234,2211,222,22, 2, 11, 2, 115]
    print("===为了验证，引入排序观看===", sorted(alist,reverse= True))

    print(getTopK(alist, 3))

怎么用一个宏来求三个数值的中间值呢？请看：
#include <stdio.h>

#define MIDDLE(x,y,z) \
((x)<(y)?((y)<(z)?(y):(x)<(z)?(z):(x)):((y)>(z)?(y):(x)>(z)?(z):(x)))

int main(void)
{
    printf("MIDDLE(%d,%d,%d) = %d\r\n", 1,2,3,MIDDLE(1,2,3));
    printf("MIDDLE(%d,%d,%d) = %d\r\n", 2,1,3,MIDDLE(2,1,3));
    printf("MIDDLE(%d,%d,%d) = %d\r\n", 1,3,2,MIDDLE(1,3,2));
    printf("MIDDLE(%d,%d,%d) = %d\r\n", -1,-2,-3,MIDDLE(-1,-2,-3));
    printf("MIDDLE(%d,%d,%d) = %d\r\n", -2,-1,-3,MIDDLE(-2,-1,-3));
    printf("MIDDLE(%d,%d,%d) = %d\r\n", -1,-3,-2,MIDDLE(-1,-3,-2));
    printf("MIDDLE(%f,%f,%f) = %f\r\n", 1.1,2.4,3.5,MIDDLE(1.1,2.4,3.5));
    printf("MIDDLE(%f,%f,%f) = %f\r\n", 1.1,3.3,2.4,MIDDLE(1.1,3.3,2.4));
    printf("MIDDLE(%f,%f,%f) = %f\r\n", 2.4,1.1,3.3,MIDDLE(2.4,1.1,3.3));
    
    return 0;
}

可见结果均正确！

有时候做项目的时候，需要动态的计算两颜色值之间的中间值，然后做出一定的效果，那么该怎么求呢？
 下面说说做法：
简单而言，就是需要对两颜色之间的求和再取平均值，但是直接使用color.parseInt再求和除2是不对的，因为直接求和会导致颜色不对，具体原因出自相加求和颜色退位。
那么，该如何算呢，贴下代码：

public static String getMiddleColor(String color1, String color2) {
    if (color1.contains("#") && color2.contains("#") && color1.length() == color2.length() && color2.length() == 7) {
        String tempColor1 = color1.replace("#", "");
        String tempColor2 = color2.replace("#", "");
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("#");
        for (int i = 0; i < tempColor1.length(); i++) {
            String tempResult = (changeHex2Int(String.valueOf(tempColor1.charAt(i)))
                    + changeHex2Int(String.valueOf(tempColor2.charAt(i)))) / 2 + "";
            stringBuffer.append(changeInt2Hex(tempResult));
        }
        return stringBuffer.toString();
    }
    return "";
}
简单的说就是根据6位的颜色直接逐个逐个的求和再除二，那么这个颜色值就是对的了。


private static int changeHex2Int(String temp) {
    BigInteger srch = new BigInteger(temp, 16);
    return Integer.valueOf(srch.toString());
}

private static String changeInt2Hex(String temp) {
    BigInteger srch = new BigInteger(temp, 10);
    return Integer.toHexString(Integer.parseInt(srch.toString()));
}
如此一来，就能实现一个比较困难的需求，用曲线救国的方式实现我们的功能要求了。

感谢你的浏览。

设立两个指针，比如*p和*q,p每次移动一个位置，q每次移动两个位置，q到达最后一个节点时，p到达中间节点