วิธีที่ดีที่สุดในการแยก subvector จากเวกเตอร์

สมมติว่าผมมีstd::vector(โทรให้ของมันmyVec) Nขนาด อะไรคือวิธีที่ง่ายที่สุดในการสร้างเวกเตอร์ใหม่ซึ่งประกอบด้วยสำเนาขององค์ประกอบ X ถึง Y โดยที่ 0 <= X <= Y <= N-1 ยกตัวอย่างเช่นmyVec [100000]ผ่านในเวกเตอร์ของขนาดmyVec [100999]150000

หากไม่สามารถทำได้อย่างมีประสิทธิภาพด้วยเวกเตอร์มีประเภทข้อมูล STL อื่นที่ฉันควรใช้แทนหรือไม่

vector<T>::const_iterator first = myVec.begin() + 100000;
vector<T>::const_iterator last = myVec.begin() + 101000;
vector<T> newVec(first, last);

เป็นการดำเนินการ O (N) เพื่อสร้างเวกเตอร์ใหม่ แต่ไม่มีวิธีที่ดีกว่าจริงๆ

เพียงแค่ใช้ตัวสร้างเวกเตอร์

std::vector<int>   data();
// Load Z elements into data so that Z > Y > X

std::vector<int>   sub(&data[100000],&data[101000]);

std::vector<T>(input_iterator, input_iterator)ในกรณีของคุณfoo = std::vector<T>(myVec.begin () + 100000, myVec.begin () + 150000);ดูตัวอย่างที่นี่

วันนี้เราใช้spans! ดังนั้นคุณจะเขียน:

#include <gsl/span>

...
auto start_pos = 100000;
auto length = 1000;
auto span_of_myvec = gsl::make_span(myvec);
auto my_subspan = span_of_myvec.subspan(start_pos, length);

เพื่อรับช่วง 1,000 องค์ประกอบประเภทเดียวกันเป็นmyvecของ หรือแบบฟอร์มสั้น ๆ เพิ่มเติม:

auto my_subspan = gsl::make_span(myvec).subspan(1000000, 1000);

(แต่ฉันไม่ชอบสิ่งนี้มากนักเนื่องจากความหมายของอาร์กิวเมนต์ที่เป็นตัวเลขแต่ละตัวนั้นไม่ชัดเจนทั้งหมดและจะแย่ลงถ้าความยาวและ start_pos มีลำดับความสำคัญเท่ากัน)

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

std::vector<T> new_vec(my_subspan.cbegin(), my_subspan.cend());

หมายเหตุ:

• gslหมายถึงห้องสมุดสนับสนุนแนวทาง สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการgslดู: http://www.modernescpp.com/index.php/c-core-guideline-the-guidelines-support-library
• สำหรับการนำไปปฏิบัติอย่างใดอย่างหนึ่งgslโปรดดู: https://github.com/Microsoft/GSL
• C ++ 20 spanให้การดำเนินงานของ คุณจะใช้std::spanและมากกว่า#include <span>#include <gsl/span>
• สำหรับข้อมูลเพิ่มเติมเกี่ยวกับช่วงโปรดดูที่: "ระยะเวลา" คืออะไรและฉันควรใช้เมื่อใด
• std::vector มีช่างก่อสร้างเป็นล้านล้านมันง่ายมากที่จะตกอยู่ในสิ่งที่คุณไม่ต้องการใช้ดังนั้นระวัง

หากทั้งสองจะไม่ได้รับการแก้ไข (ไม่มีการเพิ่ม / ลบรายการ - การปรับเปลี่ยนที่มีอยู่จะดีตราบเท่าที่คุณจ่ายรำลึกถึงปัญหา threading) คุณก็สามารถผ่านรอบdata.begin() + 100000และdata.begin() + 101000และแกล้งทำเป็นว่าพวกเขาเป็นbegin()และend()ของเวกเตอร์ที่มีขนาดเล็ก

หรือเนื่องจากพื้นที่จัดเก็บแบบเวกเตอร์รับประกันว่าต่อเนื่องกันคุณสามารถส่งรายการอาร์เรย์ได้ 1,000 รายการ:

T *arrayOfT = &data[0] + 100000;
size_t arrayOfTLength = 1000;

เทคนิคทั้งสองนี้ใช้เวลาคงที่ แต่ต้องการความยาวของข้อมูลที่ไม่เพิ่มขึ้นทำให้เกิดการจัดสรรใหม่

การสนทนานี้ค่อนข้างเก่า แต่สิ่งที่ง่ายที่สุดยังไม่ได้กล่าวถึงด้วยการเริ่มต้นรายการ :

 vector<int> subvector = {big_vector.begin() + 3, big_vector.end() - 2}; 

มันต้องมี c ++ 11 ขึ้นไป

ตัวอย่างการใช้งาน:

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main(){

    vector<int> big_vector = {5,12,4,6,7,8,9,9,31,1,1,5,76,78,8};
    vector<int> subvector = {big_vector.begin() + 3, big_vector.end() - 2};

    cout << "Big vector: ";
    for_each(big_vector.begin(), big_vector.end(),[](int number){cout << number << ";";});
    cout << endl << "Subvector: ";
    for_each(subvector.begin(), subvector.end(),[](int number){cout << number << ";";});
    cout << endl;
}

ผลลัพธ์:

Big vector: 5;12;4;6;7;8;9;9;31;1;1;5;76;78;8;
Subvector: 6;7;8;9;9;31;1;1;5;76;

คุณไม่ได้พูดถึงประเภทstd::vector<...> myVecใด แต่ถ้าเป็นประเภทง่ายๆหรือ struct / class ที่ไม่มีตัวชี้และคุณต้องการประสิทธิภาพที่ดีที่สุดคุณสามารถทำสำเนาหน่วยความจำโดยตรง (ซึ่งฉันคิดว่าจะเร็วกว่า ให้คำตอบอื่น ๆ ) นี่เป็นตัวอย่างทั่วไปstd::vector<type> myVecซึ่งtypeในกรณีนี้คือint:

typedef int type; //choose your custom type/struct/class
int iFirst = 100000; //first index to copy
int iLast = 101000; //last index + 1
int iLen = iLast - iFirst;
std::vector<type> newVec;
newVec.resize(iLen); //pre-allocate the space needed to write the data directly
memcpy(&newVec[0], &myVec[iFirst], iLen*sizeof(type)); //write directly to destination buffer from source buffer

คุณสามารถใช้ insert

vector<type> myVec { n_elements };

vector<type> newVec;

newVec.insert(newVec.begin(), myVec.begin() + X, myVec.begin() + Y);

คุณสามารถใช้สำเนา STLพร้อมประสิทธิภาพ O (M) เมื่อ M คือขนาดของ subvector

วิธีเดียวที่จะฉายคอลเลกชันที่ไม่ใช่เวลาเชิงเส้นคือการทำอย่างเกียจคร้านซึ่ง "เวกเตอร์" ที่เกิดขึ้นจริง ๆ แล้วเป็นประเภทย่อยที่มอบหมายให้คอลเลกชันดั้งเดิม ตัวอย่างเช่นList#subseqวิธีของ Scala สร้างลำดับย่อยในเวลาคงที่ อย่างไรก็ตามวิธีนี้ใช้ได้เฉพาะในกรณีที่คอลเล็กชันไม่มีการเปลี่ยนแปลงและถ้าคอลเลกชันขยะเป็นภาษากีฬา

โพสต์นี้ล่าช้าสำหรับคนอื่น ๆ .. ฉันเดิมพัน coder แรกเสร็จแล้ว สำหรับประเภทข้อมูลที่เรียบง่ายไม่จำเป็นต้องมีการคัดลอกเพียงแค่เปลี่ยนกลับไปใช้วิธีการรหัส C แบบเก่าที่ดี

std::vector <int>   myVec;
int *p;
// Add some data here and set start, then
p=myVec.data()+start;

จากนั้นส่งผ่านตัวชี้ p และ len ไปยังสิ่งที่ต้องการ subvector

notelen ต้องเป็น !! len < myVec.size()-start

อาจจะเป็นarray_view / spanในไลบรารี GSL อาจเป็นตัวเลือกที่ดี

ที่นี่ยังเป็นการนำไฟล์เดียว: array_view

คัดลอกองค์ประกอบจากเวกเตอร์หนึ่งไปอีกอันได้อย่างง่ายดาย
ในตัวอย่างนี้ฉันใช้เวกเตอร์ของคู่เพื่อให้ง่ายต่อการเข้าใจ
`

vector<pair<int, int> > v(n);

//we want half of elements in vector a and another half in vector b
vector<pair<lli, lli> > a(v.begin(),v.begin()+n/2);
vector<pair<lli, lli> > b(v.begin()+n/2, v.end());


//if v = [(1, 2), (2, 3), (3, 4), (4, 5), (5, 6)]
//then a = [(1, 2), (2, 3)]
//and b = [(3, 4), (4, 5), (5, 6)]

//if v = [(1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7)]
//then a = [(1, 2), (2, 3), (3, 4)]
//and b = [(4, 5), (5, 6), (6, 7)]

'
อย่างที่คุณเห็นคุณสามารถคัดลอกองค์ประกอบจากเวกเตอร์หนึ่งไปยังอีกเวกเตอร์หนึ่งได้อย่างง่ายดายหากคุณต้องการคัดลอกองค์ประกอบจากดัชนี 10 ถึง 16 เช่นนั้นเราจะใช้

vector<pair<int, int> > a(v.begin()+10, v.begin+16);

และถ้าคุณต้องการองค์ประกอบจากดัชนี 10 ถึงบางดัชนีจากจุดสิ้นสุดในกรณีนั้น

vector<pair<int, int> > a(v.begin()+10, v.end()-5);

หวังว่าสิ่งนี้จะช่วยได้โปรดจำไว้ในกรณีสุดท้าย v.end()-5 > v.begin()+10

อีกตัวเลือกหนึ่ง: มีประโยชน์เช่นเมื่อย้ายระหว่าง a thrust::device_vectorและ a thrust::host_vectorซึ่งคุณไม่สามารถใช้ตัวสร้าง

std::vector<T> newVector;
newVector.reserve(1000);
std::copy_n(&vec[100000], 1000, std::back_inserter(newVector));

ควรมีความซับซ้อน O (N)

คุณสามารถรวมสิ่งนี้กับรหัสแอนเวอร์ด้านบน

vector<T>::const_iterator first = myVec.begin() + 100000;
vector<T>::const_iterator last = myVec.begin() + 101000;
std::copy(first, last, std::back_inserter(newVector));