Java 如何建立一个链表，即每个节点都会有一个随机的int值，但总的值总和和节点数会事先固定下来？

我已经开始建造这样的东西：

class Node{
    Node next,prev;
    int val;
    Node(int val, Node prev, Node next){
        this.val = val;
        this.prev = prev;
        this.next = next;
    }
}

double runningTotal = total;
Random rand = new Random();
road = new double[size];
while(runningTotal > 0) {
    double temp = rand.nextDouble(); // return [0, 1)
    if(temp > runningTotal) {
        temp = runningTotal;
        runningTotal = 0.0;
    } else {
        runningTotal -= temp;
    }
    road[rand.nextInt(size)] += temp;
}

公共路径（整数大小，整数总数）{
道路=新节点[尺寸]；
inttmp=（int）（Math.random（）*（double）（total/size））；
总计=总tmp；
道路[0]=新节点（tmp，道路[1号]，道路[1]）；
对于（int i=1；i

---

这完全不是正确的算法，但这是我要表达的一般想法。如果你想让总和成为一个特定的总和，你可以有一个剩余的总和，并使最后一个元素具有该值。e、 g

---

使节点具有随机值X1、X2、。。。Xn-1，total-SumOf（X1，…Xn-1）这将确保总数始终为

total

如果要生成n个值，其总和为S，则可以生成0和1之间的n个随机双精度，然后将它们除以，使其总和为1。然后将值乘以S。如果数字必须是整数，则可能需要进行一些额外的工作来正确处理舍入。

对于统一的随机答案（假设隐式非负约束）：在

0

包含和

sum+nodeCount-1

独占之间生成

nodeCount-1

成对不同整数。对这些进行排序，在

-1

前面加上前缀，然后再加上

sum+nodeCount-1

。返回差序列减1

示例：

nodeCount=4

和

sum=10

。生成整数

5 2 12

排序、前置、追加

-1 2 5 12 13

差异序列

3 3 7 1

负一

2 2 6 0

---

实现说明：如果可能的话，您需要使用特殊情况

nodeCount==0

。要生成无重复的整数：如果

sum

比

nodeCount

小，则使用部分Fisher--Yates shuffle。否则，对带有替换项的

nodeCount-1

整数进行采样并重复，直到没有重复项。

您可以执行以下操作：

class Node{
    Node next,prev;
    int val;
    Node(int val, Node prev, Node next){
        this.val = val;
        this.prev = prev;
        this.next = next;
    }
}

double runningTotal = total;
Random rand = new Random();
road = new double[size];
while(runningTotal > 0) {
    double temp = rand.nextDouble(); // return [0, 1)
    if(temp > runningTotal) {
        temp = runningTotal;
        runningTotal = 0.0;
    } else {
        runningTotal -= temp;
    }
    road[rand.nextInt(size)] += temp;
}

您可以将

temp=rand.nextDouble（）

替换为

temp=rand.nextDouble/scalingFactor

（例如scalingFactor=10），以提高一致性并降低任何节点最终等于0的概率。

公共节点[]buildRandomPath（int-size，int-total）{
public Node[] buildRandomPath(int size, int total){
    Node[] road = new Node[size];
    int tmp = (int)(Math.random()*(double)(total/size));
    if(tmp==0)
        tmp=1;
    total = total-tmp;
    road[0] = new Node(tmp,road[size-1],road[1]);
    int tmp1=0;
    for (int i = 1; i < size-1; i++){
        tmp1 = (int)(Math.random()*(double)(total/size-i));
        if(tmp1==0)
            tmp1=1;
        total = total-tmp1;
        if(total>0)
            road[i] = new Node(tmp1,road[i-1],road[i+1]);
        else
            road[i] = new Node(0,road[i-1],road[i+1]);
    }
    road[size-1] = new Node(total,road[size-2],road[0]);
    return road;
}

节点[]道路=新节点[尺寸]；
inttmp=（int）（Math.random（）*（double）（total/size））；
如果（tmp==0）
tmp=1；
总计=总tmp；
道路[0]=新节点（tmp，道路[1号]，道路[1]）；
int-tmp1=0；
对于（int i=1；i0）
道路[i]=新节点（tmp1，道路[i-1]，道路[i+1]）；
其他的
道路[i]=新节点（0，道路[i-1]，道路[i+1]）；
}
道路[size-1]=新节点（总计，道路[size-2]，道路[0]）；
回程路；
}

导入java.util.ArrayList；
导入java.util.HashMap；
导入java.util.Iterator；
导入java.util.List；
导入java.util.Map；
类节点{
节点next，prev；
int-val；
}
公共类临时工{
公共节点[]buildRandomPath（整数大小，整数总数）{
节点[]道路=新节点[尺寸]；
对于（int i=0；i0）
道路[i].val=tmp1；
其他的
道路[i].val=0；
}
道路[size-1].val=总计；
道路[size-1]。下一条=道路[0]；
道路[size-1]。prev=道路[size-2]；
回程路；
}
公共静态void main（字符串[]args）{
温度t=新温度（）；
Node[]Node=t.buildRandomPath（10500）；
int i=0；
用于（节点2:Node）{
i=i+node2.val；
}
系统输出打印LN（i）；
}
}

这基本上取决于给定的附加约束。例如，节点的随机分布应如何？或者有任何可能的列表具有相同的概率吗。。。以何种方式，所有值都是随机的，且总和是确定性的？在我看来，至少有一个值必须依赖于所有其他值，no？@G.Bach Random并不自动意味着独立。在给定的情况下，确定性和只是将随机度的数量减少了一个。@Howard我假设随机在这里的意思是“有多个正概率的可能结果”，这不适用于最后选择的值。当然，概率不一定是独立的，但将某个事件（即概率为1的事件）称为随机事件至少会在上下文中产生误导。@Howard想一想，我同意你的看法；我的想法有点过于严格。我不明白这个问题是如何暗示非消极性的，以及作为约束的值的上限。我明白了；无论哪种方式，您给出的解决方案都可以通过选择随机数来生成无界值，将其添加到序列的一个元素中，然后从另一个元素中减去，因此边界很容易消除。@G.Bach我不太明白，但对于负和非负

int

s，Peter的解决方案更简单，而且在Java封装

int的情况下效果很好<