稀疏矩阵和矩阵

Question

我需要一个程序，它允许阵列中的任何条目中的用户随机读取访问帮助。如果用户试图在有用区域之外读取，则数据结构应该返回0.另外，它允许用户只对有用区域进行随机写入访问。如果用户尝试在应该为0的数组部分写入内容，请输出错误消息。 除了程序应该具有的构造函数，取阵列参数作为唯一的输入并初始化所有的阵列的为0。第二个构造应另外作为输入整数数组其值复制到正在制作的阵列的有用部分。

这是数组

[ 0 0 0 0 ... 0 0 1 2 3 4 5 0 0 .... 0 0 ] 

的我不知道如何创建稀疏阵，也是我不希望使用现有的库形式。

我试图创建一个动态数组，它采用超载运营商，但我的问题是，我甚至不知道什么是稀疏阵以及如何创建它。

#include <iostream> 

using namespace std; 

class MyArray 
{ 
    friend ostream& operator<< (ostream &os, MyArray &array); 

    public: 
     MyArray (int size); 
     MyArray (const MyArray &rhs); 
     ~MyArray(); 

     MyArray& operator= (const MyArray& rhs); 
     int& operator[] (int index); 
     int read_element (int index); 
     void write_element (int index, int value); 

    private: 
     int *storage; 
     int size; 
}; 

#include "sparse_array_1d.h" 

MyArray::MyArray (int size) 
{ 
    storage = new int[size]; 
    this->size = size; 
} 

MyArray::MyArray (const MyArray &rhs) 
{ 
    size = rhs.size; 
    storage = new int[size]; 
    (*this) = rhs; 
} 

MyArray::~MyArray() 
{ 
    delete [] storage; 
} 

int MyArray::read_element (int index) 
{ 
    return storage[index]; 
} 

void MyArray::write_element (int index, int value) 
{ 
    storage[index] = value; 
} 

MyArray& MyArray::operator= (const MyArray &rhs) 
{ 
    int i,min_size; 

    if (size < rhs.size) 
     min_size = size; 
    else 
     min_size = rhs.size; 

    for (i=0; i<min_size; i++) 
     storage[i] = rhs.storage[i]; 

    return (*this); 
} 

int& MyArray::operator[] (int index) 
{ 
    if (index < size && index >=0) 
     return storage[index]; 

    return storage[0]; 
} 

ostream& operator<< (ostream &os, MyArray &array) 
{ 
    int i; 

    os << "[ "; 

    for (i=0; i<array.size; i++) 
     os << array[i] << " "; 

    os << "]" << endl; 
    return os; 
} 

#include <iostream> 
#include "sparse_array_1d.h" 

using namespace std; 

int main() 
{ 
    int i,size; 

    cout << "What array sizes would you like?" << endl; 
    cin >> size; 

    MyArray p1 (size); 

    //int q=1; 
    for (i=0; i<size; i++) 
    { 
     p1[i] = 0; 
     //q++; 
    } 

    cout << "p1: " << endl; 
    cout << p1; 

    int x; 

    cout << endl; 
    cout << "enter numbers : " << endl; 

    for (i=0 ; i<size; i++) 
    { 
     cin >> p1[i]; 
    } 

    cout << "This is the array" << endl; 
    cout << p1; 
    cout << endl; 

    return 0; 
} 

Answer 1

我认为Vector类加上一些if应该做你想要的一切，无需重新创建它。 您可以使用两个矢量，一个用于存储元素，另一个用于存储它们的位置。

vector<int> values,positions; 
int c,success; 

cout<<"Insert element"<<endl; 
cin>>c; 
positions.push_back(c); 
cout<<"Insert value"<<endl; 
cin>>c; 
values.push_back(c); 

cout<<"Which element you want to read?"<<endl; 
cin>>c; 
success=0; 
for(int i=0;i<values.size();;i++){ 
if(positions[i]==c){ 
cout<<values[i]<<endl; 
success=1; 
} 
if(success==0) 
cout<<"Out of bounds: 0"<<endl; 

Answer 2

有趣的是，我相信我们是在同一班。但是听着，当您将数组动态初始化为某个用户选择的大小（int N;）和全零时，您可能已经创建了稀疏数组。

既然你立刻充满所有的N个元素是零，你开始你的稀疏阵列。在第一次完成你的构造函数后，你的析构函数会自动（如果你创建了一个）清除数组中的所有内存。所以你有一个N个元素的插槽可以接收N个元素。但是，在此之前，所有N个元素插槽区域基本上都是空的，因此不使用内存。但数组仍然存在，因此您的稀疏数组。