จะสรุปองค์ประกอบของเวกเตอร์ C ++ ได้อย่างไร

อะไรคือวิธีที่ดีในการหาผลรวมขององค์ประกอบทั้งหมดในstd::vector?

สมมติว่าฉันมีเวกเตอร์ที่std::vector<int> vectorมีองค์ประกอบบางอย่างอยู่ในนั้น ตอนนี้ฉันต้องการหาผลรวมขององค์ประกอบทั้งหมด อะไรกันในวิธีเดียวกัน

จริงๆแล้วมีวิธีการค่อนข้างน้อย

int sum_of_elems = 0;

C ++ 03

1. คลาสสิกสำหรับวง:

   for(std::vector<int>::iterator it = vector.begin(); it != vector.end(); ++it)
       sum_of_elems += *it;

2. ใช้อัลกอริทึมมาตรฐาน:

   #include <numeric>
   
   sum_of_elems = std::accumulate(vector.begin(), vector.end(), 0);

   หมายเหตุสำคัญ:ประเภทของอาร์กิวเมนต์ล่าสุดนั้นไม่ได้ใช้เฉพาะกับค่าเริ่มต้น แต่สำหรับประเภทของผลลัพธ์เช่นกัน ถ้าคุณใส่ค่า int ตรงนั้นมันจะสะสม ints แม้ว่าเวกเตอร์จะลอย หากคุณกำลังรวมจำนวนจุดลอยตัวให้เปลี่ยน0เป็น0.0หรือ0.0f(ขอบคุณ nneonneo) ดูเพิ่มเติมที่โซลูชัน C ++ 11 ด้านล่าง

C ++ 11 และสูงกว่า

2. ข ติดตามชนิดเวกเตอร์โดยอัตโนมัติแม้ในกรณีที่มีการเปลี่ยนแปลงในอนาคต:

   #include <numeric>
   
   sum_of_elems = std::accumulate(vector.begin(), vector.end(),
                                  decltype(vector)::value_type(0));

3. การใช้std::for_each:

   std::for_each(vector.begin(), vector.end(), [&] (int n) {
       sum_of_elems += n;
   });

4. ใช้ช่วงสำหรับวง (ขอบคุณ Roger Pate):

   for (auto& n : vector)
       sum_of_elems += n;

วิธีที่ง่ายที่สุดคือการใช้std:accumuateของvector<int> A:

#include <numeric>
cout << accumulate(A.begin(), A.end(), 0);

Prasoon ได้เสนอวิธีการที่แตกต่าง (และดี) ให้กับโฮสต์แล้วซึ่งไม่จำเป็นต้องทำซ้ำที่นี่ ฉันต้องการแนะนำวิธีอื่นสำหรับความเร็วอย่างไรก็ตาม

หากคุณกำลังจะทำเช่นนี้ไม่น้อยคุณอาจต้องการที่จะต้องพิจารณา "ย่อย classing" เวกเตอร์ของคุณเพื่อให้ผลรวมขององค์ประกอบที่จะยังคงแยกกัน (ไม่จริงย่อย classing เวกเตอร์ซึ่งเป็นเต็มไปด้วยปัญหาเกิดจากการขาดการ virtual destructor - ฉันกำลังพูดถึงคลาสที่มีผลรวมและเวกเตอร์ในคลาสhas-aมากกว่าis-aและมีวิธีการเหมือนเวกเตอร์)

สำหรับเวกเตอร์ที่ว่างเปล่าผลรวมจะถูกตั้งค่าเป็นศูนย์ ในทุกการแทรกของเวกเตอร์ให้เพิ่มองค์ประกอบที่ถูกแทรกลงในผลรวม ในการลบทุกครั้งให้ลบออก โดยพื้นฐานแล้วสิ่งใดก็ตามที่สามารถเปลี่ยนเวกเตอร์ต้นแบบนั้นจะถูกดักเพื่อให้แน่ใจว่าผลรวมนั้นคงที่

ด้วยวิธีนี้คุณมีวิธี O (1) ที่มีประสิทธิภาพมากในการ "คำนวณ" ผลรวม ณ เวลาใด ๆ (เพียงแค่คืนผลรวมที่คำนวณได้ในปัจจุบัน) การแทรกและการลบจะใช้เวลานานขึ้นเล็กน้อยในขณะที่คุณปรับยอดรวมและคุณควรคำนึงถึงประสิทธิภาพการทำงานนี้ด้วย

เวกเตอร์ที่จำเป็นต้องใช้ผลรวมบ่อยกว่าเวกเตอร์ที่มีการเปลี่ยนแปลงเป็นสิ่งที่น่าจะได้รับประโยชน์จากโครงการนี้เนื่องจากค่าใช้จ่ายในการคำนวณผลรวมนั้นตัดจำหน่ายตลอดการเข้าถึงทั้งหมด เห็นได้ชัดว่าถ้าคุณต้องการเพียงผลรวมทุกชั่วโมงและเวกเตอร์มีการเปลี่ยนแปลงสามพันครั้งต่อวินาทีมันจะไม่เหมาะสม

สิ่งนี้จะพอเพียง:

class UberVector:
    private Vector<int> vec
    private int sum

    public UberVector():
        vec = new Vector<int>()
        sum = 0

    public getSum():
        return sum

    public add (int val):
        rc = vec.add (val)
        if rc == OK:
            sum = sum + val
        return rc

    public delindex (int idx):
        val = 0
        if idx >= 0 and idx < vec.size:
            val = vec[idx]
        rc =  vec.delindex (idx)
        if rc == OK:
            sum = sum - val
        return rc

เห็นได้ชัดว่าเป็นรหัสหลอกและคุณอาจต้องการฟังก์ชั่นเพิ่มเติมอีกเล็กน้อย แต่มันแสดงแนวคิดพื้นฐาน

เหตุใดจึงต้องมีการรวมกันส่งต่อเมื่อคุณสามารถทำย้อนกลับได้ ? ได้รับ:

std::vector<int> v;     // vector to be summed
int sum_of_elements(0); // result of the summation

เราสามารถใช้ตัวห้อยนับถอยหลังไปด้านหลัง:

for (int i(v.size()); i > 0; --i)
    sum_of_elements += v[i-1];

เราสามารถใช้ "การห้อย," การนับช่วงถอยหลัง (ในกรณี):

for (int i(v.size()); i > 0; --i)
    sum_of_elements += v.at(i-1);

เราสามารถใช้ตัววนซ้ำแบบย้อนกลับในการ for:

for(std::vector<int>::const_reverse_iterator i(v.rbegin()); i != v.rend(); ++i)
    sum_of_elements += *i;

เราสามารถใช้ตัววนซ้ำไปข้างหน้าวนซ้ำไปข้างหลังในวงวน (oooh, หากิน!):

for(std::vector<int>::const_iterator i(v.end()); i != v.begin(); --i)
    sum_of_elements += *(i - 1);

เราสามารถใช้accumulateกับตัววนซ้ำแบบย้อนกลับ:

sum_of_elems = std::accumulate(v.rbegin(), v.rend(), 0);

เราสามารถใช้for_eachกับแลมบ์ดานิพจน์โดยใช้ตัววนซ้ำแบบย้อนกลับ:

std::for_each(v.rbegin(), v.rend(), [&](int n) { sum_of_elements += n; });

ดังที่คุณเห็นมีหลายวิธีในการหาผลรวมของเวกเตอร์ไปข้างหลังเหมือนกับที่จะรวมเวกเตอร์ไปข้างหน้าและสิ่งเหล่านี้น่าตื่นเต้นมากขึ้น

#include<boost/range/numeric.hpp>
int sum = boost::accumulate(vector, 0);

ท่านสามารถใช้std::valarray<T>เช่นนี้

#include<iostream>
#include<vector>
#include<valarray>

int main()
{
    std::vector<int> seq{ 1,2,3,4,5,6,7,8,9,10 };
    std::valarray<int> seq_add{ seq.data(), seq.size() };
    std::cout << "sum = " << seq_add.sum() << "\n";

    return 0;
}

บางคนอาจไม่พบวิธีนี้ที่มีประสิทธิภาพเนื่องจากขนาดของvalarrayความต้องการจะใหญ่เท่ากับขนาดของเวกเตอร์และการเริ่มต้นvalarrayจะใช้เวลาเช่นกัน

ในกรณีนี้อย่าใช้มันและใช้เป็นอีกวิธีในการสรุปลำดับ

C ++ 0x เท่านั้น:

vector<int> v; // and fill with data
int sum {}; // or = 0 ... :)
for (int n : v) sum += n;

สิ่งนี้คล้ายกับ BOOST_FOREACH ที่กล่าวถึงที่อื่นและได้รับประโยชน์จากความชัดเจนในสถานการณ์ที่ซับซ้อนมากขึ้นเมื่อเทียบกับฟังก์ชั่น stateful ที่ใช้กับสะสมหรือ for_each

ฉันเป็นผู้ใช้ Perl เกมที่เรามีคือการค้นหาทุกวิธีที่แตกต่างกันในการเพิ่มตัวแปร ... นั่นไม่ได้แตกต่างไปจากที่นี่จริงๆ คำตอบของวิธีหาจำนวนผลรวมขององค์ประกอบของเวกเตอร์ใน C ++ น่าจะเป็นan infinity...

2 เซนต์ของฉัน:

ใช้ BOOST_FOREACH เพื่อรับไวยากรณ์ iterator ที่น่าเกลียด:

sum = 0;
BOOST_FOREACH(int & x, myvector){
  sum += x;
}

วนซ้ำดัชนี (อ่านง่ายจริงๆ)

int i, sum = 0;
for (i=0; i<myvector.size(); i++){
  sum += myvector[i];
}

อีกอันหนึ่งนั้นเป็นแบบทำลายล้างการเข้าถึงเวกเตอร์เหมือนสแต็ก:

while (!myvector.empty()){
   sum+=myvector.back();
   myvector.pop_back();
}

ฉันพบวิธีที่ง่ายที่สุดในการหาผลรวมขององค์ประกอบทั้งหมดของเวกเตอร์

#include <iostream>
#include<vector>
using namespace std;

int main()
{
    vector<int>v(10,1);
    int sum=0;
    for(int i=0;i<v.size();i++)
    {
        sum+=v[i];
    }
    cout<<sum<<endl;

}

ในโปรแกรมนี้ฉันมีเวกเตอร์ขนาด 10 และเริ่มต้นด้วย 1 ฉันได้คำนวณผลรวมด้วยลูปแบบง่ายเช่นเดียวกับในอาร์เรย์

มันง่ายมาก C ++ 11 เป็นวิธีที่ง่ายในการสรุปองค์ประกอบของเวกเตอร์

sum = 0; 
vector<int> vec = {1,2,3,4,5,....}
for(auto i:vec) 
   sum+=i;
cout<<" The sum is :: "<<sum<<endl;