用C++实现顺序表

typedef int DataType;
#define DEFAULT_CAPACITY 7
#define DEFAULT_INC 9
#include<iostream>
#include<assert.h>
using namespace std;
class Seqlist
{
friend ostream& operator<<(ostream &os,const Seqlist &s);
public:
//构造函数
Seqlist(int capacity=DEFAULT_CAPACITY)
:_capacity(capacity)
,_size(0)
,_pdata(0)
{
_pdata=new DataType[_capacity];
}
//拷贝构造函数
Seqlist(const Seqlist& s)
:_size(s._size)
,_capacity(s._capacity)
{
_pdata=new DataType[_capacity];
memcpy(_pdata,s._pdata,_size*sizeof(DataType));
}
//operator=运算符重载
Seqlist &operator=(const Seqlist& s)
{
if(this!=&s)//防止自赋值
{
delete [] _pdata;//释放原来空间
_pdata=new DataType[s._capacity];//开辟新空间并复制
_size=s._size;
_capacity=s._capacity;
}
return *this;
}
//1尾插法建立顺序表
void pushback(const DataType &d);
//2尾删法清空顺序表
void popback(const DataType &s);
//3头插建立单链表
void pushfront(const DataType &d);
//4头删法清空顺序表
void popfront(const DataType &s);
//5插入某个数据
void InsertSeqList(Seqlist&s,int pos , DataType x);
//6寻找某个数据
int Find(Seqlist &s,DataType x);
//7删除某个位置的数据
void Erase(Seqlist &s,int pos);
//8找到某个数据并且删除
void Remove(Seqlist &s,DataType x);
//9翻转顺序表
void ReverseList(Seqlist& s);

//检测当前顺序表是否已满
void checkcapacity()
{
if(_size==_capacity)
{
DataType *tmp=new DataType[_capacity+ DEFAULT_INC];
memcpy(tmp,_pdata,_size*sizeof(DataType));
delete [] _pdata;
_pdata=tmp;
}
_capacity=_capacity+DEFAULT_INC;
}
//析构函数
~Seqlist()
{
if(_pdata!=NULL)
delete [] _pdata;
}

private:
DataType *_pdata;//指向顺序表的指针
int _size;//顺序表的大小
int _capacity;//顺序表的当前容量

};

ostream& operator<<(ostream &os,const Seqlist &s)
{
int i=0;
for(i=0;i<s._size;i++)
{
os<<s._pdata[i]<<" ";
}
return os;
}
//1尾插法建立顺序表
void Seqlist:: pushback(const DataType &d)
{
checkcapacity();
_pdata[_size]=d;
_size++;
}
//2尾删法清空顺序表
void Seqlist::popback( const DataType &s)
{
if(_size<=0)
{
cout<<"顺序表为空"<<endl;
return;
}
--_size;
}
//3头插建立单链表
void Seqlist::pushfront(const DataType &d)
{
checkcapacity();
int start=_size-1;
while(start>=0)
{
_pdata[start+1]=_pdata[start];
start--;
}
_pdata[0]=d;
_size++;
}
//4头删法清空顺序表
void Seqlist::popfront(const DataType &s)
{
if(_size<=0)
{
cout<<"顺序表为空"<<endl;
return;
}
int i=0;
for(i=0;i<_size;i++)
{
_pdata[i]=_pdata[i+1];
}
--_size;
}
//5插入某个数据
void Seqlist::InsertSeqList(Seqlist&s,int pos , DataType d)
{
int i=0;
assert(pos<_size&&pos>0);
checkcapacity();
for(i=_size;i>pos;i--)
{
_pdata[i]=_pdata[i-1];

}
_pdata[pos]=d;
++_size;
}
//6寻找某个数据
int Seqlist::Find(Seqlist &s,DataType d)
{
int i=0;
for(i=0;i<_size;i++)
{
if(_pdata[i]==d)
{
return i;
}
}
return -1;
}
//7删除某个位置的数据
void Seqlist::Erase(Seqlist &s,int pos)
{
int i=0;
assert(pos<_size&&pos>0);
for(i=pos+1;i<_size;i++)
{
_pdata[i-1]=_pdata[i];
}
--_size;
}
//8找到某个数据并且删除
void Seqlist::Remove(Seqlist &s,DataType x)
{
int pos=0;
pos=Find(s, x);
if(pos!=-1)
{
Erase(s,pos);
}
}
//9翻转顺序表
void Seqlist::ReverseList(Seqlist& s)
{
int start=0;
int end=_size-1;
while(start<end)
{
DataType tmp=_pdata[start];
_pdata[start]=_pdata[end];
_pdata[end]=tmp;
start++;
end--;
}
}
int main()
{
Seqlist seqlist1;
seqlist1.pushback(1);
seqlist1.pushback(2);
seqlist1.pushback(3);
seqlist1.pushback(4);
/*seqlist1.pushfront(5);
seqlist1.pushfront(6);
seqlist1.popfront(6);
seqlist1.popfront(5);
seqlist1.popback(4);
seqlist1.popback(4)*/;
seqlist1.InsertSeqList(seqlist1,1, 0);
seqlist1.Erase(seqlist1,1);
seqlist1.Remove(seqlist1,4);
seqlist1.ReverseList(seqlist1);
cout<<seqlist1<<endl;
/* cout<<seqlist2<<endl;*/
system("pause");
return 0;

}