数据结构之三元组

今天,我们简单的实现稀疏矩阵的存储方式:三元组.

我们就看看简单的实现代码吧:

#ifndef _SARRAY_H_
#define _SARRAY_H_

/*----------------------------------*/
三元组通常是用来存放非常大的数组，而
且数组中的元素大部分是重复元素（这里
我们把这些重复的元素值认为是默认值）
，只有少数是不同的元素（需要单独保存
的特殊值）
/*----------------------------------*/

#ifndef MAX_SIZE
#define MAX_SIZE 256
#endif//MAX_SIZE

template <typename T>
class CSArray;
template <typename T>
struct Elem
{
 friend class CSArray<T>;
 private:
  T elem;
  int nRow;
  int nCol;
 public:
  Elem():nRow(-1),nCol(-1){};
  Elem( T e , int row, int col ):elem(e),nRow(row),nCol(col){};
};

template <typename T>
class CSArray
{
 private:
  Elem<T>  m_Elem[MAX_SIZE + 1]; //m_Elem[MAX_SIZE]存放默认值
  int   m_nRows;
  int   m_nCols;
  
 public:
  CSArray():m_nRows(0),m_nCols(0){};
  CSArray( T defValue );
  CSArray( T defValue, int nRows, int nCols );

  void SetSArraySize( int nRows, int nCols );
  void SetSArraySize( T defValue, int nRows, int nCols );

  void SetAt( int nRow, int nCol, T e );
  T  GetAt( int nRow, int nCol, T & e );

 public:

  T operator ()( int nRow, int nCol ); //由于C++不支持[][]重载，故用()代替
};

template <typename T>
CSArray<T>::CSArray( T defValue )
{
 m_nRows = 0;
 m_nCols = 0;
 m_Elem[MAX_SIZE].elem = defValue;
}

template <typename T>
CSArray<T>::CSArray( T defValue, int nRows, int nCols )
{
 m_nRows = nRows;
 m_nCols = nCols;
 m_Elem[MAX_SIZE].elem = defValue;
}

template <typename T>
void CSArray<T>::SetSArraySize( int nRows, int nCols )
{
 m_nRows = nRows;
 m_nCols = nCols;
}

template <typename T>
void CSArray<T>::SetSArraySize( T defValue, int nRows, int nCols )
{
 m_nRows = nRows;
 m_nCols = nCols;
 m_Elem[MAX_SIZE].elem = defValue;
}

template <typename T>
void CSArray<T>::SetAt( int nRow, int nCol, T e )
{
 int  i = 0;
 bool bfind = false;
 
 if ( nRow >= m_nRows || nRow < 0 ||
  nCol >= m_nCols || nCol < 0 )
 {
  throw exception();
 }
 
 do
 {
  if ( m_Elem[i].nRow == -1 ||  m_Elem[i].nCol == -1 ) break;
  if ( m_Elem[i].nRow == nRow && m_Elem[i].nCol == nCol )
  {
   bfind = true; break;
  }
 }while ( ++i < MAX_SIZE );

 if ( bfind )
 {
  m_Elem[i].elem = e;
 }
 else
 {
  if ( i < MAX_SIZE )
  {
   m_Elem[i].elem = e;
   m_Elem[i].nRow = nRow;
   m_Elem[i].nCol = nCol;
  }
  else
  {
   throw exception();
  }
 }
}

template <typename T>
T CSArray<T>::GetAt( int nRow, int nCol, T & e )
{
 int  i = 0;
 bool bfind = false;
 
 if ( nRow >= m_nRows || nRow < 0 ||
  nCol >= m_nCols || nCol < 0 )
 {
  throw exception();
 }
 
 do
 {
  if ( m_Elem[i].nRow == -1 ||  m_Elem[i].nCol == -1 ) break;
  if ( m_Elem[i].nRow == nRow && m_Elem[i].nCol == nCol )
  {
   bfind = true; break;
  }
 }while ( ++i < MAX_SIZE );
 
 return (e = bfind ? m_Elem[i].elem : m_Elem[MAX_SIZE].elem);
}

template <typename T>
T CSArray<T>::operator ()( int nRow, int nCol )
{
 int  i = 0;
 bool bfind = false;

 if ( nRow >= m_nRows || nRow < 0 ||
   nCol >= m_nCols || nCol < 0 )
 {
  throw exception();
 }

 do
 {
  if ( m_Elem[i].nRow == -1 ||  m_Elem[i].nCol == -1 ) break;
  if ( m_Elem[i].nRow == nRow && m_Elem[i].nCol == nCol )
  {
   bfind = true; break;
  }
 }while ( ++i < MAX_SIZE );

 return bfind ? m_Elem[i].elem : m_Elem[MAX_SIZE].elem;
}

#endif//_SARRAY_H_