对排序列表中的元素求和,然后将求和值添加到列表中
Sum elements in an sorted List and then add the summed value into list
所以,这是我的问题,我有一个包含类似内容的列表
[4,7,8,23,41]
我想要的是
4+7 = 11 因此应将 11 添加到此列表中,并应删除 4 和 7。
然后 11 +8 = 19 所以添加 19 并删除 11 和 8。
int finalSum=0;
Collections.sort(myList);
for(int i =0;i<myList.size();i++)
{
for(int j=i+1;i<myList.size();j++)
{
int sum = myList.get(i) + myList.get(j);
myList.remove(i);
myList.remove(j);
}
}
for(int k=0;k<myList.size();k++)
{
finalSum += myList.get(k);
}
我不确定您想要这样的算法的原因,但是这应该按照您描述的方式运行。
public static void main(String[] args) {
List<Integer> myList = new LinkedList<>(Arrays.asList(4,7,8,23,41));
Collections.sort(myList);
while (myList.size() > 1) {
myList.add(0, myList.remove(0) + myList.remove(0));
}
int finalSum = myList.get(0);
System.out.println(finalSum);
}
对列表中的元素求和的更好方法是:
public static void main(String[] args) {
List<Integer> myList = Arrays.asList(4,7,8,23,41);
int finalSum = myList.stream().reduce(0, Integer::sum);
System.out.println(finalSum);
}
如果您只想获得列表的最终总数,您可以通过遍历整个列表并同时添加每个值来实现。
for(int k=0;k<myList.size();k++)
{
finalSum += myList.get(k);
}
但是,正如您所描述的,您想要从列表中添加前两个数字,然后应该删除它们,将总数添加回列表并执行相同的过程,然后我们可以在此处使用 PriorityQueue。它可以帮助跟踪升序,无论如何我们代码的时间复杂度将是 O(n logn),其中 n 是列表的大小。
PriorityQueue<Integer> pq= new PriorityQueue<>(); // by default it maintains the ascending order
for(int k=0;k<myList.size();k++){
pq.add(myList.get(k));
}
while(pq.size()>1){
int num1 = pq.poll(); // taking out first smallest number
int num2 = pq.poll(); // taking out second smallest number
pq.add(num1+num2);
}
finalSum = pq.poll(); // final sum
由于您一直在从列表中删除元素,因此您可以继续使用索引 0。
List<Integer> list = new ArrayList<>(Arrays.asList(4,7,8,23,41));
int first = 0;
while (list.size() > 0) {
int v = list.remove(0) + first;
list.add(0, v);
System.out.println(list);
first = list.remove(0);
}
但如果您只是求和,这是最简单的。
int sum = list.stream().mapToInt(a -> a).sum();
所以,这是我的问题,我有一个包含类似内容的列表 [4,7,8,23,41] 我想要的是 4+7 = 11 因此应将 11 添加到此列表中,并应删除 4 和 7。 然后 11 +8 = 19 所以添加 19 并删除 11 和 8。
int finalSum=0;
Collections.sort(myList);
for(int i =0;i<myList.size();i++)
{
for(int j=i+1;i<myList.size();j++)
{
int sum = myList.get(i) + myList.get(j);
myList.remove(i);
myList.remove(j);
}
}
for(int k=0;k<myList.size();k++)
{
finalSum += myList.get(k);
}
我不确定您想要这样的算法的原因,但是这应该按照您描述的方式运行。
public static void main(String[] args) {
List<Integer> myList = new LinkedList<>(Arrays.asList(4,7,8,23,41));
Collections.sort(myList);
while (myList.size() > 1) {
myList.add(0, myList.remove(0) + myList.remove(0));
}
int finalSum = myList.get(0);
System.out.println(finalSum);
}
对列表中的元素求和的更好方法是:
public static void main(String[] args) {
List<Integer> myList = Arrays.asList(4,7,8,23,41);
int finalSum = myList.stream().reduce(0, Integer::sum);
System.out.println(finalSum);
}
如果您只想获得列表的最终总数,您可以通过遍历整个列表并同时添加每个值来实现。
for(int k=0;k<myList.size();k++)
{
finalSum += myList.get(k);
}
但是,正如您所描述的,您想要从列表中添加前两个数字,然后应该删除它们,将总数添加回列表并执行相同的过程,然后我们可以在此处使用 PriorityQueue。它可以帮助跟踪升序,无论如何我们代码的时间复杂度将是 O(n logn),其中 n 是列表的大小。
PriorityQueue<Integer> pq= new PriorityQueue<>(); // by default it maintains the ascending order
for(int k=0;k<myList.size();k++){
pq.add(myList.get(k));
}
while(pq.size()>1){
int num1 = pq.poll(); // taking out first smallest number
int num2 = pq.poll(); // taking out second smallest number
pq.add(num1+num2);
}
finalSum = pq.poll(); // final sum
由于您一直在从列表中删除元素,因此您可以继续使用索引 0。
List<Integer> list = new ArrayList<>(Arrays.asList(4,7,8,23,41));
int first = 0;
while (list.size() > 0) {
int v = list.remove(0) + first;
list.add(0, v);
System.out.println(list);
first = list.remove(0);
}
但如果您只是求和,这是最简单的。
int sum = list.stream().mapToInt(a -> a).sum();