In many situations, the best way to store data is tables.

 
Array is the best choice when the data is densely clustered in a certain coordinate range.
For example, to store the scores of students in a class, there are 30 students in the class, numbered from 1-30, 10 courses, numbered from 1-10
Then you can use an array of 30x10 to store this score sheet, which is economical and convenient to use

But sometimes the data is very sparse. For example, a school has opened 1000 courses, and some students can choose courses at will. Now, a data structure is needed to store the scores of each student in each course.
Obviously, a student can only take more than ten courses a semester, so the data in the table is very sparse, most of the nodes are empty nodes, without data. If you use arrays, you need to allocate space in advance, not only the score table itself is very large, but also a lot of space is wasted.

At this point, you can use sparse tables.

Imagine now that there is a record of 3000 students in 1000 subjects.
Now we abstract every non empty table element into a node. Each column is strung up to form many columns, which are put into an array together. Each row is strung up to form many rows, which are put into an array together. In this way, the nodes selected from the whole dense array are weaved into a sparse net.
Just maintain and store this network

The following picture:

The attributes of the sparse table are as follows:

int rowTotalNum; / / total rows
int colTotalNum; / / total columns
LinkedList[] row; / / the pointer of the row list. The size should be the same as the following
LinkedList[] col; / / the pointer of the column list. The size should be the same as the following

The sparse table provides the following methods:

SparseTable(): constructor, initialization parameter
Void insert (int value, int rowIndex, int colIndex): inserts a value into a point (rowIndex, colIndex) of the sparse table
void remove(int rowIndex, int colIndex): delete the node of a coordinate (rowIndex, colIndex)
int getValue(int rowIndex, int colIndex): get the value of the specified coordinate (rowIndex, colIndex). If there is no such node, return - 1. There are two methods inside the method, by column and by row
void printSelfByRow(): print sparse table through row linked list
void printSelfByCol(): print sparse table through column linked list

LinkedList getCol(int colIndex): get the column list of a column
LinkedList getRow(int rowIndex): get the row list of a row

Here is the C + + Code:

#include<iostream>
#include<string>
#include<stdio.h>
using namespace std;

//Node class, representing the nodes of the linked list
class Node{
	public:
		int row;
		int col;
		int value;	//Value of storage node 
		Node* next;	//Store next node's pointer 
		
		Node(int aValue, int aRow, int aCol, Node* aNext = NULL){	//Constructor, the value of the node must be passed in, and the next node defaults to NULL
			this->value = aValue;
			this->next = aNext;
			this->row = aRow;
			this->col = aCol;
		}	
};

class LinkedList{	//Common unidirectional list class
	public:
		int length;		//The length of the linked list is not important. It is not used in the following methods, but it is maintained
		Node* head;		//Pointer to the chain header node
		Node* tail;		//Pointer to the node at the end of the list
	LinkedList(){
		length = 0;
		head = tail = 0;
	}

	//Treat the list as a list of columns, and insert the node at row row with value
	void insertToCol(int value, int row, int col){
		//Search in col where nextCol > col
		//Find the node whose coordinate is row in a column, and return the value of the previous node of the node
		//The returned results are as follows
			//1. NULL: indicates that the node is found and it is the head node, so there is no precursor node;
			//2. NULL: the list is empty
			//3. It is not empty, indicating that the precursor node is found, and the basis is that the coordinates of the successor node are larger than the coordinates to be inserted
		Node* aheadOfInsert = searchInCol(row); 
		//insertNode in that position

		//If the link list is empty and NULL is returned, the node needs to be inserted in the first position to update the head and tail
		if (aheadOfInsert == NULL && isEmpty()){
			head = tail = new Node(value, row, col);	
		}
		//If NULL is returned and the linked list is not empty, the first node should be added and the head should be updated
		else if (aheadOfInsert == NULL && !isEmpty()){
			head = new Node(value, row, col, head);
		}
		//Otherwise, insert normally
		else {
			aheadOfInsert->next = new Node(value, row, col, aheadOfInsert->next);
		}
		length++;
	}
	
	//Similarly, insert a node into the col coordinate of the row list
	void insertToRow(int value, int row, int col){
		//Search in col where nextCol > col
		Node* aheadOfInsert = searchInRow(col); 
		
		//insertNode in that position
		if (aheadOfInsert == NULL && isEmpty()){
			head = tail = new Node(value, row, col);	
		}
		else if (aheadOfInsert == NULL && !isEmpty()){
			head = new Node(value, row, col, head);
		}
		else {
			aheadOfInsert->next = new Node(value, row, col, aheadOfInsert->next);
		}
		length++;
	}
	

	//Take the current linked list as a column linked list, and delete the node whose coordinate is row
	void deleteByCol(int row, int col){
		//Search in col where nextCol > col
		//Search for the precursor node to delete
		//The returned results are as follows
			//1. NULL: indicates that the node is found and it is the head node, so there is no precursor node;
			//2. NULL: the list is empty
			//3. NULL: the node was not found
			//4. It is not empty, indicating that the precursor node is found, and the basis for finding is that the coordinates of the successor node are larger than the coordinates to be inserted, so the successor node is not necessarily the node to be deleted
		Node* aheadOfDelete = searchInCol(row);
		
		Node* deletedNode=NULL;
		//Case 1: it may be necessary to delete the head node and compare the coordinates. If it is necessary to delete it, delete the head node and update the head
		if (aheadOfDelete == NULL && !isEmpty()
			&& head->col==col && head->row==row){
			deletedNode = head;
			head = head->next;
			length--;
		}
		//Cases 2 and 3: no node found to delete, return
		else if (aheadOfDelete==NULL)
			return ;
		//Case 3: no node found to delete, return
		else if(aheadOfDelete->next == NULL)
			return ;
		//Otherwise, delete the node normally
		else if (aheadOfDelete->next->col==col && aheadOfDelete->next->row==row){
			deletedNode = aheadOfDelete->next;
			aheadOfDelete->next = aheadOfDelete->next->next;
			length--;
		}
		//Free the memory of this node
		delete deletedNode;
	}
	
	//Take the current linked list as a row linked list, and delete the node whose coordinate is col
	//Empathy
	void deleteByRow(int row, int col){
		//Search in col where nextCol > col
		Node* aheadOfDelete = searchInRow(col);
		//cout<<"deleting by row"<<endl;
		
		Node* deletedNode=NULL;
		if (aheadOfDelete == NULL && !isEmpty() 
			&& head->col==col && head->row==row){
			
			deletedNode = head;
			head = head->next;
			length--;
		}
		else if (aheadOfDelete==NULL)
			return ;
			
		else if(aheadOfDelete->next == NULL)
			return ;
		else if (aheadOfDelete->next->col==col && aheadOfDelete->next->row==row){
			deletedNode = aheadOfDelete->next;
			aheadOfDelete->next = aheadOfDelete->next->next;
			length--;
		}
		
		delete deletedNode;
	}
	
	//According to the column, find the value of the coordinate (row, col)
	int getValueByCol(int row, int col){
		//Search in col where nextCol > col
		//Search for the precursor node to find
		//The returned results are as follows
			//1. NULL: this node is found and it is the head node, so there is no precursor node;
			//2. NULL: this node is not found, which means that the list is not empty but NULL is returned;
			//3. NULL: the list is empty
			//4. NULL: the node was not found
			//5. It is not empty, indicating that the precursor node is found, and the basis for finding is that the coordinates of the successor node are larger than the coordinates to be inserted, so the successor node is not necessarily the node to be deleted
		
		Node* aheadOfNode = searchInCol(row);
		
		//Situation 1
		if (aheadOfNode == NULL && !isEmpty()
			&& head->col==col && head->row==row){
			return head->value;
		}
		//Situation 2
		else if (aheadOfNode == NULL && !isEmpty())
			return -1;
		//Situation 3
		else if (aheadOfNode==NULL && isEmpty())
			return -1;
		//Situation 4
		else if(aheadOfNode->next == NULL)
			return -1;
		//Situation 5
		else if (aheadOfNode->next->col==col && aheadOfNode->next->row==row){
			return aheadOfNode->next->value;
		}
		return -1;
	}

	//Find the value of the coordinate (row, col) according to the row
	int getValueByRow(int row, int col){
		//Search in col where nextCol > col
		//Search for the precursor node to find
		//The returned results are as follows
			//1. NULL: indicates that the node is found and it is the head node, so there is no precursor node;
			//2. NULL: the list is empty
			//3. NULL: the node was not found
			//4. It is not empty, indicating that the precursor node is found, and the basis for finding is that the coordinates of the successor node are larger than the coordinates to be inserted, so the successor node is not necessarily the node to be deleted
		
		Node* aheadOfNode = searchInRow(col);
		
		//Situation 1
		if (aheadOfNode == NULL && !isEmpty()
			&& head->col==col && head->row==row){
			return head->value;
		}
		//Situation 2
		else if (aheadOfNode == NULL && !isEmpty())
			return -1;
		//Situation 3
		else if (aheadOfNode==NULL && isEmpty())
			return -1;
		//Situation 4
		else if(aheadOfNode->next == NULL)
			return -1;
		//Situation 5
		else if (aheadOfNode->next->col==col && aheadOfNode->next->row==row){
			return aheadOfNode->next->value;
		}
		return -1;
	}
	
	
	//Take the current linked list as a column linked list and search the node whose row coordinate is row
	Node* searchInCol(int row){
		//return NULL if list is empty; 
		//If the link list is empty or the row coordinate of the head node is greater than the row coordinate of the node to be searched, return null
		if (isEmpty() || head->row>=row)
			return NULL;
		Node* now;
		//Loop lookup
		//There are two conditions for cycle termination:
			//1. At the end of the list, it is still not found. Corresponding to now - > next! = null
			//2. The row coordinate of the next node is smaller than the row coordinate to be searched, corresponding to now - > next - > row < row
		for (now=head; now->next!=NULL && now->next->row<row; now=now->next);
		return now;
	}

	//Empathy
	//Take the current linked list as a row linked list, and search for nodes whose column coordinates are row
	Node* searchInRow(int col){
		//return NULL if list is empty; 
		if (isEmpty() || head->col>=col)
			return NULL;
		Node* now;
		for (now=head; now->next!=NULL && now->next->col<col; now=now->next);
		return now;
	}

	
	
	int isEmpty(){			//Judge whether the chain list is empty or not. If the head pointer is 0, it means empty
		return head == 0;
	}	
	
	void printSelf(){	//Print linked list content	
		
	}
	
};

//Sparse table
class SparseTable{
	public:
	int rowTotalNum;	//Total number of banks
	int colTotalNum;	//Total column number
	LinkedList* row[500];	//The pointer of the row list. The size should be the same as the following
	LinkedList* col[500];	//Pointer to the column list, the size should be consistent with the following
	
	//Construction method
	SparseTable(){
		rowTotalNum = 500;
		colTotalNum = 500;
		for (int i=0; i<rowTotalNum; i++)
			row[i] = new LinkedList();
		for (int i=0; i<colTotalNum; i++)
			col[i] = new LinkedList();
	}
	//Insert value value into a point (rowIndex, colIndex) of sparse table
	void insert(int value ,int rowIndex, int colIndex){
		if (rowIndex >= rowTotalNum || colIndex >= colTotalNum)
			return ;
		if(getValue(rowIndex, colIndex) != -1)
			return ; 
		//Insert nodes into row list and column list respectively
		row[rowIndex]->insertToRow(value, rowIndex, colIndex);
		col[colIndex]->insertToCol(value, rowIndex, colIndex);
	}
	
	//Delete a node of a coordinate (rowIndex, colIndex)
	void remove(int rowIndex, int colIndex){
		if (rowIndex >= rowTotalNum || colIndex >= colTotalNum)
			return ;
		//Delete nodes on row and column lists
		row[rowIndex]->deleteByRow(rowIndex, colIndex);
		col[colIndex]->deleteByCol(rowIndex, colIndex);
	}

	//Get the value of the specified coordinate (rowIndex, colIndex)
	//If there is no such node, return - 1
	//There are two ways to do this, by column and by row
	int getValue(int rowIndex, int colIndex){
		if (rowIndex >= rowTotalNum || colIndex >= colTotalNum)
			return -1;
		//return col[colIndex]->getValueByCol(rowIndex, colIndex);
		return row[rowIndex]->getValueByRow(rowIndex, colIndex);
	}

	//Print sparse table through row linked list
	void printSelfByRow(){
		cout<<"By row--------------------------"<<endl;
		for (int i=0;i<=10;i++){
			for(Node* now=row[i]->head; now!=NULL; now=now->next){
				cout<<"("<<now->row<<", "<<now->col<<"): "<<now->value<<" ";
			}
			cout<<endl;
		}
	}

	//Printing sparse tables with column linked lists
	void printSelfByCol(){
		cout<<"By col--------------------------"<<endl;
		for (int i=0;i<=5;i++){
			for(Node* now=col[i]->head; now!=NULL; now=now->next){
				cout<<"("<<now->row<<", "<<now->col<<"): "<<now->value<<" ";
			}
			cout<<endl;
		}
		
	}

	//Get column list of a column
	LinkedList* getCol(int colIndex){
		return col[colIndex];
	}
	//Get row list of a row
	LinkedList* getRow(int rowIndex){
		return row[rowIndex];
	}
	
};

//Test program
int main(){

	SparseTable* st = new SparseTable();
	st->insert(1,1,2);
	st->insert(2,1,3);
	
	st->insert(3,2,4);
	st->insert(4,3,3);
	st->insert(44,3,5);
	st->insert(42,3,2);
	st->insert(42,3,2);
	st->printSelfByRow();
	st->printSelfByCol();
	
	
	st->remove(2,4);
	st->remove(2,4);
	st->printSelfByRow();
	st->printSelfByCol();

	st->remove(1,2);
	st->printSelfByRow();
	st->printSelfByCol();

	cout<<"Get value: (3,5)"<<st->getValue(3,5)<<endl;
	cout<<"Get value: (3,4)"<<st->getValue(3,4)<<endl;
	cout<<"Get value: (3,2)"<<st->getValue(3,2)<<endl;
}