C++ 병합, 결합, 벡터의 두 객체를 새로운 세 번째 객체에 교차시키는 방법?

Question

저는 Vector에 대해 배웠고 일부분을 마칠 수 없습니다. 내 코드 및 아래에 대한 설명. 출력은 다음과 같아야

가

b1 size = 0 
b1 beginning capacity = 10 
b1 empty? 1 

b2 size = 0 
b2 beginning capacity = 10 
b2 empty? 1 

b1 : [] 
b2 : [ 2 4 6 8 10 12 14 16 18 20 ] 
b1 + b2 : [ 2 4 6 8 10 12 14 16 18 20 ] // not working 

b2 duplicate : [ 1 2 2 4 4 6 6 8 8 10 12 14 16 18 20 ] // not working 
b2 remove duplicate : [ 1 2 4 6 8 10 12 14 16 18 20 ] // not working 

b1 : [ 1 2 3 4 5 6 7 8 9 ] 
b1 size : 9 
b1 capacity : 10 
b2 : [ 1 2 4 6 8 10 12 14 16 18 20 ] 
b2 size = 11 
b2 capacity = 20 

b1+b2 : [ 1 2 3 4 5 6 7 8 9 1 2 4 6 8 10 12 14 16 18 20 ] // nw 
b1-b2 : [ 3 5 7 9]          // nw 
b1 union b2 : [ 1 2 3 4 5 6 7 8 9 10 12 14 16 18 20 ]  // nw 
b1 intersect b2 : [ 1 2 4 6 8 ]       // nw 

b3+b4 : [ 3 5 7 9 3 5 7 9 ] // nw 
b3-b4 : []     // nw 
b3 union b4 : [ 3 5 7 9 ]  // nw 
b3 intersect b4 : [ 3 5 7 9 ] // nw 

골격 부 여기 붙어

#include "MyNumber.cpp" 
#include <iostream> 
#include <string> 
#include <sstream> 
#include <stdexcept> 
#include <algorithm> 

using namespace std; 

template <typename B> 
class MyNumber 
{ 
private : 
    static const size_t BEGINNING_CAPACITY =10; 
    size_t _capacity;   
    size_t _size;  
    B* _data; // array' element 

public : 
    // Constructor 
    MyNumber<B>() : _capacity(BEGINNING_CAPACITY), 
       _size(0), 
        _data(new B[BEGINNING_CAPACITY]) 
    {} 

    //Destructor 
    ~MyNumber<B>() 
    { 
     delete[] _data; 
    } 

    //Copy Constructor 
    MyNumber<B>(const MyNumber<B>& OtherNumber) : 
        _capacity(OtherNumber._capacity), 
        _size(OtherNumber._size), 
        _data(new B[_capacity]) 
    { 
     for(size_t i = 0; i < _size; i++) 
      _data[i] = OtherNumber._data[i]; 
    } 

    // template function swap STL algorithm 
    void swap(MyNumber<B>& OtherNumber) 
    { 
     swap(_size, OtherNumber._size); 
     swap(_capacity, OtherNumber._capacity); 
     swap(_data, OtherNumber._data); 
    } 

    MyNumber<B>& operator= (const MyNumber<B>& OtherNumber) 
    { 

     MyNumber<B> copy(OtherNumber); 
     exchange(copy); 
     return *this; 
    } 

    // Operator indexing [] 
    B& operator[] (size_t index) 
    { 
     if(index < 0 || index >= _size) 
     { 
      throw out_of_range("Index operator [] out of range"); 
     } 
     return _data[index]; 
    } 

    //Function for adding new element 
    void push_back(const B& elemen) 
    { 
     if(_size == _capacity) 
     { 
      expand(2 *_capacity); 
     } 
     _data[_size] = elemen; 
     _size++; 
    } 

    //Function for inserting 
    void insert(size_t index, const B& elemen) 
    { 
     if(index < 0 || index > _size) 
     { 
      throw out_of_range("index insert out of range"); 
     } 
     if(_size == _capacity) 
     { 
      expand(2 * _capacity); 
     } 

     for(size_t i = _size; i > index; i--) 
     { 
      _data[i] = _data[i-1]; 
     } 
     _data[index] = elemen; 
     _size++; 
    } 

    //Function for expanding the size of capacity 
    void expand(size_t newCapacity) 
    { 
     _capacity = newCapacity; 
     B* newData = new B[newCapacity]; 
     for(size_t i = 0; i < _size; i++) 
      newData[i] = _data[i]; 
     delete[] _data; 
     _data = newData; 
    } 

    //Funtion for returning capacity 
    size_t capacity() 
    { 
     return _capacity; 
    } 

    //Function for returning size 
    size_t size() 
    { 
     return _size; 
    } 

    //Function for checking the vector 
    bool empty() 
    { 
     return _size == 0; 
    } 

    //Function for representing the vector 
    string toString() 
    { 
     ostringstream oss; 
     oss << "[ "; 
     for(int i = 0; i < _size; ++i) 
      oss << _data[i] << " "; 
     oss << "]"; 
     return oss.str(); 
    } 

    //Function for searching particular element 
    int find(const B& elemen){ 
     for(int i=0;i<_size;i++){ 
      if(_data[i] == elemen) 
       return i; 
     } 
     string exception = "Data not found!"; 
     throw exception;} 

: 여기서

#include RunMyNumber.cpp 


int main() { 
MyNumber<int> b1; 
cout << "b1 size = " << b1.size() << endl; 
cout << "b1 beginning capacity = " << b1.capacity() << endl; 
cout << "b1 empty? " << b1.empty() << endl << endl; 

MyNumber<int> b2; 
cout << "b2 size = " << b2.size() << endl; 
cout << "b2 beginning capacity = " << b2.capacity() << endl; 
cout << "b2 empty? " << b2.empty() << endl << endl; 

for(int i=1;i<=10;i++) 
{ 
    b2.push_back(i*2); 
} 

cout << "b1 : " << b1.toString() << endl; 
cout << "b2 : " << b2.toString() << endl; 

cout << "b1 + b2 : " << (b1 + b2).toString() << endl << endl; 

for(int i=1;i<10;i++) 
{ 
    b1.push_back(i); 
} 

for(int i=0;i<4;i++){ 
    b2.duplicate(i+i,1); 
} 

b2.insert(0,1); 
cout << "b2 duplicate : " << b2.toString() << endl; 

b2.removeDuplicate(); 
cout << "b2 remove duplicate : " << b2.toString() << endl << endl; 

cout << "b1 : " << b1.toString() << endl; 
cout << "b1 size = " << b1.size() << endl; 
cout << "b1 capacity = " << b1.capacity() << endl; 
cout << "b2 : " << b2.toString() << endl; 
cout << "b2 size = " << b2.size() << endl; 
cout << "b2 capacity = " << b2.capacity() << endl << endl; 

cout << "b1 + b2 : " << (b1 + b2).toString() << endl; 
cout << "b1 - b2 : " << (b1 - b2).toString() << endl; 
cout << "b1 union b2 : " << b1.myUnion(b2).toString() << endl; 
cout << "b1 intersect b2 : " << b1.myIntersect(b2).toString() << endl << endl; 

MyNumber<int> b3; 
b3 = b1 - b2; 

MyNumber<int> b4(b3); 
cout << "b3 : " << b3.toString() << endl; 
cout << "b4 : " << b4.toString() << endl << endl; 

MyNumber<int> b5; 
b5 = b3 + b4; 
cout << "b3 + b4 : " << b5.toString() << endl; 
b5 = b3 - b4; 
cout << "b3 - b4 : " << b5.toString() << endl; 
cout << "b3 union b4 : " << b3.myUnion(b4).toString() << endl; 
cout << "b3 intersect b4 : " << b3.myIntersect(b4).toString() << endl << endl; 

return 0; 
    } 

가 원경 코드 연산자 +에 (두 병합 벡터), 연산자 - (초에 존재하지 않는 첫 번째 벡터의 숫자를 표시), 합집합, 교차. 또한, b1과 b2의 이전 연산의 결과로 새로운 벡터의 객체 (3 번째와 4 번째)를 만드는 방법을 모르겠습니다.

MyNumber<B>& operator+ (MyNumber<B>& OtherNumber) 
    {auto cmp = [] (const B& b1, const B& b2) { return b1.value() < b2.value() ; } ; 
     sort(MyNumber.begin(), MyNumber.end(), cmp) ; // sort first on ascending v 
     sort(OtherNumber.begin(), OtherNumber.end(), cmp) ; // sort second on ascending v 
     merge(MyNumber.begin(), MyNumber.end(), OtherNumber.begin(), OtherNumber.end(), 
     back_inserter(b3??), cmp) ; // merge first and second into third 

    // append contents of second to first 
     MyNumber.insert(MyNumber.end(), OtherNumber.begin(), OtherNumber.end()) ; 

    // sort first on descending length of str 
     sort(MyNumber.begin(), MyNumber.end(), 
      [] (const B& b1, const B& b2) { return b1.str().size() > b2.str().size() ; }) ; 

    } 

    MyNumber<B>& operator- (MyNumber<B>& OtherNumber) 
      { 

    } 

      void duplicate(size_t index, size_t n) 
      { 
      } 

      void removeDuplicate() 
      { 
      } 
    MyNumber<B>& myUnion(MyNumber<B>& OtherNumber) 
    { 
     vec_union(MyNumber<B> &, OtherNumber) 
     { 
      if (OtherNumber.empty()) 
      return MyNumber; 

      MyNumber<B>::iterator found = find(MyNumber.begin(), MyNumber.end(), OtherNumber.back()); 
      if (found == MyNumber.end()) 
      { 
        // all good, element not already in v1, so insert it. 
       B value = OtherNumber.back(); 
       MyNumber.push_back(value); 
        OtherNumber.pop_back(); // remove back element 
        return vec_union(MyNumber, OtherNumber); 
      } 
      else 
      { 
        // element was already in v1, skip it and call vec_union again 
      OtherNumber.pop_back(); // remove back element 
       return vec_union(MyNumber, OtherNumber); 
      } 
     } 
    } 

      MyNumber<B>& myIntersect(MyNumber<B>& OtherNumber){ 
      } 







}; 

Answer 1

벡터가 항상 정렬되는 경우 다음 알고리즘을 사용하여 O (N) 시간에 병합 할 수 있습니다.

초기화 I1 = 0, V1을 감산 I2 = 0

while (I1 < V1.size() || I2 < V2.size()) 
    if (V1[I1] == V2[I2]) { 
    newVec.push_back(V1[I1]); // if duplicates are to be entered, then push back twice. 
    I1++; 
    I2++; 
    } else if (V1[I1] < V2[I2]) { // or I2 == V2.size() 
    newVec.push_back(V1[I1]); 
    I1++; 
    } else { // or I1 == V1.size() 
    newVec.push_back(V2[I2]); 
    I2++; 
    } 

- V2 또한 유사한 알고리즘을 적용 할 수있다.
경고 : 나는 이러한 알고리즘 중 하나를 선택하지 않은, 그들이 어떤 디버깅이나 사소한 조작

초기화 I1 = 0, I2를해야 할 수도 있습니다 = 0 논의한 바와 같이

while (I1 < V1.size()) //|| I2 < V2.size()) (No need to iterate till end of V2) 
    if (V1[I1] == V2[I2]) { 
    //newVec.push_back(V1[I1]); // Don't push back if element is common. 
    I1++; 
    I2++; 
    } else if (V1[I1] < V2[I2]) { // or I2 == V2.size() 
    newVec.push_back(V1[I1]); 
    I1++; 
    } else { // or I1 == V1.size() 
    //newVec.push_back(V2[I2]); 
    I2++; 
    } 

Answer 2

, 당신이 원하는 Set operations 개념을 구현합니다. 요소의 원본 순서와 사본을 보존해야하는지 결정하십시오 (샘플 출력이 제시하는대로). 그렇다면 벡터를 그대로 유지하고 작업 중에 임시 세트 (정렬 된 MyNumber)를 구성하십시오. 이는 비효율적이지만 유효합니다. 효율성을 처리하기 위해보다 정교한 데이터 구조가 필요할 수 있습니다. 그렇지 않으면 MyNumber를 항상 정렬하고 find()에서 이진 검색을 사용하십시오.

다음, 연산자로 + - + = (운영자 유사한 =)

MyNumber<B> operator+ (const MyNumber<B>& OtherNumber) 
{ 
    MyNumber<B> result(*this); 
    result += OtherNumber; 
    return result; 
} 

그럼 + =와 push_back와

가

MyNumber<B>& operator+= (MyNumber<B>& OtherNumber) 
{ 
    // todo expand() once 
    for (size_t i = 0; i < OtherNumber.size(); ++i) 
    push_back(OtherNumber[i]); 
    return *this; 
} 

주 구현 오퍼레이터의 관점에서 구현 연산자 + = 복귀 MyNumber & 그런 하지만 operator +는 MyNumber를 반환합니다.

또한 값이 컨테이너에없는 경우 오류가 아니기 때문에 find()에서 throw하지 않는 것이 더 좋습니다. stl처럼 C 또는 size() 에서처럼 잘못된 인덱스를 반환하는 것이 좋습니다.