数据结构关于顺序表的问题在数据结构中,顺序表判断为空的条件是顺序表的长度为0,但是初始化时候应该把长度设为0吗?如果是,是不是在输入的时候长度要相应的加长啊

数据结构关于顺序表的问题在数据结构中,顺序表判断为空的条件是顺序表的长度为0,但是初始化时候应该把长度设为0吗?如果是,是不是在输入的时候长度要相应的加长啊
数据结构关于顺序表的问题
在数据结构中,顺序表判断为空的条件是顺序表的长度为0,但是初始化时候应该把长度设为0吗?如果是,是不是在输入的时候长度要相应的加长啊

数据结构关于顺序表的问题在数据结构中,顺序表判断为空的条件是顺序表的长度为0,但是初始化时候应该把长度设为0吗?如果是,是不是在输入的时候长度要相应的加长啊
没错.确实是这样.这里有一段我写的顺序链表源代码、代码分俩个文件：Node、List
节点类模板
#ifndef NODE_H
#define NODE_H
using namespace std;
template
class Node
{
private:
Node *Next;//节点指针域,指向下一个节点
public:
T data;//数据存储域
Node();//无参构造函数
Node(Node &n);
Node(const T &data,Node *ptrNext=NULL);//有参构造函数
void insertAfter(Node *p);//往后插入
Node *insertH(Node *p);//往头部插入
Node *deleteAfter();//删除后一个节点
Node *NextNode();//返回指针域,即指向下一个节点的指针
};
template
Node::Node()
{
Next=NULL;
}
template
Node::Node(Node &n)
{
Next=n.Next;
}
template
Node::Node(const T &data,Node *ptrNext/*=NULL*/):data(data),Next(ptrNext){}
template
void Node::insertAfter(Node *p)
{
p->Next=Next;
Next=p;
}
template
Node *Node::insertH(Node *p)
{
p->Next=this;
return p;
}
template
Node *Node::NextNode()
{
return Next;
}
template
Node *Node::deleteAfter()
{
Node*p=Next;
Next=p->Next;
return p;
}
#endif
链表类模板
#ifndef LIST_H
#define LIST_H
#include"Node.h"
using namespace std;
template
class List
{
private:
Node *pH,//表头指针
 *pE,//表尾指针
*pPre,//前向指针
*pCur;//当前指针域
int nPos,//当前位置
nLength;//当前表的长度,元素个数
Node *NewNode(const T &item,Node*ptrNext=NULL);//建立新的节点,指针域默认为空
void freeNode(Node *p){delete p;};
public:
List();//无参构造函数
List(const List &l);//复制构造函数
//List& operator=(const List &l);
int GetSize()const;//获取表长
bool isEmpty()const;//判断是否为空
bool isEnd()const;//是否到达表尾
bool isStart()const;//是否在表头
void Reset(int pos=1);//设置当前记录位置
int CurrentPos()const;//返回当前记录位置
void MoveNext();//记录指针向下移一步
void InsertEnd(const T &item);//表尾插入
void InsertHead(const T &item);//表头插入
void InsertAfter(const T &item);//当前记录之后插入
void InsertPrev(const T &item);//当前记录之前插入
void DeleteCurrent();//删除当前记录
void Clear();//清空所有记录,只保留头指针
T &Data();//访问数据域
const T &Data()const;//数据域的常引用
};
template
List::List(const List &l)
{
l.Reset();
Clear();
while(!l.isEnd())
{
InsertEnd(l.Data());
l.MoveNext();
}
InsertEnd(l.Data());
}
template
void List::Clear()
{
while(!isEmpty())
{
DeleteCurrent();
}
}
template
void List::DeleteCurrent()
{
if(GetSize()==1)
{
pPre=pCur=pE=pH;
nPos=0;
}
else if(isStart())
{
pH=pH->NextNode();
pPre=pH;
pCur=pH->NextNode();
}
else
{
Node *p=pH;
while(pPre!=p->NextNode())
{
p=p->NextNode();
}
if(isEnd())
{
pPre=pCur=pE=p;
}
else
{
pPre=p->deleteAfter();
}
nPos--;
}
nLength--;
}
template
Node *List::NewNode(const T &item,Node *ptrNext/*=NULL*/)
{
Node *newNode=new Node(item,NULL);
if(newNode==NULL)
{
coutinsertH(NewNode(item)));
}
nLength++;
}
template
int List::CurrentPos()const
{
return nPos;
}
template
void List::InsertEnd(const T &item)
{
if(isEmpty())
{
nPos++;
pH=pPre=pH=pE=NewNode(item,NewNode(item));
}
else
{
pE->insertAfter(NewNode(item));
pE=pE->NextNode();
if(isEnd())
{
pCur=pE;
}
}
nLength++;
}
template
void List::MoveNext()
{
if(isEmpty())
{
cout