Insert and Remove Arrays elements

Нужно дополнить 2 функции инсерт и ремов , Программа будет работать так создавать массивы с местами степени 2 и заполнять его , пример в картинке

header file

#pragma once
class SA
{
    struct Node {
        int*    base_;
        int     size_;
        Node*   next_;
        Node(int* base = 0, int size = 0, Node* next = 0) :
            base_(base), size_(size), next_(next) {}
        ~Node() { delete[]base_; }
    };
    struct Position {
        Node*   ptr_;
        int     index_;
        Position(Node* ptr = 0, int index = -1) : ptr_(ptr), index_(index) {}
    };
    //AUXILIARY FUNCTINS
    //returns index of the key found (or -1, if there is no such a key in array)  
    static  int         binarySearch(int* base, int size, int key);
    //merges two sorted arrays of the same size and returns the location of the resulting array of double size 
    static  int*        merge(int* first, int* second, int size);
    //returns (node, index) pair (or (0, -1), if there is no such a key in the structure 
    Position            search1(int key)const;
    Node head_;
public:
    SA();
    ~SA();
    /*1*/   bool    search(int key)const;
    /*2*/   void    insert(int key);
    /*3*/   void    remove(int key);
    void    print()const;
};

cpp file

#include "stdafx.h"
#include "SA.h"
#include <iostream>
using namespace std;
SA::SA() {
    head_.next_ = 0;
}
SA::~SA() {
    Node* ptr;
    while (head_.next_ != 0) {
        ptr = head_.next_;
        head_.next_ = ptr->next_;
        delete ptr;
    }
}
int
SA::binarySearch(int* base, int size, int key) {
    int left = 0, right = size - 1, mid;
    while (left <= right) {
        mid = (left + right) / 2;
        if (key == base[mid]) return mid;
        (key < base[mid]) ? right = mid - 1 : left = mid + 1;
    }
    return -1;
}
int*
SA::merge(int* base1, int* base2, int size) {
    int* result = new int[size << 1];
    int i = 0, j = 0, k = -1;
    while (i < size && j < size)
        result[++k] = (base1[i] <= base2[j]) ? base1[i++] : base2[j++];
    while (i < size)
        result[++k] = base1[i++];
    while (j < size)
        result[++k] = base2[j++];
    delete[]base1;
    return result;
}
void
SA::print()const {
    int i;
    for (Node* ptr = head_.next_; ptr != 0; ptr = ptr->next_) {
        cout << ptr->size_ << ": ";
        for (i = 0; i < ptr->size_; i++)
            cout << ptr->base_[i] << ' ';
        cout << endl;
    }
    cout << endl;
}
SA::Position
SA::search1(int key)const {
    int index;
    for (Node* ptr = head_.next_; ptr != 0; ptr = ptr->next_) {
        index = binarySearch(ptr->base_, ptr->size_, key);
        if (index != -1)
            return Position(ptr, index);
    }
    return Position(0, -1);
}
bool
SA::search(int key)const {
    return search1(key).ptr_ != 0;
}
void
SA::insert(int key) {
    //. . . should be implemented . . . 
}

void
SA::remove(int key) {
    //. . . should be implemented . . .
}