C++实现顺序表

C++实现顺序表

顺序表是用数组来实现的，把数据放在数组中，实现其基本的增删查改。

以下为实现源代码：

 //C++实现顺序表**strong 
#pragma once
#include<iostream>
#include<assert.h>
using namespace std;
typedef int DataType;
class SeqList
class SeqList
{
  public:
SeqList()
    :_array(NULL)
    ,_size(0)
    ,_capacity(0)
{}
 //s1(s2)
SeqList(const SeqList& s)
{
    if(s._array)
    {
        _array = (DataType*)malloc(sizeof(DataType)*s._size);//深拷贝，拷空间
        memcpy(_array,s._array,sizeof(DataType)*s._size);
    }
    else
    {
        _array = NULL;
    }
    _size = s._size;
    _capacity = s._capacity;
}


//SeqList& operator=(const SeqList& s)//传统写法
//{
//  if(this != &s)
//  {
//      if(s._array)
//      {
//          DataType* tmp = (Datatype*)malloc(sizeof(DataType)*s._size);
//          memcpy(tmp,s._array,sizeof(DataType)*s._size);
//          free(_array);
//          _array = tmp;
//      }
//      else
//      {
//          free(_array);
//          _array = NULL;
//      }
//      _size = s._size;
//      _capacity = s._capacity;
//  }
//  return *this;

//}

//s1=s2  s1.operator=(&s1,s2)
SeqList& operator=(SeqList s)  //现代写法
{
    this->Swap(s); //Swap(this,s)
    return *this;
}

~SeqList()
{
    if(_array)
    {
        free(_array);
        _size = _capacity = 0;
        _array = NULL;
    }
}

void Swap(SeqList& s)
{
    swap(_array,s._array);
    swap(_size,s._size);
    swap(_capacity,s._capacity);
}
void PushBack(DataType x)//尾插(可以复用Insert(_size,x) )
{
    CheckCapacity();
    _array[_size] = x;
    ++_size;
}

void PopBack()//尾删
{
    if(_size == 0)
        return;
    --_size;//size为无符号整型，当减到-1时会出错，所以要进行断言
}

void PushFront(DataType x)//头插
{
    CheckCapacity();
    for(int end=_size-1; end>=0; --end)
    {
        _array[end+1] = _array[end];
    }
    _array[0] = x;
    ++_size;
}

void PopFront()//头删
{
    if(_size == 0)
        return;
    for(size_t i=0; i<_size; i++)
    {
        _array[i] = _array[i+1];
    }
    --_size;
}

void Insert(size_t pos, DataType x)
{
    assert(pos <= _size);
    CheckCapacity();
    for(int end=_size-1; end>=(int)pos; --end)
    {
        _array[end+1] = _array[end];
    }
    _array[pos] = x;
    ++_size;
}

void Erase(size_t pos)
{
    assert(pos <= _size);
    for(size_t i=pos; i<_size; ++i)
    {
        _array[i] = _array[i+1];
    }
    --_size;
}
DataType& operator[](size_t pos)
{
    assert(pos < _size);
    return _array[pos];
}
void CheckCapacity()
{
    if(_size == _capacity)
    {
        _capacity = _capacity*2+3;
        _array = (DataType*)realloc(_array,_capacity*sizeof(DataType));
    }
}
void Print()
{
    for(size_t i=0; i<_size; ++i)
    {
        cout<<_array[i]<<" ";
    }
    cout<<endl;
}
private:
    DataType* _array;
    size_t _size;
    size_t _capacity;
};

以下为测试用例：

void TestSeqList1()
{
  SeqList s;
  s.PushBack(1);
  s.PushBack(2);
  s.PushBack(3);
  s.PushBack(4);

s.PopBack();
s.PopBack();
s.PopBack();
s.PopBack();
s.PopBack();

s.Print();
}


 void TestSeqList2()
 {
   SeqList s;
   s.PushFront(1);
   s.PushFront(2);
   s.PushFront(3);
   s.PushFront(4);
//s.PopFront();
//s.PopFront();
//s.PopFront();
//s.PopFront();
//s.PopFront();

//s.Insert(0,5);
//s.Insert(5,6);

//s.Erase(0);
//s.Erase(5);//尾删
 //   cout<<s[2]<<endl;
   s.Print();

SeqList s1(s);
SeqList s2;
s2 = s1;
s1.Print();
s2.Print();
}