矩阵和散列表

目的：
1、创建三对角矩阵类，采用按列映射方式，提供 store 和 retrieve 方法。
2、创建下三角矩阵类，采用按列映射方式，提供 store 和 retrieve 方法。
3、创建稀疏矩阵类，采用行主顺序把稀疏矩阵映射到一维数组中，实现稀疏矩阵的转置和两个稀疏矩阵的加法操作。
4、使用散列表设计实现一个字典，假设关键字为整数且 D 为 961，在字典 中插入随机产生的 500 个不同的整数，实现字典的建立和搜索操作。分别使 用线性开型寻址和链表散列解决溢出。

创建特殊矩阵类的重点就是分析矩阵中位置在一维数组中的映射方式，根据公式就可以计算出元素存放的位置。可以先假设n为一个比较小的定值，并画出数组中的位置在矩阵内元素上的编号，通过带入求解公式。
在这次的目的中，我们都采用按列映射方式，输入位置不对就抛出MustBeZero异常。
三对角矩阵：使用列主映射保存元素在大小为3*n-2的数组中，如果行列之差的绝对值大于1就抛出异常，如果能存储就存在数组中2*column+row-3的位置上。
下三角矩阵：使用列主映射保存元素在大小为n*(n-1)/2的数组中，如果列数比行数小就抛出异常，如果能存储就存储在数组中column*(2*n-column + 1)/2-(n-row)-1的位置上。

稀疏矩阵是矩阵中多数元素为0的矩阵，在这里我们采用自定义类型存储它的一个元素。

template<class T>
class Term
{
    friend SparseMatrix;
private:
    int row, column;
    T value;
};

存储时使用行主映射，保存元素的行、列、值，行数小的在前面，行数相同列数小的在前面。

转置时，设置两个数组，一个(ColSize)用来记录每一列的元素数量，另一个(RowNext)记录通过元素数量计算出的每一行的开始位置，再把矩阵中的所有元素按照相应的列顺序放到新矩阵的行位置上，并把元素的行和列交换保存，每放一个元素相应行开始位置(RowNext)就加一，直到把所有元素全部放入新矩阵。

template<class T>
void SparseMatrix::Transpose(SparseMatrix& b) const
{//对*this进行转置，转置后的矩阵存储在b中
    if (terms > b.MaxTerms) throw NoMem();

    b.rows = columns;
    b.columns = rows;
    b.terms = terms;

    int *ColSize, *RowNext;
    ColSize = new int[columns + 1];
    RowNext = new int[columns + 1];

    //计算每一列的元素数量
    for (int i = 1; i <= columns; i++)
        ColSize[i] = 0;
    for (int i = 0; i < terms; i++)
        ColSize[a[i].column]++;

    //计算每一行的开始位置
    RowNext[1] = 0;
    for (int i = 2; i <= columns; i++)
        RowNext[i] = RowNext[i - 1] + ColSize[i - 1];

    for (int i = 0; i < terms; i++) {
        int j = RowNext[a[i].column]; //b中a[i]的位置,a是Term的数组
        RowNext[a[i].column]++;
        b.a[j].column = a[i].row;
        b.a[j].row = a[i].column;
        b.a[j].value = a[i].value;
    }

    delete[] ColSize;
    delete[] RowNext;
}

矩阵加法先检查两个矩阵是否同行同列，不是则抛出异常，是则设置两个指针指向两个相加矩阵的第一项元素；分别计算两个指针所指的位置的行主索引值，把索引值小的添加放到新矩阵最后，并把相应指针向后移一位；如果相等，在和不为0的情况下，把和加到新矩阵最后，和为0则不添加元素，并把两个指针都向后移一位，直到把两个矩阵中的数据添加完。

template
void SparseMatrix::Add(const SparseMatrix& b, SparseMatrix& c) const
{//将*this与b相加，得到的矩阵存在c中
    if (rows != b.rows || columns != b.columns)
        throw SizeMismatch();   //矩阵不兼容

    //设置矩阵c的特征
    c.rows = rows;
    c.columns = columns;
    c.terms = 0; //初始化项数

    //定义到*this和b的指针
    int ct = 0, cb = 0;

    //移动*this和b的指针
    while (ct < terms && cb < b.terms) {
        //计算项的行主索引值
        int it = a[ct].row * columns + a[ct].column;
        int ib = b.a[cb].row * columns + b.a[cb].column;

        if (it < ib) {
            c.Append(a[ct]);
            ct++;
        }
        else if (it == ib) {
            if (a[ct].value + b.a[cb].value) { 
                //如果相加不为0，则加到c后面
                Term temp;
                temp.column = a[ct].column;
                temp.row = a[ct].row;
                temp.value = a[ct].value + b.a[cb].value;
                c.Append(temp);
            }
            ct++;
            cb++;
        }
        else {
            c.Append(b.a[cb]);
            cb++;
        }
    }

    for (; ct < terms; ct++)
        c.Append(a[ct]);
    for (; cb < b.terms; cb++)
        c.Append(b.a[cb]);
}

散列表：线性开型寻址表通过数组存储元素。保存时先在模哈希函数的除数的余数位置寻找，如果位置为空则直接保存，如果位置不为空则线性向后查找空位，如果找到就将元素保存在空位中，如果一直查找到最初的位置还查找不到空位说明表满了，抛出异常。查找时模哈希函数的除数的余数位置寻找，如果位置为空就说明找不到，如果位置上不是该元素就向后查找，如果找到了空位，说明元素没有存进散列表，如果能找到说明元素存进了散列表。
链表实现的散列表通过链表保存元素。保存时在模哈希函数的除数的余数位置的链表上尝试插入，如果能找到抛出异常，如果找不到把它保存在键值比它大的元素的前一个。查找时在模哈希函数的除数的余数位置的链表上直接一个个搜索，如果找不到说明不在散列表中。
插入时使用rand()函数生成随机数，当数据重复时捕获异常并将再一次生成随机数，一直到满500个随机数被放入为止。

源代码：MatrixAndHashTable.zip