用C++实现顺序表

Posted 2020-06-21

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;

}