数据结构之 循环表线性表

//循环表
#define _SEQ_MAXLEN 100
typedef int DataType;
class CirSeqList
{
public:
CirSeqList();
CirSeqList(DataType ary[],int n);
void Initial(DataType ary[], int n);
DataType Next(bool move);
DataType Current();
DataType Previous(bool move);
DataType Get(int index);

void Set(int index,DataType data);

void SetCurrent(DataType data);

void SetCurNum(int n);
int GetCurNum();

void Move(int shift);

bool IsLegal(int index);
private:
DataType list[_SEQ_MAXLEN];
int cur,len;

void Shift(int *index,int shift);
};

CirSeqList::CirSeqList()
{
len = 0;
cur = -1;
}

CirSeqList::CirSeqList(DataType ary[], int n)
{
Initial(ary, n);
}

void CirSeqList::Initial(DataType ary[], int n)
{
if (n > _SEQ_MAXLEN)
{
CirSeqList();
return;
}
len = 0;
for (int i = 0; i < n; i++)
{
list[len++] = ary[i];
}
cur = 0;
}

DataType CirSeqList::Get(int index)
{
if (IsLegal(index))
{
return list[index];
}
else
{
return 0;
}
}

DataType CirSeqList::Next(bool move = true)
{
int tar = cur;
Shift(&tar, 1);
Move(move);
return Get(tar);
}

DataType CirSeqList::Current()
{
return Get(cur);
}

DataType CirSeqList::Previous(bool move = false)
{

int tar = cur;
Shift(&tar, -1);
Move(-move);
return Get(tar);
}

void CirSeqList::SetCurNum(int n)
{
if (IsLegal(n))
{
cur = n;
}
}

int CirSeqList::GetCurNum()
{
return cur;
}

void CirSeqList::Move(int shift)
{
Shift(&cur, shift);
}

void CirSeqList::Shift(int *index,int shift)
{
int tar = *index;
//周期处理
if (shift<=-len)
{
shift = -((-shift) % len);
}
else if (shift>=len )
{
shift = shift % len;
}
//加偏移，这个时候不可能出现周期情况。
tar += shift;
if (tar < 0)
{
tar+=len;
}
else if (tar >= len)
{
tar-=len;
}

//保险判断
if (IsLegal(tar))
{
*index = tar;
}
}

void CirSeqList::SetCurrent(DataType data)
{
Set(cur, data);
}

void CirSeqList::Set(int index, DataType data)
{
if (IsLegal(index))
{
list[index] = data;
}
}

bool CirSeqList::IsLegal(int index)
{
if (index >= 0 && index<len)
{
return true;
}
else
{
return false;
}
}