堆排序是啥

Posted 2023-05-16

【概念】堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆，是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值，即A[PARENT[i]]
>=
A[i]。在数组的非降序排序中，需要使用的就是大根堆，因为根据大根堆的要求可知，最大的值一定在堆顶。
【起源】
1991年的计算机先驱奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德(Robert
W．Floyd）和威廉姆斯(J．Williams）在1964年共同发明了著名的堆排序算法（
Heap
Sort
)。
【简介】
堆排序利用了大根堆（或小根堆）堆顶记录的关键字最大（或最小）这一特征，使得在当前无序区中选取最大（或最小）关键字的记录变得简单。
（1）用大根堆排序的基本思想
①
先将初始文件R[1..n]建成一个大根堆，此堆为初始的无序区
②
再将关键字最大的记录R[1]（即堆顶）和无序区的最后一个记录R[n]交换，由此得到新的无序区R[1..n-1]和有序区R[n]，且满足R[1..n-1].keys≤R[n].key
③由于交换后新的根R[1]可能违反堆性质，故应将当前无序区R[1..n-1]调整为堆。然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换，由此得到新的无序区R[1..n-2]和有序区R[n-1..n]，且仍满足关系R[1..n-2].keys≤R[n-1..n].keys，同样要将R[1..n-2]调整为堆。
……
直到无序区只有一个元素为止。
（2）大根堆排序算法的基本操作：
①建堆，建堆是不断调整堆的过程，从len/2处开始调整，一直到第一个节点，此处len是堆中元素的个数。建堆的过程是线性的过程，从len/2到0处一直调用调整堆的过程，相当于o(h1)+o(h2)…+o(hlen/2)
其中h表示节点的深度，len/2表示节点的个数，这是一个求和的过程，结果是线性的O(n)。
②调整堆：调整堆在构建堆的过程中会用到，而且在堆排序过程中也会用到。利用的思想是比较节点i和它的孩子节点left(i),right(i)，选出三者最大(或者最小)者，如果最大（小）值不是节点i而是它的一个孩子节点，那边交互节点i和该节点，然后再调用调整堆过程，这是一个递归的过程。调整堆的过程时间复杂度与堆的深度有关系，是lgn的操作，因为是沿着深度方向进行调整的。
③堆排序：堆排序是利用上面的两个过程来进行的。首先是根据元素构建堆。然后将堆的根节点取出(一般是与最后一个节点进行交换)，将前面len-1个节点继续进行堆调整的过程，然后再将根节点取出，这样一直到所有节点都取出。堆排序过程的时间复杂度是O(nlgn)。因为建堆的时间复杂度是O(n)（调用一次）；调整堆的时间复杂度是lgn，调用了n-1次，所以堆排序的时间复杂度是O(nlgn)[2]
注意：
①只需做n-1趟排序，选出较大的n-1个关键字即可以使得文件递增有序。
②用小根堆排序与利用大根堆类似，只不过其排序结果是递减有序的。堆排序和直接选择排序相反：在任何时刻堆排序中无序区总是在有序区之前，且有序区是在原向量的尾部由后往前逐步扩大至整个向量为止
【特点】
堆排序（HeapSort）是一树形选择排序。堆排序的特点是：在排序过程中，将R[l..n]看成是一棵完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系（参见二叉树的顺序存储结构），在当前无序区中选择关键字最大（或最小）的记录
【算法分析】
堆排序的时间，主要由建立初始堆和反复重建堆这两部分的时间开销构成，它们均是通过调用Heapify实现的。
平均性能：O(N*logN)。
其他性能：由于建初始堆所需的比较次数较多，所以堆排序不适宜于记录数较少的文件。堆排序是就地排序，辅助空间为O(1）。它是不稳定的排序方法。（排序的稳定性是指如果在排序的序列中，存在前后相同的两个元素的话，排序前
和排序后他们的相对位置不发生变化）。 参考技术A 堆排序（HeapSort）是一树形选择排序。堆排序的特点是：在排序过程中，将R[l..n]看成是一棵完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系（参见二叉树的顺序存储结构），在当前无序区中选择关键字最大（或最小）的记录
其过程为：
（1）用大根堆排序的基本思想

① 先将初始文件R[1..n]建成一个大根堆，此堆为初始的无序区

②
再将关键字最大的记录R[1]（即堆顶）和无序区的最后一个记录R[n]交换，由此得到新的无序区R[1..n-1]和有序区R[n]，且满足R[1..n-1].keys≤R[n].key

③由于交换后新的根R[1]可能违反堆性质，故应将当前无序区R[1..n-1]调整为堆。然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换，由此得到新的无序区R[1..n-2]和有序区R[n-1..n]，且仍满足关系R[1..n-2].keys≤R[n-1..n].keys，同样要将R[1..n-2]调整为堆。

……

直到无序区只有一个元素为止。

（2）大根堆排序算法的基本操作：

① 初始化操作：将R[1..n]构造为初始堆；

②
每一趟排序的基本操作：将当前无序区的堆顶记录R[1]和该区间的最后一个记录交换，然后将新的无序区调整为堆（亦称重建堆）。

注意：

①只需做n-1趟排序，选出较大的n-1个关键字即可以使得文件递增有序。

②用小根堆排序与利用大根堆类似，只不过其排序结果是递减有序的。堆排序和直接选择排序相反：在任何时刻堆排序中无序区总是在有序区之前，且有序区是在原向量的尾部由后往前逐步扩大至整个向量为止 参考技术B 堆排序就是利用堆的数据结构进行排序，通过调整堆的结构使得关键字有一定的顺序。有最大堆和最小堆，堆排序在类似topK问题中经常应用，效率比其他内部排序算法高。 参考技术C 堆排序
1、
堆的定义
堆是一个含有n个关键字k1,k2,…,kn的序列，且具有如下特性：
ki<=k2i
且
ki<=k2i+1
(1<=i<=n/2)
(1)
或
ki>=k2i
且
ki>=k2i+1
(1<=i<=n/2)
(2)
ki>=k2i
满足式（1）的称为极小化堆，或极小堆，或小堆，满足式（2）的称为极大化堆，或极大堆，或大堆。本节以极小化堆为例子进行讲解。
堆与完全二叉树的关系：堆是n个元素（关键字）的序列，满足完全二叉树顺序存储中结点间的关系（双亲与子女序号间的关系）。
17，28，51，33，62，96，87，51
是小顶堆
96，51，87，33，28，62，51，17
是大顶堆
二叉堆
2、
堆排序的基本问题
既然堆顶元素（关键字）是最小元素，所以它是排序序列的最小元素，输出后，将其它元素再调整成堆，新的堆顶元素是排序序列的第二个元素。如此下去，通过堆，可将一个无序序列变为一个有序序列。因此，堆排序的基本问题是：
（1）
如何建堆
（2）
如何调堆
3、
如何调堆
将最后一个元素和堆顶元素交换（相当将堆顶元素输出）后，这时，从堆顶到倒数第二元素，除堆顶元素外，其余元素均符合堆的定义。下面采用筛选法，把包括堆顶元素在内的所有元素调成堆。大堆根
void
Sift(RecType
R[]，int
i，int
m)

‖假设R[i+1..m]中各元素满足堆的定义，本算法调整R[i]使序列
‖R[i..m]中各元素满足堆的性质
R[0]=R[i];
‖暂存“根”记录R[i]
for(j=2*i;
j<=m;
j*=2)
‖j<=m时，R[2i]是R[i]的左孩子

if(j<m
&&
R[j].key<R[j+l].key)
j++;
‖若R[i]的右孩子存在，且关键字大于左孩子，j指向R[i]的右孩子
if(R[0].key<R[j].key)
‖孩子结点关键字较大

R[i]=R[j];
‖将R[j]换到双亲位置上
i=j;
‖修改当前被调整结点

else
break;
‖调整完毕，退出循环
‖for
R[i]=R[0];
‖最初被调整结点放入正确位置
‖Sift
4、
如何建堆
具有n个结点的完全二叉树，其叶子结点被认为符合堆的定义，其最后一个非终端结点的编号是n/2，若从该结点开始，直到根结点，依次调用上面的筛选法，则可完成堆的建立。具体算法放在下面堆排序算法中。
5、
堆排序算法
void
HeapSort(RecType
R[]，int
n)

‖对记录序列R[1..n]进行堆排序。
for(i=n/2;i>0;i--)
‖把R[1..n]建成大顶堆
Sift(R,i,n);
for(i=n;i>1;i--)

‖将堆顶记录和当前未经排序子序列R[1..i]中最后一个记录相互交换
R[1]←→R[i];
Sift(R,1,i-1);
‖将R[1..i-1]重新调整为大顶堆
‖for
‖HeapSort
6、
堆排序算法分析
时间复杂度为O（nlogn），只需要一个记录大小供交换用的辅助存储空间。 参考技术D 堆排序
1、 堆的定义
堆是一个含有n个关键字k1,k2,…,kn的序列，且具有如下特性：
ki<=k2i
且 ki<=k2i+1 (1<=i<=n/2) (1)
或
ki>=k2i
且 ki>=k2i+1 (1<=i<=n/2) (2)
ki>=k2i
满足式（1）的称为极小化堆，或极小堆，或小堆，满足式（2）的称为极大化堆，或极大堆，或大堆。本节以极小化堆为例子进行讲解。
堆与完全二叉树的关系：堆是n个元素（关键字）的序列，满足完全二叉树顺序存储中结点间的关系（双亲与子女序号间的关系）。
17，28，51，33，62，96，87，51 是小顶堆
96，51，87，33，28，62，51，17 是大顶堆

二叉堆
2、 堆排序的基本问题
既然堆顶元素（关键字）是最小元素，所以它是排序序列的最小元素，输出后，将其它元素再调整成堆，新的堆顶元素是排序序列的第二个元素。如此下去，通过堆，可将一个无序序列变为一个有序序列。因此，堆排序的基本问题是：
（1） 如何建堆
（2） 如何调堆
3、 如何调堆
将最后一个元素和堆顶元素交换（相当将堆顶元素输出）后，这时，从堆顶到倒数第二元素，除堆顶元素外，其余元素均符合堆的定义。下面采用筛选法，把包括堆顶元素在内的所有元素调成堆。大堆根
void Sift(RecType R[]，int i，int m)
‖假设R[i+1..m]中各元素满足堆的定义，本算法调整R[i]使序列
‖R[i..m]中各元素满足堆的性质
R[0]=R[i]; ‖暂存“根”记录R[i]
for(j=2*i; j<=m; j*=2) ‖j<=m时，R[2i]是R[i]的左孩子
if(j<m && R[j].key<R[j+l].key) j++;
‖若R[i]的右孩子存在，且关键字大于左孩子，j指向R[i]的右孩子
if(R[0].key<R[j].key) ‖孩子结点关键字较大
R[i]=R[j]; ‖将R[j]换到双亲位置上
i=j; ‖修改当前被调整结点

else break; ‖调整完毕，退出循环
‖for
R[i]=R[0]; ‖最初被调整结点放入正确位置
‖Sift

4、 如何建堆
具有n个结点的完全二叉树，其叶子结点被认为符合堆的定义，其最后一个非终端结点的编号是n/2，若从该结点开始，直到根结点，依次调用上面的筛选法，则可完成堆的建立。具体算法放在下面堆排序算法中。
5、 堆排序算法
void HeapSort(RecType R[]，int n)
‖对记录序列R[1..n]进行堆排序。
for(i=n/2;i>0;i--) ‖把R[1..n]建成大顶堆
Sift(R,i,n);
for(i=n;i>1;i--)
‖将堆顶记录和当前未经排序子序列R[1..i]中最后一个记录相互交换
R[1]←→R[i];
Sift(R,1,i-1); ‖将R[1..i-1]重新调整为大顶堆
‖for
‖HeapSort
6、 堆排序算法分析
时间复杂度为O（nlogn），只需要一个记录大小供交换用的辅助存储空间。

参考资料：http://zhidao.baidu.com/question/202404050.html

按 5 星评级排序的更好方法是啥？

【中文标题】按 5 星评级排序的更好方法是啥？

【英文标题】：What is a better way to sort by a 5 star rating?按 5 星评级排序的更好方法是什么？

【发布时间】：2010-11-27 12:38:43

【问题描述】：

我正在尝试使用 5 星系统按客户评分对一堆产品进行分类。我为其设置的网站没有很多评分，并且会继续添加新产品，因此通常会有一些评分较低的产品。

我尝试使用平均星级评分，但当评分数量较少时，该算法会失败。

例如，具有 3x 5 星评级的产品会比具有 100x 5 星评级和 2x 2 星评级的产品显示得更好。

第二个产品是否应该显示得更高，因为它在统计上更值得信赖，因为评级数量更多？

【参考方案1】：

在 2015 年之前，互联网电影数据库 (IMDb) 公开列出了用于对其Top 250 电影列表进行排名的公式。引用：

Top Rated 250 Titles 的计算公式给出了真正的贝叶斯估计：

weighted rating (WR) = (v ÷ (v+m)) × R + (m ÷ (v+m)) × C

地点：

R = 电影的平均值（平均值） v = 电影票数 m = 进入前 250 名所需的最低票数（目前为 25000） C = 整个报告的平均投票数（目前为 7.0）

对于前 250 名，仅考虑普通选民的投票。

这并不难理解。公式为：

rating = (v / (v + m)) * R +
         (m / (v + m)) * C;

数学上可以简化为：

rating = (R * v + C * m) / (v + m);

变量是：

R – 物品自己的等级。 R 是项目投票的平均值。 （例如，如果一个项目没有投票，它的 R 为 0。如果有人给它 5 星，R 变为 5。如果有人给它 1 星，R 变为 3，[1, 5] 的平均值。以此类推。 ) C – 平均项目评级。找出数据库中每一项的R，包括当前一项，取它们的平均值；即 C。（假设数据库中有 4 个项目，它们的评分为 [2, 3, 5, 5]。C 是 3.75，这些数字的平均值。） v – 项目的投票数。 （再举一个例子，如果有 5 个人对一个项目投了票，v 是 5。） m – 可调参数。应用于评级的“平滑”量基于与 m 相关的票数 (v)。调整 m 直到结果让你满意。并且不要将 IMDb 对 m 的描述误解为“需要列出的最低投票数”——这个系统完全有能力对投票数少于 m 的项目进行排名。

公式所做的只是：在计算平均值之前添加 m 个假想票，每个票的值为 C。一开始，当没有足够的数据（即投票数大大少于m）时，这会导致空白被平均数据填充。然而，随着票数的积累，最终虚构的票数会被真实票数淹没。

在这个系统中，投票不会导致评分大幅波动。相反，他们只是在某个方向上稍微扰乱了它。

当票数为零时，只有虚构票数，并且都是C。因此，每个项目都以C开头。

另见：

demo。点击“解决”。 IMDb 系统的另一个explanation。 类似贝叶斯星级系统的explanation。

【讨论】：

引用的 wiki 答案文章表明公式是 WR = (v * R + m * C) / (v + m)，因为考虑到 C 并且值 I'我看起来好多了。

公式其实是一样的，你一定要把原来的那个填错了，(v/(v+m))*R+(m/(v+m))*C就是与 (v * R + m * C) / (v + m) 相同。链接：goo.gl/IW9s1A

如果我做得对，我认为 5 分的 1 票大于 4 分的 5 票。而且不适合排名系统

对于简单的答案，只需将like 与like 进行比较，即比较相应的 5 星评级。所以在您的示例中，具有 100x 5 星评级的产品优于具有 3x 5 星评级的产品。

【参考方案2】：

Evan Miller shows 一种贝叶斯方法来排名 5 星评级：

在哪里

nk 是k-星级评分的数量， sk 是 k 星星的“价值”（以点为单位）， N 是总票数 K 是最大星数（例如 K=5，在 5 星评级系统中） z_alpha/2 是正态分布的 1 - alpha/2 分位数。如果您希望 95% 的置信度（基于贝叶斯后验分布）实际排序标准至少与计算的排序标准一样大，请选择 z_alpha/2 = 1.65。

在Python中，排序标准可以用

def starsort(ns):
    """
    http://www.evanmiller.org/ranking-items-with-star-ratings.html
    """
    N = sum(ns)
    K = len(ns)
    s = list(range(K,0,-1))
    s2 = [sk**2 for sk in s]
    z = 1.65
    def f(s, ns):
        N = sum(ns)
        K = len(ns)
        return sum(sk*(nk+1) for sk, nk in zip(s,ns)) / (N+K)
    fsns = f(s, ns)
    return fsns - z*math.sqrt((f(s2, ns)- fsns**2)/(N+K+1))

例如，如果一件商品有 60 颗五星、80 颗四星、75 颗三星、20 颗二星和 25 颗一星，那么它的总星级大约是 3.4：

x = (60, 80, 75, 20, 25)
starsort(x)
# 3.3686975120774694

您可以使用

对 5 星评级列表进行排序

sorted([(60, 80, 75, 20, 25), (10,0,0,0,0), (5,0,0,0,0)], key=starsort, reverse=True)
# [(10, 0, 0, 0, 0), (60, 80, 75, 20, 25), (5, 0, 0, 0, 0)]

这显示了更多评分对整体星级值的影响。

---

你会发现这个公式往往会给出一个有点 低于亚马逊、Ebay 或沃尔玛等网站报告的总体评级 特别是当票数很少（比如说，小于300）时。这反映了 更少的选票带来更高的不确定性。随着票数的增加 （成千）所有这些评级公式总体上应该倾向于 （加权）平均评分。

---

由于该公式仅取决于 5 星评级的频率分布 对于商品本身，很容易合并来自多个来源的评论（或者， 更新根据新投票的总体评分）只需添加频率 一起分发。

---

与IMDb公式不同，这个公式不依赖于平均分 跨越所有项目，也没有人为的最低投票数截止值。

此外，这个公式利用了完整的频率分布——不仅仅是 平均星数和票数。这是有道理的 应该因为一个有 10 个 5 星和 10 个 1 星的项目应该被视为 比具有更多不确定性的项目（因此没有被评为高） 20 个 3 星评级：

In [78]: starsort((10,0,0,0,10))
Out[78]: 2.386028063783418

In [79]: starsort((0,0,20,0,0))
Out[79]: 2.795342687927806

IMDb 公式没有考虑到这一点。

【讨论】：

非常感谢！我将此答案移植到 JavaScript。 gist.github.com/dfabulich/fc6b13a8bffc5518c4731347de642749

我还将这个答案移植到 SQL 中，假设列 rated5、rated4、rated3、rated2 和 rated1，这是对有多少人给出该评级的计数。 select ((5*(rated5+1)+4*(rated4+1)+3*(rated3+1)+2*(rated2+1)+1*(rated1+1))/(5+rated5+rated4+rated3+rated2+rated1))-1.65*SQRT((((25*(rated5+1)+16*(rated4+1)+9*(rated3+1)+4*(rated2+1)+1*(rated1+1))/(5+rated5+rated4+rated3+rated2+rated1)) - POWER(((5*(rated5+1)+4*(rated4+1)+3*(rated3+1)+2*(rated2+1)+1*(rated1+1))/(5+rated5+rated4+rated3+rated2+rated1)), 2))/(6+rated5+rated4+rated3+rated2+rated1)) as x from mytable

这是最好的答案。

那么，如果只有一个 5 开始评级，那么平均为什么是 2.5？例如。 starsort([1,0,0,0,0]) 2.4036636531319653

埃文米勒的公式看起来很复杂，但实际上很简单。首先，在计算平均值和标准差之前，为每个小部件添加五个虚假评级：一个 1 星、一个 2 星、一个 3 星、一个 4 星和一个 5-星级。然后，当需要排序时，首先从平均值中减去标准偏差 σ， 将 σ 乘以常数因子 z 以增加共识的权重，即 X = A - zσ。在 z = 1.65 时，每个小部件的“真实”平均值大于 X 的置信度为 90%。

【参考方案3】：

请参阅this page 以获得对基于星级的评分系统的良好分析，以及查看this one 以获得对基于赞成/反对票的系统的良好分析。

对于上下投票，您想估计在给定评分的情况下，“真实”分数（如果您有无限评分）大于某个数量（例如，其他一些类似的数字）的概率您正在排序的项目）。

答案见第二篇文章，但结论是你想使用威尔逊置信度。这篇文章给出了方程式和示例 Ruby 代码（很容易翻译成另一种语言）。

【讨论】：

Wilson 置信区间仅适用于二项分布（例如，+1/-1 风格评级）；目前尚不清楚对 5 星评级计划采取什么方法。

【参考方案4】：

您可以按median 排序，而不是算术平均值。在这种情况下，两个示例的中位数均为 5，因此在排序算法中两者的权重相同。

您可以使用 mode 达到相同的效果，但中位数可能是一个更好的主意。

如果您想为具有 100 个 5 星评级的产品分配额外的权重，您可能希望采用某种加权模式，为具有相同中位数但总体投票数更多的评级分配更多权重。

【讨论】：

如果我使用中值法，您将如何确定哪一个应该被评为更好的 5x 5 星评级和 4x 2 星评级或 5x 5 星评级和 4x 1 星评级？两者的评分都为 5。

这取决于你。这取决于你认为哪个更好。也许您首先按中位数排序，然后按均值排序。或者可能首先按中位数，然后按总票数。

加权中位数：首先按中位数排序，然后按均值排序。总票数提高了分数的可靠性（置信度），但没有说明分数本身。

【参考方案5】：

嗯，根据您想要制作的复杂程度，您还可以根据该人的评分数量以及这些评分的内容对评分进行加权。如果这个人只做了一个评级，它可能是一个先令评级，并且可能计算得更少。或者如果这个人在 a 类中评分很多，但在 b 类中评分很少，并且平均评分为 1.3 颗星（满分 5 星），听起来 a 类可能被该用户的低平均分人为压低，并且应该调整。

但足以让它变得复杂。让我们变得简单。

假设我们只使用两个值，ReviewCount 和 AverageRating，用于特定项目，我认为 ReviewCount 本质上是“可靠性”值是有意义的。但我们不只是想降低低 ReviewCount 项目的分数：单个 1 星评级可能与单个 5 星评级一样不可靠。所以我们想要做的可能是平均到中间：3。

所以，基本上，我在想一个方程，比如 X * AverageRating + Y * 3 = the-rating-we-want。为了使这个值正确，我们需要 X+Y 等于 1。此外，随着 ReviewCount 的增加，我们需要 X 的值增加……评论计数为 0，x 应该为 0（给我们一个等式“ 3”），并且评论数无限，X 应为 1（这使得等式 = AverageRating）。

那么什么是 X 和 Y 方程？对于 X 方程，当自变量接近无穷大时，希望因变量渐近接近 1。一组好的方程类似于： Y = 1/(因子^RatingCount) 和（利用 X 必须等于 1-Y 的事实） X = 1 – (1/(因子^RatingCount)

然后我们可以调整“因子”以适应我们正在寻找的范围。

我使用这个简单的 C# 程序尝试了几个因素：

        // We can adjust this factor to adjust our curve.
        double factor = 1.5;  

        // Here's some sample data
        double RatingAverage1 = 5;
        double RatingCount1 = 1;

        double RatingAverage2 = 4.5;
        double RatingCount2 = 5;

        double RatingAverage3 = 3.5;
        double RatingCount3 = 50000; // 50000 is not infinite, but it's probably plenty to closely simulate it.

        // Do the calculations
        double modfactor = Math.Pow(factor, RatingCount1);
        double modRating1 = (3 / modfactor)
            + (RatingAverage1 * (1 - 1 / modfactor));

        double modfactor2 = Math.Pow(factor, RatingCount2);
        double modRating2 = (3 / modfactor2)
            + (RatingAverage2 * (1 - 1 / modfactor2));

        double modfactor3 = Math.Pow(factor, RatingCount3);
        double modRating3 = (3 / modfactor3)
            + (RatingAverage3 * (1 - 1 / modfactor3));

        Console.WriteLine(String.Format("RatingAverage: 0, RatingCount: 1, Adjusted Rating: 2:0.00", 
            RatingAverage1, RatingCount1, modRating1));
        Console.WriteLine(String.Format("RatingAverage: 0, RatingCount: 1, Adjusted Rating: 2:0.00",
            RatingAverage2, RatingCount2, modRating2));
        Console.WriteLine(String.Format("RatingAverage: 0, RatingCount: 1, Adjusted Rating: 2:0.00",
            RatingAverage3, RatingCount3, modRating3));

        // Hold up for the user to read the data.
        Console.ReadLine();

所以你不必费心复制它，它会给出以下输出：

RatingAverage: 5, RatingCount: 1, Adjusted Rating: 3.67
RatingAverage: 4.5, RatingCount: 5, Adjusted Rating: 4.30
RatingAverage: 3.5, RatingCount: 50000, Adjusted Rating: 3.50

类似的东西？您显然可以根据需要调整“因子”值以获得所需的权重。

【参考方案6】：

如果您只需要一个快速且廉价的解决方案，并且大多数情况下无需使用大量计算即可工作，这里有一个选项（假设评分等级为 1-5）

SELECT Products.id, Products.title, avg(Ratings.score), etc
FROM
Products INNER JOIN Ratings ON Products.id=Ratings.product_id
GROUP BY 
Products.id, Products.title
ORDER BY (SUM(Ratings.score)+25.0)/(COUNT(Ratings.id)+20.0) DESC, COUNT(Ratings.id) DESC

加上 25 并除以总评分 + 20，基本上就是将 10 个最差分数和 10 个最佳分数加到总评分中，然后进行相应的排序。

这确实存在已知问题。例如，它不公平地奖励评分很少且评分较低的产品（如this graph 所示，平均评分为 1 且只有一个评分的产品评分为 1.2，而平均评分为 1 且评分为 1k+ 的产品评分接近 1.05） .你也可以争辩说它对评分很少的高质量产品进行了不公平的惩罚。

此图表显示了超过 1-1000 个评分的所有 5 个评分的情况： http://www.wolframalpha.com/input/?i=Plot3D%5B%2825%2Bxy%29/%2820%2Bx%29%2C%7Bx%2C1%2C1000%7D%2C%7By%2C0%2C6%7D%5D

你可以看到在最底层的收视率有所下降，但总的来说，我认为这是一个公平的排名。你也可以这样看：

http://www.wolframalpha.com/input/?i=Plot3D%5B6-%28%2825%2Bxy%29/%2820%2Bx%29%29%2C%7Bx%2C1%2C1000%7D%2C%7By%2C0%2C6%7D%5D

如果您在此图表中的大多数位置放置弹珠，它会自动滚向得分较高且评分较高的产品。

【参考方案7】：

显然，评分数量少使这个问题成为统计上的障碍。永远不会少...

提高综合评分质量的一个关键因素是“对评分者进行评分”，即密切关注每个特定“评分者”提供的评分（相对于其他评分者）。这允许在聚合过程中权衡他们的投票。

另一个解决方案，更多的是应对，是为最终用户提供对基础项目的投票计数（或其范围指示）。

【参考方案8】：

一个选项类似于 Microsoft 的 TrueSkill 系统，其分数由 mean - 3*stddev 给出，其中的常数可以调整。

【参考方案9】：

看了一会儿，我选择了贝叶斯系统。 如果有人在使用 Ruby，这里有一块宝石：

https://github.com/wbotelhos/rating

【参考方案10】：

我强烈推荐 Toby Segaran (OReilly) ISBN 978-0-596-52932-1 编写的 Programming Collective Intelligence 一书，该书讨论了如何从人群行为中提取有意义的数据。这些示例是用 Python 编写的，但它很容易转换。

【讨论】：

尽管我可以向所有对该领域感兴趣的人推荐这本书，但您的回答并不能解决所提出的问题。