数据结构与算法C++描述（2）---数组

1、数组的定义

数据对象的每个实例都是形如(index,value)的数据对集合，其中任意两对数据的index值都各不相同。当每个数据对的index为一个唯一确定的值时，该数据对象被称为一维数组；当每个数据对的index值为唯一确定的两个值时，该数据对象便为二维数组。。。。。。
C++本身是支持数组的，但无法保证数组下标的合法性。同时，C++也未能提供数组的输入、输出以及简单的算数运算（如数组赋值和数组相加）。
为了利用C++描述数组，首先定义Array1D类描述一维数组，用Array2D类描述二维数组。在这里，为了描述二维数组A[i][j]，采用行主映射的方式（即从第一行开始，依次对每一行中的每个索引从左至右进行连续编号）。
在类中主要实现以下功能：

2、一维数组的C++实现

2.1 Array1D类的声明

template <class T>class Array1D{public:    Array1D(int size = 0);    Array1D(const Array1D<T> &v);     //复制构造函数    ~Array1D() { delete[] element; };     T &operator[](int i) const;       //重载下标操作符    int Size() { return size; }       //返回数组大小    Array1D<T> Resize(int sz);        //将一维数组的大小变为sz    Array1D<T> &operator=(const Array1D<T> &v); //重载“=”    Array1D<T> operator+()const;      //一元加法操作符    Array1D<T> operator+(const Array1D<T> &v)const;    Array1D<T> operator-()const;      //一元减法操作符    Array1D<T> operator-(const Array1D<T> &v)const;    Array1D<T> operator*(const Array1D<T> &v)const;    Array1D<T> &operator+=(const T& x);private:    int size;                       //数组大小     T *element;                     //数据对

2.2 一维数组的创建—构造函数的实现

//一维数组的构造函数template <class T>Array1D<T>::Array1D(int sz){    if (sz < 0) throw OutOfRange();   //抛出越界异常    size = sz;                        //将size设置为sz    element = new T[size];            //新建数据对}

2.2 一维数组的复制—复制构造函数的实现

//一维数组的复制构造函数template <class T>Array1D<T>::Array1D(const Array1D<T> &v){    size = v.size;    element = new T[size];    for (int i = 0; i < size; i++)        element[i] = v.element[i];}

2.3 取值操作—重载“[]”操作符

//重载“[]"，返回索引值下的元素值template <class T>T &Array1D<T>::operator[](int i) const{    if (i > 0 && i < size)          //在索引范围内        return element[i];          //返回数据对的value值    else        throw OutOfRange();         //抛出越界异常}

2.4 调整数组大小操作

//将一维数组的大小变为sztemplate <class T>Array1D<T> Array1D<T>::Resize(int sz){    delete[] element;              //删除当前所有的数据对    element = new T[sz];           //重新建立sz个数据对    return *this;                  //返回新建实例}

2.5 赋值操作—重载“=”运算符

//重载“=”template <class T>Array1D<T> &Array1D<T>::operator=(const Array1D<T> &v){    if (this != v)                      //v不为当前实例    {        size = v.size;                  //获取v的元素个数        delete[] element;               //释放原空间        element = new T[size];          //申请新空间        for (int i = 0; i < v.size; i++)//赋值            element[i] = v.element[i];    }    return *this;}

2.6 返回元素正值—重载“+”

//重载“+”（正号）template <class T>Array1D<T> Array1D<T>::operator+()const{    Array1D<T> w(size);              //新建实例,大小为当前实例大小    for (int i = 0; i < size; i++)   //赋值        w.element[i] = element[i];    return w;}

2.7 两数组相加—重载“+”

//重载“+”（加号）运算符template <class T>Array1D<T> Array1D<T>::operator+(const Array1D<T> &v)const{    if (size != v.size)       //数组大小不同不能相加    {        cout << "数组大小冲突！！！" << endl;        return 0;    }    else    {        Array1D<T> w(size); //新建实例，用于存放计算后的数据对        for (int i = 0; i < size; i++) //计算            w.element[i] = element[i] + v.element[i];        return w;    }}

2.8 返回元素负值—重载“-”

//重载“-”（负号）template <class T>Array1D<T> Array1D<T>::operator-()const{    Array1D<T> w(size);    for (int i = 0; i < size; i++)        w.element[i] = -element[i];    return w;}

2.9 两数组相减—重载“-”

//重载“-”（减号）运算符template <class T>Array1D<T> Array1D<T>::operator-(const Array1D<T> &v)const{    if (size != v.size)    {        cout << "数组大小冲突！！！" << endl;        return 0;    }    else    {        Array1D<T> w(size);        for (int i = 0; i < size; i++)            w.element[i] = element[i] - v.element[i];        return w;    }}

2.10 两数组相乘—重载“*”

//重载“*”（乘号）运算符template <class T>Array1D<T> Array1D<T>::operator*(const Array1D<T> &v)const{    if (size != v.size)    {        cout << "数组大小冲突！！！" << endl;        return 0;    }    else    {        Array1D<T> w(size);        for (int i = 0; i < size; i++)            w.element[i] = element[i] * v.element[i];        return w;    }}

2.11 每个元素加上x—重载“+=”

//重载“+=”运算符template <class T>Array1D<T> & Array1D<T>::operator+=(const T& x){    for (int i = 0; i < size; i++)         element[i] += x;    return *this;}

3. 二维数组的C++实现

3.1 二维数组类的声明

template <class T>class Array2D{public:    Array2D(int r = 0,int c=0);    Array2D(const Array2D<T> &m);     //复制构造函数    ~Array1D() { delete[] row; };    Array1D<T> &operator[](int i) const;       //重载下标操作符    int Rows() { return rows; }       //返回数组行数    int Cols() { return cols; }       //返回数组列数    Array2D<T> &operator=(const Array2D<T> &m); //重载“=”    Array2D<T> operator+()const;      //一元加法操作符    Array2D<T> operator+(const Array2D<T> &m)const;    Array2D<T> operator-()const;      //一元减法操作符    Array2D<T> operator-(const Array2D<T> &m)const;    Array2D<T> operator*(const Array2D<T> &m)const;    Array2D<T> &operator+=(const T& x);private:    int rows,cols;                    //数组行数和列数    Array1D<T> *row;                  //一维数组的数组};

3.2 创建二维数组—构造函数实现

//构造函数template<class T>Array2D<T>::Array2D(int r, int c){    if (r < 0 || c < 0)    {        cout << "行数或列数错误！！！"<<endl;        return 0;    }    if ((!r || !c) && (r || c))        throw OutOfRange();    rows = r;                        //行数    cols = c;                        //列数    row = new Array1D<T> [r];        //分配r个一维数组    for (int i = 0; i < r; i++)        row[i].Resize(c);            //调整每个一维数组的大小为c（列数）}

3.3 二维数组的复制—复制构造函数的实现

//复制构造函数template<class T>Array2D<T>::Array2D(const Array2D<T> &m)     //复制构造函数{    rows = m.row;                //复制行数    cols = m.cols;               //复制列数    row = new Array1D<T>[rows];  //新建rows个一维数组    for (int i = 0; i < rows; i++)//对每个一维数组赋值，        row[i] = m.row[i];       //这里调用了Array1D类的成员函数“Array1D<T> &operator=(const Array1D<T> &v); }

3.4 取第i行—重载“[]”,返回一个一维数组

//重载下标操作符template <class T>Array1D<T> &Array2D<T>::operator[](int i) const{    if (i<0 || i>=rows)        throw OutOfRange();    return row[i];}

3.5 赋值操作，重载“=”

//重载“=”template <class T>Array2D<T> &Array2D<T>::operator=(const Array2D<T> &m){    if (this != m)    {        rows = m.rows;           //获取m的行数        cols = m.cols;           //获取m的列数        delete[] row;            //删除当前存储值        row = new Array1D<T>[rows]; //新建        for (int i = 0; i < rows; i++) //赋值            row = m.row[i];       }    return *this;}

3.6 一元加法操作—重载“+”

//一元加法操作符template <class T>Array2D<T> Array2D<T>:: operator+()const{    row = new Array1D<T>[rows];    for (int i = 0; i < rows; i++)        return row[i];}

3.7 二元加法操作

//二元加法操作符template <class T>Array2D<T> Array2D<T>::operator+(const Array2D<T> &m)const{    if (rows != m.rows || cols != m.cols)        throw OutOfRange();    Array2D<T> w(rows,cols);    for (int i = 0; i < rows; i++)    {        w.row[i] = row[i] + m.row[i];  //调用了一元数组的“+”重载函数    }    return w;}

3.8 一元减法操作—重载“-”

//一元减法操作符template <class T>Array2D<T> Array2D<T>:: operator-()const{    row = new Array1D<T>[rows];    for (int i = 0; i < rows; i++)        return -row[i];}

3.9 二元减法操作—重载“-”

//二元减法操作符template <class T>Array2D<T> Array2D<T>::operator-(const Array2D<T> &m)const{    if (rows != m.rows || cols != m.cols)        throw OutOfRange();    Array2D<T> w(rows, cols);    for (int i = 0; i < rows; i++)    {        w.row[i] = row[i] - m.row[i];  //调用了一元数组的“-”重载函数    }    return w;}

3.10 两数组相乘—重载“*”

两数组相乘类似于矩阵的相乘，只有数组1的列数等于数组2的行数，才有“数组1x数组2”，并且两者相乘后共有“数组1的行数x数组2的列数”个数据。

//乘法操作符template <class T>Array2D<T> Array2D<T>::operator*(const Array2D<T> &m)const{    if (cols != m.rows)         //不满足相乘条件        throw OutOfRange();    Array2D<T> w(rows, m.cols);  //声明新的对象，用于存放计算后的数据    for (int i = 0; i < rows; i++)        for (int j = 0; j < m.cols; j++)        {            T sum;                //声明中间变量sum，用于存放乘法运算后的数值            sum = (*this)[i][0] * m[0][j];            for (int k = 1; k < rows; k++)                sum += (*this)[i][k] * m[k][j];            w[i][j] = sum;      //赋值        }    return w;}

3.11 每个元素加上x—重载“+=”

//"+="操作符重载template <class T>Array2D<T> &Array2D<T>::operator+=(const T& x){    Array2D w(rows, cols);    for (int i = 0; i < rows; i++)        w.row[i] += x;    return w;}