Làm thế nào để tổng hợp các phần tử của một vectơ C ++?

Các cách tốt để tìm tổng của tất cả các yếu tố trong một là std::vectorgì?

Giả sử tôi có một vectơ std::vector<int> vectorvới một vài yếu tố trong đó. Bây giờ tôi muốn tìm tổng của tất cả các yếu tố. Các cách khác nhau cho cùng là gì?

Trên thực tế có khá nhiều phương pháp.

int sum_of_elems = 0;

C ++ 03

1. Vòng lặp cổ điển:

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

2. Sử dụng thuật toán tiêu chuẩn:

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

   Lưu ý quan trọng: Loại của đối số cuối cùng không chỉ được sử dụng cho giá trị ban đầu mà còn cho loại kết quả . Nếu bạn đặt một int ở đó, nó sẽ tích lũy int ngay cả khi vectơ có float. Nếu bạn đang tính tổng các số dấu phẩy động, hãy đổi 0thành 0.0hoặc 0.0f(nhờ nneonneo). Xem thêm giải pháp C ++ 11 dưới đây.

C ++ 11 trở lên

2. b. Tự động theo dõi loại vectơ ngay cả trong trường hợp thay đổi trong tương lai:

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

3. Sử dụng std::for_each:

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

4. Sử dụng vòng lặp dựa trên phạm vi (nhờ Roger Pate):

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

Cách dễ nhất là sử dụng std:accumuatemột vector<int> A:

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

Prasoon đã đưa ra một loạt các cách khác nhau (và tốt) để làm điều này, không có cách nào cần lặp lại ở đây. Tuy nhiên, tôi muốn đề xuất một phương pháp thay thế cho tốc độ.

Nếu bạn sẽ làm điều này khá nhiều, bạn có thể muốn xem xét "phân lớp phụ" vectơ của mình để một tổng các phần tử được duy trì riêng biệt (không thực sự là vectơ phân lớp phụ là iffy do thiếu một hàm hủy ảo - Tôi đang nói nhiều hơn về một lớp chứa tổng và vectơ bên trong nó, has-achứ không phải is-a, và cung cấp các phương thức giống như vectơ).

Đối với một vectơ trống, tổng được đặt thành không. Trên mỗi lần chèn vào vectơ, thêm phần tử được chèn vào tổng. Trên mỗi lần xóa, trừ nó. Về cơ bản, bất cứ điều gì có thể thay đổi vectơ cơ bản đều bị chặn để đảm bảo tổng được giữ ổn định.

Bằng cách đó, bạn có một phương pháp O (1) rất hiệu quả để "tính toán" tổng số tại bất kỳ thời điểm nào (chỉ cần trả lại tổng số hiện đang tính). Việc chèn và xóa sẽ mất nhiều thời gian hơn khi bạn điều chỉnh tổng số và bạn nên cân nhắc hiệu năng này.

Các vectơ trong đó tổng cần thiết thường xuyên hơn vectơ được thay đổi là những vectơ có thể được hưởng lợi từ sơ đồ này, vì chi phí tính tổng được khấu hao trên tất cả các truy cập. Rõ ràng, nếu bạn chỉ cần tổng mỗi giờ và vectơ thay đổi ba nghìn lần một giây, nó sẽ không phù hợp.

Một cái gì đó như thế này sẽ đủ:

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

Rõ ràng, đó là mã giả và bạn có thể muốn có thêm một chút chức năng, nhưng nó cho thấy khái niệm cơ bản.

Tại sao thực hiện tổng kết về phía trước khi bạn có thể làm điều đó ngược lại ? Được:

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

Chúng ta có thể sử dụng đăng ký, đếm ngược:

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

Chúng tôi có thể sử dụng "đăng ký" được kiểm tra phạm vi, đếm ngược (chỉ trong trường hợp):

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

Chúng ta có thể sử dụng các trình vòng lặp ngược trong một vòng lặp for:

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

Chúng ta có thể sử dụng các trình vòng lặp tiến, lặp lại ngược, trong một vòng lặp for (oooh, tricky!):

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

Chúng ta có thể sử dụng accumulatevới các trình vòng lặp ngược:

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

Chúng ta có thể sử dụng for_eachvới biểu thức lambda bằng cách sử dụng các trình vòng lặp ngược:

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

Vì vậy, như bạn có thể thấy, có rất nhiều cách để tổng hợp vectơ ngược lại cũng như tính tổng vectơ về phía trước, và một số trong số này thú vị hơn nhiều và cung cấp cơ hội lớn hơn nhiều cho các lỗi ngoài luồng.

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

Người ta cũng có thể sử dụng std::valarray<T>như thế này

#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;
}

Một số có thể không tìm thấy cách này hiệu quả vì kích thước của valarraynhu cầu phải lớn bằng kích thước của vectơ và việc khởi tạo valarraycũng sẽ mất thời gian.

Trong trường hợp đó, không sử dụng nó và coi đó là một cách khác để tóm tắt trình tự.

Chỉ C ++ 0x:

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

Điều này tương tự như BOOST_FOREACH được đề cập ở nơi khác và có cùng lợi ích của sự rõ ràng trong các tình huống phức tạp hơn, so với các hàm xử lý trạng thái được sử dụng với tích lũy hoặc for_each.

Tôi là người dùng Perl, một trò chơi chúng tôi có là tìm mọi cách khác nhau để tăng một biến ... điều đó không thực sự khác biệt ở đây. Câu trả lời cho có bao nhiêu cách để tìm tổng các phần tử của một vectơ trong C ++ có lẽ là an infinity...

2 xu của tôi:

Sử dụng BOOST_FOREACH, để thoát khỏi cú pháp lặp xấu xí:

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

lặp đi lặp lại trên các chỉ số (thực sự dễ đọc).

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

Cái khác này là phá hoại, truy cập vào vector như một ngăn xếp:

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

Tôi tìm thấy cách dễ nhất để tìm tổng của tất cả các phần tử của một vectơ

#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;

}

Trong chương trình này, tôi có một vectơ kích thước 10 và được khởi tạo bằng 1. Tôi đã tính tổng bằng một vòng lặp đơn giản như trong mảng.

Nó rất dễ dàng. C ++ 11 cung cấp một cách dễ dàng để tổng hợp các phần tử của một vectơ.

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