「数据结构」：模拟指针(simulated pointer)

　　模拟指针，也就是清华严老师《数据结构－C语言描述》中的静态链表，静态链表的引用是使用一段连续的存储区还模拟指针的功能，可以有效的利用一段连续内存进行一定范围内可变的子链表的空间分配，此数据结构原理比较简单，但是实现起来（至少我个人感觉）有一些绕，原因在于结点的指针域和所申请的整个空间数组的下标都是用整型来表示，极易出错，由于使用连续存储区，稍有不甚将指针地址错写成数组下标则很容易出错并且很难被发现。

　　以下为本次实现的模拟指针代码，由三个文件构成：

　　1、 simulatedPointer.h     定义了模拟指针的一些基本结构和方法

　　2、excp.h　　　　　　　和前面一样，包含定制的异常类。

　　3、simulatedPointer.cp    测试用的主函数

 //simulatedPointer.h
 #ifndef __SIMULATEDPOINTER__
 #define __SIMULATEDPOINTER__
 #include <iostream>
 #include "excp.h"
 using namespace std;

 template<class T>
 class SimPointerList;

 template<class T>
 class Node {
 public:
     friend class SimPointerList<T>;
 private:
     T data;
     int next;
 };

 template<class T>
 class SimPointerList {
 public:
     SimPointerList(int maxaSize = );
     ~SimPointerList(){delete [] list;}
     int getFreeNode();
     void recycleFreeNode(int i);
     bool isEmpty() const;
     int getLength() const;
     SimPointerList<T>& deleteElement(int k, T& x);
     SimPointerList<T>& insertElement(int k, const T& x);
     void findElement(int k, T& x) const;
     int searchElement(const T& x) const;
     void output(ostream& out) const;
     int getFreeCapacity() const;
 private:
     int freeHeader;//point to the head of the free-list
     int usedHeader;
     int maxSize;
     Node<T> *list;
 };

 template<class T>
 SimPointerList<T>::SimPointerList(int maxaSize)
 {
     maxSize = maxaSize;
     freeHeader = ;
     usedHeader = -;
     list = new Node<T>[maxSize];
     for (int i=; i<maxSize-;i++)
         list[i].next = i+;
     list[maxSize-].next = -;
 }

 template<class T>
 int SimPointerList<T>::getFreeNode()
 {
     if (freeHeader == -)
         throw FullMemory();
     int i = freeHeader;
     freeHeader = list[i].next;
     list[i].next=-;
     return i;
 }

 template<class T>
 void SimPointerList<T>::recycleFreeNode(int i)
 {
     if (i< || i>=maxSize)
         throw OutOfBounds();
     list[i].next = freeHeader;
     freeHeader = i;
 }

 template<class T>
 bool SimPointerList<T>::isEmpty() const
 {
     return usedHeader == -;
 }

 template<class T>
 int SimPointerList<T>::getLength() const
 {
     int len = ;
     if (usedHeader != -)
         for (int begin=usedHeader; begin!=-; begin=list[begin].next)
             len++;
     return len;
 }

 template<class T>
 SimPointerList<T>& SimPointerList<T>::deleteElement(int k, T& x)
 {
     if (k<= || k>getLength())
         throw OutOfBounds();
     int index = ;
     if (k == )
     {
         index = usedHeader;
         usedHeader = list[usedHeader].next;
     }
     else if (getLength()== && k == )
     {
         index = list[usedHeader].next;
         list[usedHeader].next = -;
     }
     else
     {
         int prior = usedHeader;
         for (int i=; i<k-; i++)
             prior = list[prior].next;
         index = list[prior].next;
         list[prior].next = list[list[prior].next].next;
     }
     x = list[index].data;
     list[index].next = -;
     recycleFreeNode(index);
     return *this;
 }

 template<class T>
 SimPointerList<T>& SimPointerList<T>::insertElement(int k, const T& x)
 {
     int len = getLength();
     if (k< || k>len+)
         throw OutOfBounds();
     if (len == maxSize)
         throw FullMemory();
     int index = getFreeNode();//.next field has been setted by -1
     list[index].data = x;
     if (usedHeader == - || k == )
     {
         list[index].next = usedHeader;
         usedHeader = index;
         return *this;
     }

     int begin = usedHeader;
     for (int i=; i<k-; i++)
         begin = list[begin].next;
     list[index].next = list[begin].next;
     list[begin].next = index;
     return *this;
 }

 template<class T>
 int SimPointerList<T>::getFreeCapacity() const
 {
     return maxSize - getLength();
 }

 template<class T>
 void SimPointerList<T>::findElement(int k, T& x) const
 {
     if (k<= || k>getLength())
         throw OutOfBounds();
     int index = usedHeader;
     for (int i=; i<k; i++)
         index = list[index].next;
     x = list[index].data;
 }

 template<class T>
 int SimPointerList<T>::searchElement(const T& x) const
 {
     int index = usedHeader;
     int len = ;
     while (index != -)
     {
         if (list[index].data == x)
             break;
         index = list[index].next;
         len++;
     }
     return len;
 }

 template<class T>
 void SimPointerList<T>::output(ostream& out) const
 {
     int len = usedHeader;
     while (len != -)
     {
         out<<list[len].data<<" ";
         len = list[len].next;
     }
 }

 template<class T>
 ostream& operator<<(ostream& out, const SimPointerList<T>& x)
 {
     x.output(out);
     return out;
 }
 #endif

 //excp.h
 #ifndef _EXCP_
 #define _EXCP_
 #include <new>
 using namespace std;

 class OutOfBounds {
 public:
     OutOfBounds(){}
 };

 class FullMemory {
 public:
     FullMemory(){}
 };

 void my_new_handler()
 {
     throw FullMemory();
 }

 new_handler old_handler = set_new_handler(my_new_handler);
 #endif

 //simulatedPointer.cpp
 #include <iostream>
 #include "excp.h"
 #include "simulatedPointer.h"
 using namespace std;

 int main()
 {
     try{
         SimPointerList<int> L();
         cout<<"length : "<<L.getLength()<<endl;
         L.insertElement(, ).insertElement(, ).insertElement(, ).insertElement(, );
         cout<<"length : "<<L.getLength()<<endl;
         int x;
         cout<<L<<endl;
         L.findElement(, x);
         cout<<"The second element is : "<<x<<endl;
         L.deleteElement(, x);
         cout<<"delete : "<<x<<endl;
         cout<<"After delete : "<<L<<endl;
         cout<<"new length is : "<<L.getLength()<<endl;
         L.insertElement(, ).insertElement(, );
         cout<<"Least : "<<L<<endl;
         cout<<"Now the length is : "<<L.getLength()<<endl;
     }
     catch(OutOfBounds e)
     {
         cout<<"out of bounds error occured"<<endl;
     }
     catch(FullMemory e)
     {
         cout<<"full memory error occured"<<endl;
     }
     return ;
 }

总结：

　　1、如果要以传统思维来规范数组位置（下标从1开始），那就时刻要注意，在代码中时时小心处理和机器表示的区别，或者浪费一个存储空间list[0]以保持一致，

　　2、要区分开模拟的链表下标和数组下标（因为这个，找了近两个小时的BUG，整个人都快疯掉了）。

　　3、代码注意规范，变量、方法名尽量表达内丰含意。