Question

我正在编写使用链表存储稀疏矩阵的程序。首先我创建一个类“Node”包含条目索引，条目值和下一行和下一列的两个指针。其次我在Google上发现我需要像下面的代码一样创建类Matrix，但我不理解Node **rowList和node** columnList的含义。为什么他们使用指向那里的指针，我怎么能从那里实现矩阵？非常感谢你。

class Node
{
public:
    int iValue, jValue;
    float value;
    Node *rowPtr;
    Node *colPtr;
};

class Matrix
{
    Node **rowList;     // rowList is the pointer to the array of rows
    Node **columnList;  // columnList is the pointer to the array of columns
    int rows, cols;     // number of rows and columns
}

Answer 1

这似乎正是评论所说的。它们是数组。据推测，rowList将是rows元素的数组，而columnList将是cols元素的数组。它是Node**的原因是数组中的每个项目都是Node*。指向数组的指针总是具有额外的间接级别（额外的*）。这意味着当您从该数组中索引单个元素时，您将再次获得类型Node*的值。

数组的创建方式如下：

rowList = new Node* [rows];
columnList = new Node* [cols];

// Don't forget to initialise the values to NULL!  Here's the dull way:
for( int i = 0; i < rows; i++ ) rowList[i] = NULL;
for( int i = 0; i < cols; i++ ) columnList[i] = NULL;

当您需要删除它们时（在Matrix的析构函数中）：

delete [] rowList;
delete [] colList;

关于如何从中实现矩阵的问题，这完全取决于您。假设您在位置(i, j)处创建节点时，会将该节点附加到rowList和columnList中的每个节点。即：

Node * node = new Node(i, j, 123.0);
rowList[i] = node;
columnList[j] = node;

但事情并非如此简单，因为显然必须将节点链接到行列列表中。在最基本的层面，并使用您提供的结构，这是一种方式：

// Inserts newNode at the head of the list and modifies the head pointer.
void insert_row( Node* & r, Node *newNode )
{
    newNode->rowPtr = r;
    if( r != NULL ) r->rowPtr = newNode;
    r = newNode;
}

// Similarly with insert_col()...

现在使用上面的原始示例：

Node * node = new Node(i, j, 123.0);
insert_row( rowList[i], node );
insert_col( columnList[j], node );

对于有序插入

由于你已经拥有代码，我将提供我的服务。但是你仍然需要自己做一些工作。

我只是试着去了解这个概念，但这对我来说太困惑了。

让我们开始干净。这是一个类，你正在使用C ++，所以请使用你的C ++知识：

class Node
{
public:
    Node( int i, int j, int val );

    void InsertRowAfter( Node* node );
    void InsertColAfter( Node* node );

    int iValue, jValue;  // Row and column index, 1-based
    float value;         // Element value
    Node *rowPtr;        // Next element in this row (sorted by jValue)
    Node *colPtr;        // Next element in this column (sorted by iValue)
};

Node::Node( int i, int j, int val )
    : iValue(i)
    , jValue(j)
    , value(val)
    , rowPtr(NULL)
    , colPtr(NULL)
{}

// Inserts the given node to follow this node in the row list
void Node::InsertRowAfter( Node* node )
{
    // [go on, you do it]
}

// Inserts the given node to follow this node in the column list
void Node::InsertColAfter( Node* node );
{
    // [go on, you do it]
}

所以，现在你需要实现Matrix::inputData函数......基本上你做了你的朋友试图做的事情，但没有错误和内存泄漏。这意味着你要这样开始：

// Use 'horz' and 'vert' to search through the row and column lists.  If a
// node needs to be created, it will be stored in 'node'.
Node *horz = rowList[iValue - 1];
Node *vert = columnList[jValue - 1];
Node *node;

// If there is no row list or smallest jValue, insert at the head.
// Otherwise, search for an insert point.
if( !horz || horz->jValue > jValue )
{
    // [go on, you do it]
}
else
{
    // Move 'horz' pointer to position at which we will append a node.
    Node *next = horz->rowPtr;
    while( next && next->jValue <= jValue ) {
        horz = next;
        next = next->rowPtr;
    }

    // If replacing an existing value, there's nothing else to do.
    if( horz->jValue == jValue ) {
        horz->value = value;
        return;
    }

    // Otherwise append a new node.
    // [go on, you do it]
}

现在，您关闭了该功能，并且不要忘记进行列索引...

使用链表C ++的稀疏矩阵

1 个答案:

对于有序插入