C++实现的十字链表：容器和迭代器

最新推荐文章于 2023-02-11 12:05:16 发布

ryfdizuo

最新推荐文章于 2023-02-11 12:05:16 发布

阅读量4.2k

点赞数 1

分类专栏：随想&&感想算法 C++ Pattern Design 文章标签： c++ iterator null delete class buffer

本文链接：https://blog.csdn.net/ryfdizuo/article/details/6361077

版权

C++ 同时被 3 个专栏收录

153 篇文章 0 订阅

订阅专栏

随想&&感想

102 篇文章 0 订阅

订阅专栏

算法

62 篇文章 0 订阅

订阅专栏

改进08年曾经编过的STL风格的十字链表程序。

二维循环式

1，每个节点有right和down指针。

2，每一行的最后一个元素的right指针指向下一个有效行（不一定是下一行）的第一个元素。

3，每一列的最后一个元素的down指针指向下一个有效列（不一定是下一列）的第一个元素。

4，注意

第一个元素不一定就是左上角，DOWN和RIGHT遍历的第一个元素也可以不同。

//矩阵:

0 1 0 0 0

0 0 0 0 0

3 0 4 0 0

0 5 0 0 0

DOWN：{3}， {1,5}， {4}

RIGHT： {1}， {3,4}， {5}

最后一个元素不一定就是右下角，按照right遍历和down遍历最后一个元素不同。

//矩阵:

0 1 0 0 0

0 0 0 0 0

0 3 4 0 0

0 5 0 0 0

DOWN：{1，3，5}， {4}

RIGHT： {1}，{3，4}， {5}

所以迭代器构造的时候必须指定类型：DOWN / RIGHT

矩阵举例分析

0 1 0 0 0

0 0 0 0 0

0 3 4 0 0

0 5 0 0 0

存储结构图：

图 - 1

如图-1，黑色结点HNode为头结点，HNode的right指向第一个有效行的首元素，down指针指向第一个有效列的首元素。

两种颜色的线条，橙色线条表示right指针，蓝色线条表示down指针。

1）每一行最后一个元素的right指针指向下一个有效行第一个元素，

图-1按照right指针遍历的序列为：{1}, {3, 4}, {5} 其中大括号内为同一行元素。

一共三行，第一行最后一个结点1的right指向3结点；第二行最后一个结点4的right指向5；5结点为right遍历的最后一个元素，所以第三行最后一个结点5的right指向了HNode结点，图中有橙色的虚线表示。

STL风格的迭代器设计都是左闭右开，行遍历的伪代码如下：

Iterator<int, RIGHT> it = begin( OList::Node_1 ); it != end( OList::HNode ); ++it );

//do_some_stuff()

迭代器的第一个模板参数为OList存储的数据类型，第二个模板参数为迭代器遍历方式，缺省参数为RIGHT。

2）每一列最后一个元素的down指针指向下一个有效列第一个元素，

图-1按照down指针遍历的序列为：{1,3,5}, {4} 其中大括号内为同一列元素。

一共两列，第一列最后一个结点5的down指针指向4结点。4结点为down遍历的最后一个元素，所以第二列最后一个结点4的down指向了HNode结点。图中有蓝色的虚线表示。

STL风格的迭代器设计都是左闭右开，列遍历的伪代码如下：

Iterator<int, DOWN> it = begin( OList::Node_1 ); it != end( OList::HNode ); ++it );

//do_some_stuff()

迭代器的第一个模板参数为OList存储的数据类型，第二个模板参数为迭代器遍历方式，缺省参数为RIGHT。

总结：

这种存储方式，方便迭代器的设计但是丢失了原稀疏矩阵的行列，元素的位置信息。

行列矩阵式存储

1, 增加行列的头结点：

行头结点：Node* m_pRowHead [ m_RowSize ];

列头结点：Node* m_pColHead[ m_ColSize ];

如果row_idx行全为0，则 m_pRowHead[ row_idx ] = NULL;

2，增加两个行遍历和列遍历的尾结点：rowCapNode, colCapNode，主要是设计迭代器需要。

3，每一行的最后一个结点m_pRight为NULL，最后一行最后一个元素m_pRight指向rowCapNode。

4，每一列的最后一个结点m_pDown为NULL，最后一列最后一个元素m_pDown指向colCapNode。

//矩阵:

0 1 0 0 0

0 0 0 0 0

3 0 4 0 0

0 5 0 0 0

存储结构如图-2：

行遍历：{1}， {3， 4}， {5}， {rowCapNode}

列遍历：{1，3，5}， {4}， {colCapNode}

OrthoList<T>的实现如下：实现了两种const iterator：row, col

#include <iostream> #include <assert.h> #define SAFE_DELETE(p) {if(p){delete p; p=NULL;}} #define ENUM enum #define CONST const #define VOID void #define BOOL bool #define INLINE inline #define ASSERT assert template<class ListDataType> class OrthoList; template<class ListDataType> class ConstRowIter; template<class ListDataType> class ConstColIter; //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> //十字链表结点类的定义 template<class NodeDataType> class OLNode { //申明友元类 friend class ConstRowIter<NodeDataType>; friend class ConstColIter<NodeDataType>; friend class OrthoList<NodeDataType>; public: OLNode(size_t iPos=0, size_t jPos=0, NodeDataType elem=0) :m_wRowPos(iPos), m_wColPos(jPos), m_Elem(elem), m_pRight(NULL), m_pDown(NULL) {} OLNode(CONST OLNode<NodeDataType>& node) :m_wRowPos(node.m_wRowPos), m_wColPos(node.m_wColPos), m_Elem(node.m_Elem), m_pRight(NULL), m_pDown(NULL) {} ~OLNode() {} size_t GetRowPos() CONST{ return m_wRowPos; } size_t GetColPos() CONST{ return m_wColPos; } NodeDataType GetElemData()CONST {return m_Elem; } OLNode<NodeDataType>* GetDownPtr()CONST {return m_pDown;} OLNode<NodeDataType>* GetRightPtr()CONST {return m_pRight;} VOID SetElemData(NodeDataType val){m_Elem=val;}; private: size_t m_wRowPos; size_t m_wColPos; NodeDataType m_Elem; OLNode<NodeDataType>* m_pRight; OLNode<NodeDataType>* m_pDown; }; //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> //十字链表的定义 //只是单纯的数据结构 template<class ListDataType> class OrthoList { friend class ConstRowIter<ListDataType>; friend class ConstColIter<ListDataType>; public: OrthoList(); OrthoList(size_t rowNum, size_t collNum); OrthoList(CONST ListDataType* buffer, size_t row, size_t coll); //一维数组 OrthoList(CONST OrthoList<ListDataType>& cMatrix); ~OrthoList(); public: typedef OLNode<ListDataType>* OLink; // // class ConstRowIter { public: typedef ListDataType value_type; typedef OLNode<value_type> node_type; typedef OrthoList<value_type> list_type; // 初始化迭代器，记录初始化行列 ConstRowIter(){}; // 找到olist的第一个有效行首元素 ConstRowIter(OLink node, const list_type * olist) : _current(node), m_iNum(0), m_pOList(olist) { m_iCurrentRow = m_pOList->availableRow[0]; //minRow } ~ConstRowIter(){}; // 遍历链表方式：只能行优先 ConstRowIter& operator++() { m_iNum++; _current = _current->m_pRight; AdjustRowImpl__(); return *this; } // OListIter& operator++(int) // temporary object reference const ConstRowIter operator++(int) { ConstRowIter tem = *this; ++*this; return tem; } // 一般的遍历方式 node_type& operator*() const { return *_current; } node_type* operator->() const { return _current; } node_type* get() const { return _current; } // 判断结束 bool valid() const { return m_iNum!=m_pOList->GetTotalSize(); } // 重载二目运算符 BOOL operator ==(const ConstRowIter& rhs) const{return _current==rhs._current;}; BOOL operator !=(const ConstRowIter& rhs) const{return _current!=rhs._current;}; private: inline VOID AdjustRowImpl__() { while(!_current) { // 调节_current指向下一个有效行第一个元素 if(++m_iCurrentRow < m_pOList->m_wRowSize) _current=m_pOList->m_pRowHead[m_iCurrentRow]; } } const list_type* m_pOList; node_type* _current; //内部链表元素遍历器 size_t m_iCurrentRow; size_t m_iNum; }; typedef ConstRowIter const_row_iterator; // // class ConstColIter { public: typedef ListDataType value_type; typedef OLNode<value_type> node_type; typedef OrthoList<value_type> list_type; /* * 初始化迭代器，记录初始化行列 */ ConstColIter(){}; // 找到olist的第一个有效行首元素 ConstColIter(OLink node, const list_type* olist) : _current(node), m_iNum(0), m_pOList(olist) { m_iCurrentCol = m_pOList->availableCol[0]; //minCol } ~ConstColIter(){}; // 遍历链表方式：只能行优先 ConstColIter& operator++() { m_iNum++; _current = _current->m_pDown; AdjustColImpl__(); return *this; } // OListIter& operator++(int) // temporary object reference const ConstColIter operator++(int) { ConstColIter tem = *this; ++*this; return tem; } // 一般的遍历方式 node_type& operator*() const { return *_current; } node_type* operator->() const { return _current; } node_type* get() const { return _current; } // 判断结束 bool valid() const { return m_iNum!=m_pOList->GetTotalSize(); } // 重载二目运算符 BOOL operator ==(const ConstColIter& rhs) const{return _current==rhs._current;}; BOOL operator !=(const ConstColIter& rhs) const{return _current!=rhs._current;}; private: VOID AdjustColImpl__() { while(!_current) { // 调节_current指向下一个有效行第一个元素 if(++m_iCurrentCol < m_pOList->m_wColSize) _current=m_pOList->m_pColHead[m_iCurrentCol]; } } const list_type* m_pOList; node_type* _current; //内部链表元素遍历器 size_t m_iCurrentCol; size_t m_iNum; }; typedef ConstColIter const_col_iterator; // // const_row_iterator rBegin() const { return (const_row_iterator(m_pRowHead[ availableRow[0] ], this)); //return row_iterator(GetFirstNodeByRow(),this); } const_row_iterator rEnd() const { return (const_row_iterator(rowCapNode, this)); } const_col_iterator cBegin() const { return (const_col_iterator(m_pColHead[ availableCol[0] ], this)); } const_col_iterator cEnd() const { return (const_col_iterator(colCapNode, this)); } size_t GetRowSize() CONST{ return m_wRowSize; } size_t GetColSize() CONST{ return m_wColSize; } size_t GetTotalSize() CONST{ return m_wTotalSize;} CONST OLink GetRow(size_t row) CONST {return m_pRowHead[row];} CONST OLink GetColl(size_t col) CONST {return m_pColHead[col];} CONST OLink GetFirstNodeByRow() CONST; CONST OLink GetFirstNodeByCol() CONST; VOID InsertNode(OLink& node); //创建十字链表 VOID InsertNode(size_t iPos, size_t jPos, ListDataType elem); VOID InsertInRow(OLink& node); //插入元素到行 VOID InsertInCol(OLink& node); //插入元素到列 VOID CreateListHeads(); //创建行列头结点 VOID Free(); //释放十字链表 //深拷贝 template<class ListDataType> friend VOID Copy(OrthoList<ListDataType>& src, CONST OrthoList<ListDataType>& dest); private: OLink* m_pRowHead; OLink* m_pColHead; size_t m_wRowSize; size_t m_wColSize; size_t m_wTotalSize; // 只是为了设计迭代器方便 // availableRow[0] 当前的第一个有效行 // availableRow[1] 当前最后一个有效行 size_t availableRow[2]; //min max size_t availableCol[2]; //min max OLink rowCapNode; OLink colCapNode; };

OrthoList<T>的实现，注意跟定义放在一个头文件中：

//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> //OrthoList类的实现 template<class ListDataType> OrthoList<ListDataType>::OrthoList() :m_wRowSize(0), m_wColSize(0), m_wTotalSize(0), m_pRowHead(NULL), m_pColHead(NULL) {} template<class ListDataType> OrthoList<ListDataType>::OrthoList(CONST ListDataType* buffer, size_t row, size_t coll) :m_wRowSize(row), m_wTotalSize(0), m_wColSize(coll), m_pRowHead(NULL), m_pColHead(NULL) { CreateListHeads(); for(size_t i=0; i<row*coll; i++) if(buffer[i]) InsertNode(i/coll, i%coll, buffer[i]); } template<class ListDataType> OrthoList<ListDataType>::OrthoList(size_t rowNum, size_t collNum) :m_wRowSize(rowNum), m_wColSize(collNum), m_wTotalSize(0), m_pRowHead(NULL), m_pColHead(NULL) { CreateListHeads(); } template<class ListDataType> OrthoList<ListDataType>::OrthoList(CONST OrthoList<ListDataType>& cMatrix) :m_wTotalSize(0), m_pRowHead(NULL), m_pColHead(NULL) { Copy(*this, cMatrix); } template<class ListDataType> OrthoList<ListDataType>::~OrthoList() { Free(); } template<class ListDataType> VOID OrthoList<ListDataType>::Free() { //列优先释放内存； for (size_t i=0; i<m_wColSize; i++) { OLink tem; while (m_pColHead[i]) { tem=m_pColHead[i]; m_pColHead[i]=m_pColHead[i]->m_pDown; SAFE_DELETE(tem); // 4/26/2011 RYF // 这里可以删除colCapNode } } SAFE_DELETE(m_pColHead); SAFE_DELETE(m_pRowHead); // 4/26/2011 RYF SAFE_DELETE(rowCapNode); } template<class ListDataType> VOID OrthoList<ListDataType>::CreateListHeads() { //没有异常处理 m_pRowHead=new OLink[m_wRowSize]; //创建行头指针表； m_pColHead=new OLink[m_wColSize]; //创建列头指针表； for (size_t i=0; i<m_wRowSize; i++) m_pRowHead[i]=NULL; for (size_t i=0; i<m_wColSize; i++) m_pColHead[i]=NULL; // 4/26/2011 RYF availableRow[0] = m_wRowSize-1; availableRow[1] = 0; availableCol[0] = m_wColSize-1; availableCol[1] = 0; rowCapNode = new OLNode<ListDataType>; colCapNode = new OLNode<ListDataType>; m_pRowHead[ availableRow[1] ] = rowCapNode; m_pColHead[ availableCol[1] ] = colCapNode; } template<class ListDataType> CONST typename OrthoList<ListDataType>::OLink OrthoList<ListDataType>::GetFirstNodeByRow() CONST { // return m_pRowHead[ availableRow[0] ]; int i(0); while(!m_pRowHead[i] && i<m_wRowSize) i++; return m_pRowHead[i]; } template<class ListDataType> CONST typename OrthoList<ListDataType>::OLink OrthoList<ListDataType>::GetFirstNodeByCol() CONST { int i(0); while(!m_pColHead[i] && i<m_wColSize) i++; return m_pColHead[i]; } template<class ListDataType> VOID OrthoList<ListDataType>::InsertNode(OLink& node) { ASSERT(node != NULL); if( !m_pColHead || !m_pRowHead) CreateListHeads(); m_wTotalSize++; InsertInRow(node); InsertInCol(node); } template<class ListDataType> VOID OrthoList<ListDataType>::InsertNode(size_t iPos, size_t jPos, ListDataType elem) { OLink node=new OLNode<ListDataType>(iPos, jPos, elem); InsertNode(node); } template<class ListDataType> VOID OrthoList<ListDataType>::InsertInRow(OLink& node) { ASSERT(node != NULL); size_t i=node->m_wRowPos; size_t j=node->m_wColPos; // 4/26/2011 RYF size_t& minRow = availableRow[0]; size_t& maxRow = availableRow[1]; if ( i<minRow ) minRow = i; //update min row. if ( i>maxRow ) //update max row { // 将node第一次插入i行 // node->m_pRight == m_pRowHead[i] == NULL; m_pRowHead[i] = node; // 交换node的right和maxRow行最后一个元素的right指针 // maxRow行没有元素 if (m_pRowHead[maxRow]==rowCapNode) { m_pRowHead[maxRow] = NULL; } else { // maxRow行至少有一个元素，查找maxRow的最后一个元素 OLink bg; for(bg=m_pRowHead[maxRow]; bg->m_pRight != rowCapNode; bg=bg->m_pRight) ; bg->m_pRight = NULL; } node->m_pRight = rowCapNode; // 更新maxRow maxRow = i; } else if( i==maxRow ) //插入元素在maxRow行 { // 直接插到行首 if (m_pRowHead[i]==rowCapNode || j<m_pRowHead[i]->m_wColPos) { node->m_pRight = m_pRowHead[i]; m_pRowHead[i] = node; } else //在行中查找插入位置，注意循环结束条件！ { OLink bg; for(bg=m_pRowHead[i]; bg->m_pRight != rowCapNode && bg->m_pRight->m_wColPos<j; bg=bg->m_pRight) ; // 将node插到bg后面 node->m_pRight=bg->m_pRight; bg->m_pRight=node; } } // 4/26/2011 RYF else // i < maxRow { //直接插入：空，或者列坐标大于此行链表中的最大列坐标 //同一行里面，链表按照列的坐标排序， //行第一个元素(0,2)，插入(0,1)时。 if( m_pRowHead[i]==NULL || m_pRowHead[i]->m_wColPos>j ) { node->m_pRight=m_pRowHead[i]; m_pRowHead[i]=node; } else //查寻在行表中的插入位置： { OLink bg; // 行第一个元素(0,2)，插入(0,3)时。 for(bg=m_pRowHead[i]; bg->m_pRight && bg->m_pRight->m_wColPos<j; bg=bg->m_pRight) ; node->m_pRight=bg->m_pRight; bg->m_pRight=node; } //完成行插入。 } } template<class ListDataType> VOID OrthoList<ListDataType>::InsertInCol(OLink& node) { ASSERT(node != NULL); size_t i=node->m_wRowPos; size_t j=node->m_wColPos; // 4/26/2011 RYF size_t& minCol = availableCol[0]; size_t& maxCol = availableCol[1]; if ( j<minCol ) minCol = j; //update min row. if ( j>maxCol ) //update max row { // 将node第一次插入j列 m_pColHead[j] = node; // 交换node的down和maxCol列最后一个元素的down指针 // maxCol列没有元素 if (m_pColHead[maxCol]==colCapNode) { m_pColHead[maxCol] = NULL; } else { // maxCol列至少有一个元素，查找maxCol列的最后一个元素 OLink bg; for(bg=m_pColHead[maxCol]; bg->m_pDown != colCapNode; bg=bg->m_pDown) ; bg->m_pDown = NULL; } node->m_pDown = colCapNode; // 更新maxCol maxCol = j; } else if( j==maxCol ) //插入元素在maxCol列 { // 直接插到列首 if (m_pColHead[j]==colCapNode || i<m_pColHead[j]->m_wRowPos) { node->m_pDown = m_pColHead[j]; m_pColHead[j] = node; } else //在列中查找插入位置，注意循环结束条件！ { OLink bg; for(bg=m_pColHead[j]; bg->m_pDown != colCapNode && bg->m_pDown->m_wRowPos<i; bg=bg->m_pDown) ; // 将node插到bg后面 node->m_pDown=bg->m_pDown; bg->m_pDown=node; } } // 4/26/2011 RYF else // j < maxCol { //直接插入：空，或者行坐标大于此列链表中的最大行坐标 //同一列里面，链表按照行的坐标排序， if( m_pColHead[j]==NULL || m_pColHead[j]->m_wRowPos>i ) { node->m_pDown=m_pColHead[j]; m_pColHead[j]=node; } else //查寻在列表中的插入位置： { OLink bg; for(bg=m_pColHead[j]; bg->m_pDown && bg->m_pDown->m_wRowPos<i; bg=bg->m_pDown) ; node->m_pDown=bg->m_pDown; bg->m_pDown=node; } //完成列插入。 } // // }

基于迭代器的功能函数设计：copy和print

// 使用迭代器输出 template<class ListDataType> VOID PrintMatrixByRow(CONST OrthoList<ListDataType>& olist) { size_t last_row(0), last_col(-1); bool isNewRow(false); OrthoList<ListDataType>::const_row_iterator lastIter; // 换行情形 for (OrthoList<ListDataType>::const_row_iterator iter = olist.rBegin(); iter != olist.rEnd(); iter++) { size_t cur_row = iter->GetRowPos(); size_t cur_col = iter->GetColPos(); if (last_row<cur_row) isNewRow = true; //空行的特殊处理: 输出last_row和cur_row if (isNewRow) { // 上一行的尾部充0 for (size_t c(last_col+1); c<olist.GetColSize(); c++) { std::cout.width(6); std::cout << 0 << " "; } std::cout << "/n"; // 填充中间的空白行 for (size_t r=last_row+1; r<cur_row; r++) { for (size_t c(0); c<olist.GetColSize(); c++) { std::cout.width(6); std::cout << 0 << " "; } std::cout << "/n"; } last_col = 0; // 从新一行的0列开始 isNewRow = false; //新一行首部元素充0 for (size_t c(last_col); c<cur_col; c++) { std::cout.width(6); std::cout << 0 << " "; } } else { //行内元素间充0 for (size_t c(last_col); c<cur_col-1; c++) { std::cout.width(6); std::cout << 0 << " "; } } //输出元素 std::cout.width(6); std::cout << iter->GetElemData() << " "; // 记录 last_row = cur_row; last_col = cur_col; lastIter = iter; } // 最后一行尾部充0 for (size_t c = lastIter->GetColPos()+1; c<olist.GetColSize(); c++) { std::cout.width(6); std::cout << 0 << " "; } std::cout << "/n"; } // 根据src的内容拷贝构造dest十字链表 template<class ListDataType> VOID Copy(OrthoList<ListDataType>& src, CONST OrthoList<ListDataType>& dest) { src.m_wColSize = dest.m_wColSize; src.m_wRowSize = dest.m_wRowSize; src.CreateListHeads(); //按照行优先构造 for(OrthoList<ListDataType>::const_row_iterator iter = dest.rBegin(); iter != dest.rEnd(); ++iter) src.InsertNode( iter->GetRowPos(), iter->GetColPos(), iter->GetElemData()); }

测试：

#include "stdafx.h" #ifndef ORTHOLISTTEST_H #define ORTHOLISTTEST_H #include "OrthoList.hpp" CONST int SparseMat[]= { 1, 0,0, 0,0, 0,0, 0,12,9, 0,0, 0,0, 3,0,0, 0,0,14,0, 0, 0,24,0,0, 0,0, 0,18,0, 0,0, 0,0, 15,0,0, -7,0,0,0, 0,1,0, 0,0, 0,0 }; class OrthoListTest { public: ~OrthoListTest() { DestroyOList(); } //Matrix:6×7 static CONST int Row=7; static CONST int Coll=7; static OrthoList<int>* OList; static VOID CreateOList() { /* * 测试十字链表 */ std::cout<<std::endl<<"CreateOList"<<std::endl; std::cout<<"/*----------------------------------------------------------*/"<<std::endl; OList = new OrthoList<int>(Row, Coll); for(int i=0; i<sizeof(SparseMat)/sizeof(SparseMat[0]); i++) if(SparseMat[i]) OList->InsertNode(i/Coll, i%Coll, SparseMat[i]); PrintMatrixByRow(*OList); // PrintMatrixInLine(*OList); std::cout<<"/*----------------------------------------------------------*/"<<std::endl; } static VOID OLIterTest() { /* * 测试迭代器：OListIter：//按照行优先遍历 */ std::cout<<std::endl<<"OLIterTest"<<std::endl; std::cout<<"/*----------------------------------------------------------*/"<<std::endl; for(OrthoList<int>::const_row_iterator iter=OList->rBegin(); iter!=OList->rEnd(); ++iter) { std::cout << "( " << iter->GetRowPos() << " , " << iter->GetColPos(); std::cout << " , " << iter->GetElemData() << " )/n"; } std::cout<<"/*----------------------------------------------------------*/"<<std::endl; std::cout<<"/*----------------------------------------------------------*/"<<std::endl; for(OrthoList<int>::const_col_iterator iter=OList->cBegin(); iter!=OList->cEnd(); ++iter) { std::cout << "( " << iter->GetRowPos() << " , " << iter->GetColPos(); std::cout << " , " << iter->GetElemData() << " )/n"; } std::cout<<"/*----------------------------------------------------------*/"<<std::endl; } static VOID DestroyOList() { if (OList) delete OList; OList = 0; } static VOID BeginTest() { CreateOList(); OLIterTest(); DestroyOList(); // RYF 2011/4/25 } }; //静态成员申明 OrthoList<int>* OrthoListTest::OList; #endif /*SPARSETEST_H*/ 、

输出：

CreateOList /*----------------------------------------------------------*/ 1 0 0 0 0 0 0 0 12 9 0 0 0 0 3 0 0 0 0 14 0 0 0 24 0 0 0 0 0 18 0 0 0 0 0 15 0 0 -7 0 0 0 0 1 0 0 0 0 0 /*----------------------------------------------------------*/ OLIterTest /*----------------------------------------------------------*/ ( 0 , 0 , 1 ) ( 1 , 1 , 12 ) ( 1 , 2 , 9 ) ( 2 , 0 , 3 ) ( 2 , 5 , 14 ) ( 3 , 2 , 24 ) ( 4 , 1 , 18 ) ( 5 , 0 , 15 ) ( 5 , 3 , -7 ) ( 6 , 1 , 1 ) /*----------------------------------------------------------*/ /*----------------------------------------------------------*/ ( 0 , 0 , 1 ) ( 2 , 0 , 3 ) ( 5 , 0 , 15 ) ( 1 , 1 , 12 ) ( 4 , 1 , 18 ) ( 6 , 1 , 1 ) ( 1 , 2 , 9 ) ( 3 , 2 , 24 ) ( 5 , 3 , -7 ) ( 2 , 5 , 14 ) /*----------------------------------------------------------*/