数据机构系列之线性表（模拟指针）

#ifndef SIMULATEPOINTER_H_
#define SIMULATEPOINTER_H_

#include <iostream>

using namespace std;

template <class T> class SimSpace;
template <class T> class SimChain;
template <class T> class SimIterator;
template <class T>
class SimNode
{
 friend SimSpace<T>;
 friend SimChain<T>;
 friend SimIterator<T>;
public:
protected:
private:
 T m_Data;
 int m_nLink;
};

template <class T>
class SimSpace
{
 friend SimChain<T>;
 friend SimIterator<T>;
public:
 SimSpace(int nMaxSpaceSize = 100);
 ~SimSpace() {delete [] m_snNode; };
 int Allocate();
 void Deallocate(int& nIndex);
 void DeallocateChain(int& c);
 void DeallocateCircular(int& c);
protected:
private:
 int m_nNumberNode;
 int m_nFirst;
 SimNode<T>* m_snNode;
};

template <class T>
class SimChain
{
 friend SimIterator<T>;
public:
 SimChain(){ m_nFirst = -1; };
 ~SimChain();
 void Destroy();
 int Length() const;
 bool Find(int nIndex,T& nValue) const;
 int Search(const T& nValue) const;
 SimChain<T>& Delete(int nIndex,T& nValue);
 SimChain<T>& Insert(int nIndex,const T& nValue);
 void Output(ostream& out) const;
 void InsertSort();
protected:
private:
 int m_nFirst;
 static SimSpace<T> m_ssSpace;//static变量，需要先进行全局初始化
};
template <class T>
class SimIterator
{
public:
 T* Initialize(const SimChain<T>& scValue)
 {
  int first = scValue.m_nFirst;
  if (first!=-1) {
   m_snLocation = scValue.m_ssSpace.m_snNode+first;
   if (m_snLocation) {
    return &m_snLocation->m_Data;
   }
  }  
  return 0;
 }
 T* Next(const SimChain<T>& scValue){
  if (!m_snLocation) {
   return 0;
  }
  int nNext;
  nNext= m_snLocation->m_nLink;
  if (nNext!=-1) {
   m_snLocation = scValue.m_ssSpace.m_snNode+nNext;
   if (m_snLocation) {
    return &m_snLocation->m_Data;
   }
  }
  return 0;
 }
protected:
private:
 SimNode<T>* m_snLocation;
};
#endif

 

 

 

#include "SimulatePointer.h"
#include "xcept.h"

/************************************************************************
Function:构造函数
Parameter:
Return:
************************************************************************/
template <class T>
SimSpace<T>::SimSpace(int nMaxSpaceSize /* = 100 */)
{
 m_nNumberNode = nMaxSpaceSize;
 m_snNode = new SimNode<T>[m_nNumberNode];
 int i;
 for (i = 0; i < m_nNumberNode - 1; i++) {
  m_snNode[i].m_nLink = i + 1;
 }
 m_snNode[m_nNumberNode-1].m_nLink = -1;
 m_nFirst = 0;
}
/************************************************************************
Function:使用模拟指针分配一个节点
Parameter:
Return:
************************************************************************/
template <class T>
int SimSpace<T>::Allocate()
{//分配一个自由节点
 if (m_nFirst==-1) {//空间已满
  throw NoMem();
 }
 int i = m_nFirst;//分配第一个节点
 m_nFirst = m_snNode[i].m_nLink;//m_nFirst指向下一个自由节点
 return i;
}
/************************************************************************
Function:用模拟指针释放一个节点
Parameter:
Return:
************************************************************************/
template <class T>
void SimSpace<T>::Deallocate(int& nIndex)
{
 //使 nIndex  成为可用空间表的第一个节点
 m_snNode[nIndex].m_nLink = m_nFirst;
 m_nFirst = nIndex;
 nIndex = -1;//释放该节点值相当于将指针赋值为0
}
/************************************************************************
Function:释放一个单向链表
Parameter:
Return:
************************************************************************/
template <class T>
void SimSpace<T>::DeallocateChain(int& c)
{
 
}
/************************************************************************
Function:释放一个循环链表
Parameter:
Return:
************************************************************************/
template <class T>
void SimSpace<T>::DeallocateCircular(int& c)
{
 if (c!=-1) {
  int nNext = m_snNode[c].m_nLink;
  m_snNode[c].m_nLink = m_nFirst;
  m_nFirst = nNext;
  c = -1;//释放该链表首地址相当于将指针赋值为0
 }
}
 

 
/************************************************************************
模拟指针链表类定义
************************************************************************/

/************************************************************************
Function:析构函数
Parameter:
Return:
************************************************************************/
template <class T>
SimChain<T>::~SimChain()
{
 Destroy();
}
/************************************************************************
Function:释放链表节点
Parameter:
Return:
************************************************************************/
template <class T>
void SimChain<T>::Destroy()
{
 int nNext;
 while (m_nFirst!=-1) {
  nNext = m_ssSpace.m_snNode[m_nFirst].m_nLink;
  m_ssSpace.Deallocate(m_nFirst);
  m_nFirst = nNext;
 }
}
/************************************************************************
Function:链表长度
Parameter:
Return:
************************************************************************/
template <class T>
int SimChain<T>::Length() const
{
 int nCurrent = m_nFirst;
 int nLength = 0;
 while (nCurrent != -1) {
  nCurrent = m_ssSpace.m_snNode[nCurrent].m_nLink;
  nLength++;
 }
 return nLength;
}
/************************************************************************
Function:按索引搜索
Parameter:
Return:
************************************************************************/
template <class T>
bool SimChain<T>::Find(int nIndex,T& nValue) const
{
 if (nIndex < 1) {
  return false;
 }
 int nCurrent = m_nFirst;
 int i = 1;//当前索引
 while (i < nIndex&&nCurrent != -1) {
  nCurrent = m_ssSpace.m_snNode[nCurrent].m_nLink;
  i++;
 }
 if (nCurrent != -1) {
  nValue = m_ssSpace.m_snNode[nCurrent].m_Data;
  return true;
 }
 return false;//不存在第nIndex个元素
}
/************************************************************************
Function:按值查找
Parameter:
Return:
************************************************************************/
template <class T>
int SimChain<T>::Search(const T& nValue) const
{
 int nCurrent = m_nFirst;
 int nIndex = 1;
 T temp;
 temp = m_ssSpace.m_snNode[nCurrent].m_Data;
 while (m_ssSpace.m_snNode[nCurrent].m_Data!=nValue&&nCurrent != -1) {
  nCurrent = m_ssSpace.m_snNode[nCurrent].m_nLink;
  nIndex++;
 }
 if (nCurrent != -1) {
  return nIndex;
 }
 return 0;
}
/************************************************************************
Function:删除节点
Parameter:
Return:
************************************************************************/
template <class T>
SimChain<T>& SimChain<T>::Delete(int nIndex,T& nValue)
{
 if (nIndex < 1||m_nFirst == -1) {
  throw OutOfBounds();
 }
 int p = m_nFirst;
 //将p移动至第nIndex个节点，并从链表中删除该节点
 if (nIndex == 1) {
  m_nFirst = m_ssSpace.m_snNode[m_nFirst].m_nLink;
 }else{
  int q = m_nFirst;
  int i;
  //q移动至nIndex-1个元素
  for (i = 1;i < nIndex-1&& q != -1;i++) {
   q = m_ssSpace.m_snNode[q].m_nLink;
  }
  if (q == -1||m_ssSpace.m_snNode[q].m_nLink == -1) {
   throw OutOfBounds();
  }
  p = m_ssSpace.m_snNode[q].m_nLink;
  m_ssSpace.m_snNode[q].m_nLink = m_ssSpace.m_snNode[p].m_nLink;
 }
 //保存第k个元素并释放节点p
 nValue = m_ssSpace.m_snNode[p].m_Data;
 m_ssSpace.Deallocate(p);
 return *this;
}
/************************************************************************
Function:插入节点
Parameter:
Return:
************************************************************************/
template <class T>
SimChain<T>& SimChain<T>::Insert(int nIndex,const T& nValue)
{
 if (nIndex < 0) {
  throw OutOfBounds();
 }
 int p = m_nFirst;
 //将p移动至第nIndex个节点
 int i;
 //q移动至nIndex-1个元素
 for (i = 1;i < nIndex-1&& p != -1;i++) {
  p = m_ssSpace.m_snNode[p].m_nLink;
 }
 //验证第nIndex个节点存在性
 if (nIndex >0 && p == -1) {
  throw OutOfBounds();
 }

 int nNewNode = m_ssSpace.Allocate();
 m_ssSpace.m_snNode[nNewNode].m_Data = nValue;
 //插入位置
 if (nIndex) {
  m_ssSpace.m_snNode[nNewNode].m_nLink = m_ssSpace.m_snNode[p].m_nLink;
  m_ssSpace.m_snNode[p].m_nLink = nNewNode;
 }else{//首部插入
  m_ssSpace.m_snNode[nNewNode].m_nLink = m_nFirst;
  m_nFirst = nNewNode;
 }
 return *this;
}
/************************************************************************
Function:
Parameter:
Return:
************************************************************************/
template <class T>
void SimChain<T>::Output(ostream& out) const
{
 int nNext = m_nFirst;

 while (nNext != -1) {
  out << m_ssSpace.m_snNode[nNext].m_Data << " ";
  nNext = m_ssSpace.m_snNode[nNext].m_nLink;
 }
}
/************************************************************************
Function:
Parameter:
Return:
************************************************************************/
template <class T>
void SimChain<T>::InsertSort()
{
 SimNode<T> *cnCurrent,*cnNext,*cnTemp,*cnTempLink;
 if (m_nFirst == -1) {//空表
  return;
 }
 cnCurrent = m_nFirst;
 cnNext = cnCurrent->m_Link;
 if (cnNext == -1) {//一个元素
  return;
 }
 while (cnNext != -1) {
  cnTemp = m_nFirst;
  while (cnNext->m_Data>cnTemp->m_Data) {
   cnTemp = cnTemp->m_Link;
  }
  if (cnNext==cnTemp) {//同一个节点
   cnCurrent = cnNext;
   cnNext = cnCurrent->m_Link;
   continue;
  }
  //交换位置
  cnCurrent->m_Link = cnNext->m_Link;
  cnNext->m_Link = cnTemp->m_Link;
  cnTemp->m_Link = cnNext;
  cnNext = cnCurrent->m_Link;
 }
}
/************************************************************************
Function:
Parameter:
Return:
************************************************************************/
template <class T>
ostream& operator<<(ostream& out,const SimChain<T>& scValue)
{
 scValue.Output(out);
 return out;
}