《数据结构和算法分析C++版》第三版部分习题（1-3章）

1.2 编程实现大数加法，乘法，和指数操作
乘法采用了快速乘法的算法

#include
#include
#include
#define Abs(x) ((x)>0?(x):-(x))
#define Min(x,y) ((x)>(y)?(y):(x))
using namespace std;
//以下大数运算都不涉及小数，大数指数操作的底数和指数都是正整数。
string pluss(string x, string y);   //大数加法
string subtra(string x, string y);  //大数减法
string inverse(string str); //把数字反转，比如123变成321，这是因为数组存储的第一位是数字最高位的原因
string multiply(string x, string y);//大数乘法
int transferr(string& str);
string transferr(int num);
string Pow(string x, int n);    //大数指数
//const double eps = 1e-10;
//const double e = 2.718281828459;

int main() {
    string x = "", y = "";
    int yy = 0;
    cout << "数字a:";
    cin >> x;
    cout << "数字b:";
    cin >> yy;
    cout << "a^b结果是:"<= 0; --i) {
        if (x[i] != y[i]) {
            if (x[i] < y[i])
                flag = 1;
            break;
        }
    }
    if (flag == 1)
        return "-"+subtra(y, x);
    for (int i = 0; i < len; ++i) {
        int a= (((x[i] - '0') - (y[i] - '0') + carry) % 10);
        if (a < 0) {
            carry = -1;
            a = 10 + a;
            ret += (a + '0');
        }
        else {
            carry = 0;
            ret += (a + '0');
        }
    }
    return inverse(ret);
}
string Pow(string x, int n) {
    string res = "1";
    while (n--) {
        res=multiply(res, x);
    }
        return res;

}

1.6 稀疏矩阵（含0元素很多的矩阵mat[100][100]）
思路是先创建一个结构体doub，这个结构体用来存储矩阵中一个有效的数字和数字所在的位置（如果把0看成无效的），这个结构体是最基本的元素(相当于一个mat[0][0])
再创建一个结构体onerow，这个结构体用来存储有效行的下标（因为有很多行全部是0），和有效行中有效数字的个数（相当于一个mat[0]）
最后创建一个结构体sparsemat,这个结构体用来存储矩阵总行数，总列数，还有有效行的个数（相当于mat）
（这里实现复杂化了，我是想要方便更改稀疏矩阵内部元素，如果不需要更改的话，最开始mat[0][0]可以用三元组表示，即横坐标，纵坐标，元素值，然后sparsemat包含一个三元组的数组就行）

#include
#include
#include"OutOfBounds.h"
using namespace std;
const int Maxsize = 100;

struct doub
{
    int pos;    //数据所在位置
    double a;       //数据
};

struct onerow {
    int len=0;
    int index;  //行的编号
    int cols;   //总列数
    doub data[Maxsize];
    double& operator[](int y) {
        if (y<0 || y>=cols) {
            throw OutOfBounds(y);   //异常处理，在另外一个类里面有定义
        }
        double ret = 0;
        for (int i = 0; i < len; ++i) {
            if (data[i].pos == y)
                return data[i].a;
        }
        return ret;
    }
};
//稀疏矩阵
struct sparsemat{
    int rows, cols;     //总行数，总列数
    int count=0;    //有效数据的行数
    onerow data[Maxsize];
    onerow& operator[](int x) {
        if (x < 0 || x >= rows)
            throw OutOfBounds(x);
        onerow ret;
        ret.cols = cols;
        int j = 0;
        for (int i = 0; i < count; ++i) {
            if (data[i].index == x) {
                return data[i];
            }
        }
        return ret;
    }
};

void printmat(sparsemat& mat);
int main()
{
    sparsemat mat;
    mat.cols = mat.rows = 10;
    mat.count = 3;
    mat.data[0].cols = 10;
    mat.data[0].index = 2;
    mat.data[0].len = 2;

    mat.data[0].data[0].pos = 3;
    mat.data[0].data[0].a = 4.2;
    mat.data[0].data[1].pos = 6;
    mat.data[0].data[1].a = 6;


    mat.data[1].cols = 10;
    mat.data[1].index = 4;
    mat.data[1].len = 2;

    mat.data[1].data[0].pos = 3;
    mat.data[1].data[0].a = 57;
    mat.data[1].data[1].pos = 7;
    mat.data[1].data[1].a = 55.4;


    mat.data[2].cols = 10;
    mat.data[2].index = 7;
    mat.data[2].len = 1;

    mat.data[2].data[0].pos = 4;
    mat.data[2].data[0].a = 10.2;
    printmat(mat);
    mat[2][3]=2;
    cout << "-----------------更改后--------------------" << endl;
    printmat(mat);
}
void printmat(sparsemat& mat)
{
    
    int q = 0;
    for (int i = 0; i < mat.rows; ++i) {
        int p = 0;
        if (i == mat.data[q].index) {
            for (int j = 0; j < mat.cols; ++j) {
                if (j == mat.data[q].data[p].pos) {
                    cout << setw(5) << mat.data[q].data[p].a;
                    ++p;
                }
                else
                    cout << setw(5) << 0;
            }
            cout << endl;
            ++q;
        }
        else {
            for (int k = 0; k < mat.cols; ++k) {
                cout << setw(5) << 0;
            }
            cout << endl;
        }
            
    }
}

3.14
3.1
访问布尔型的变量（1个字节）比访问整型变量，字符型变量的时间要长，因为字节是寻址的最小单位，单独访问字节里的一个位需要更长的时间（大概...）