前言
现在app就是雨后春笋，嗖嗖的往外冒啊，有经验的、没经验的、有资历的、没资历的都想着创业，创业的90%以上都要做一个app出来，好像成了创业的标配。
做了app就得推广啊，怎么推，发券送钱是最多用的被不可少的了，现在好多产品或者运营都要求能够随机出优惠券的金额，但是呢又不能过于随机，送出去的券都是钱吗，投资人的钱，是吧。
所以，在随机生成的金额中就要求，小额度的几率要大，大额度的几率要小，比如说3元的70%，5块的25%，10块的5%，这个样子的概率去生成优惠券，这个怎么办呢？
对于上述的问题，直接用我们的random.next(integer range);就不够了。因为这个伪随机不带权重，3，5，10出现的概率都是一样的。
实现思路
还是拿上述的例子，3出现的概率是70%，我们给他的权重赋值为70，5出现的概率为25%，我们给他的权重赋值为25，10出现的概率为5%，我们给他的权重赋值为5.
我们按照顺序计算出权重的加和，把当前数字出现的权重加和前的值作为其权重范围的起点值，把加和后的值作为其权重范围的终点值。
这样的话，我们就可以使用random.next(100)来做随机数，然后判断随机数落在的范围，然后映射到对应的优惠券数值即可。
java实现
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
package com.nggirl.test.weight.random;
import java.util.arraylist;
import java.util.hashmap;
import java.util.list;
import java.util.random;
public class weightrandom {
public static void main(string[] args){
weightrandom wr = new weightrandom();
wr.initweight(new string[]{
"1","2","3","4"
}
, new integer[]{
100,100,200,600
}
);
random r = new random();
for (int i = 0; i < 10; i++){
integer rv = r.nextint(wr.getmaxrandomvalue());
system.out.println(rv);
system.out.println(wr.getelementbyrandomvalue(rv).getkey() + " " + rv);
}
hashmap<string, integer> keycount = new hashmap<string, integer>();
keycount.put("1", 0);
keycount.put("2", 0);
keycount.put("3", 0);
keycount.put("4", 0);
for (int i = 0; i < 10000; i++){
integer rv = r.nextint(wr.getmaxrandomvalue());
string key = wr.getelementbyrandomvalue(rv).getkey();
keycount.put(key, keycount.get(key).intvalue()+1);
}
system.out.println("");
}
private list<weightelement> weightelements;
public void initweight(string[] keys, integer[] weights){
if(keys == null || weights == null || keys.length != weights.length){
return;
}
weightelements = new arraylist<weightelement>();
for (int i=0; i< keys.length; i++){
weightelements.add(new weightelement(keys[i], weights[i]));
}
rangeweightelemnts();
printrvs();
}
private void rangeweightelemnts(){
if(weightelements.size() == 0){
return;
}
weightelement ele0 = weightelements.get(0);
ele0.setthresholdlow(0);
ele0.setthresholdhigh(ele0.getweight());
for (int i = 1; i < weightelements.size(); i++){
weightelement curelement = weightelements.get(i);
weightelement preelement = weightelements.get(i - 1);
curelement.setthresholdlow(preelement.getthresholdhigh());
curelement.setthresholdhigh(curelement.getthresholdlow() + curelement.getweight());
}
}
public weightelement getelementbyrandomvalue(integer rv){
//因为元素权重范围有序递增，所以这里可以改为二分查找
for (weightelement e:weightelements){
if(rv >= e.getthresholdlow() && rv < e.getthresholdhigh()){
return e;
}
}
return null;
}
public integer getmaxrandomvalue(){
if(weightelements == null || weightelements.size() == 0){
return null;
}
return weightelements.get(weightelements.size() - 1).getthresholdhigh();
}
public void printrvs(){
for (weightelement e:weightelements){
system.out.println(e.tostring());
}
}
static class weightelement{
/**
* 元素标记
*/
private string key;
/**
* 元素权重
*/
private integer weight;
/**
* 权重对应随机数范围低线
*/
private integer thresholdlow;
/**
* 权重对应随机数范围高线
*/
private integer thresholdhigh;
public weightelement(){
}
public weightelement(integer weight){
this.key = weight.tostring();
this.weight = weight;
}
public weightelement(string key, integer weight){
this.key = key;
this.weight = weight;
}
public string getkey() {
return key;
}
public void setkey(string key) {
this.key = key;
}
public integer getweight() {
return weight;
}
public void setweight(integer weight) {
this.weight = weight;
}
public integer getthresholdlow() {
return thresholdlow;
}
public void setthresholdlow(integer thresholdlow) {
this.thresholdlow = thresholdlow;
}
public integer getthresholdhigh() {
return thresholdhigh;
}
public void setthresholdhigh(integer thresholdhigh) {
this.thresholdhigh = thresholdhigh;
}
public string tostring(){
return "key:"+this.key + " weight:" + this.weight + " low:"+this.thresholdlow+" heigh:"+this.thresholdhigh;
}
}
}
|
结果：
|
1
2
3
|
2 102
876
4 876
|
二分法的实现
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public weightelement getelementbyrandomvalue(integer rv){
if(rv < 0 || rv > getmaxrandomvalue()-1){
return null;
}
//此时rv必然在0 - getmaxrandomvalue()-1范围内，
//也就是必然能够命中某一个值
int start = 0, end = weightelements.size() - 1;
int index = weightelements.size()/2;
while(true){
if(rv < weightelements.get(index).getthresholdlow()){
end = index - 1;
} else if(rv >= weightelements.get(index).getthresholdhigh()){
start = index + 1;
} else{
return weightelements.get(index);
}
index = (start + end)/2;
}
}
|
下面再分享一则实例，加强对权重随机算法的理解，一次到位！
权重随机算法在抽奖，资源调度等系统中应用还是比较广泛的，一个简单的按照权重来随机的实现，权重为几个随机对象(分类)的命中的比例，权重设置越高命中越容易，之和可以不等于100；
简单实现代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
|
import java.util.arraylist;
import java.util.list;
import java.util.random;
public class weightrandom {
static list<weightcategory> categorys = new arraylist<weightcategory>();
private static random random = new random();
public static void initdata() {
weightcategory wc1 = new weightcategory("a",60);
weightcategory wc2 = new weightcategory("b",20);
weightcategory wc3 = new weightcategory("c",20);
categorys.add(wc1);
categorys.add(wc2);
categorys.add(wc3);
}
public static void main(string[] args) {
initdata();
integer weightsum = 0;
for (weightcategory wc : categorys) {
weightsum += wc.getweight();
}
if (weightsum <= 0) {
system.err.println("error: weightsum=" + weightsum.tostring());
return;
}
integer n = random.nextint(weightsum);
// n in [0, weightsum)
integer m = 0;
for (weightcategory wc : categorys) {
if (m <= n && n < m + wc.getweight()) {
system.out.println("this random category is "+wc.getcategory());
break;
}
m += wc.getweight();
}
}
}
class weightcategory {
private string category;
private integer weight;
public weightcategory() {
super();
}
public weightcategory(string category, integer weight) {
super();
this.setcategory(category);
this.setweight(weight);
}
public integer getweight() {
return weight;
}
public void setweight(integer weight) {
this.weight = weight;
}
public string getcategory() {
return category;
}
public void setcategory(string category) {
this.category = category;
}
}
|
结果：
总结
以上就是本文关于java语言实现权重随机算法完整实例的全部内容，希望对大家有所帮助。如有不足之处，欢迎留言指出。感谢朋友们对本站的支持！
原文链接：http://blog.csdn.net/BuquTianya/article/details/51051672