C++实现顺序表

顺序表可以看做是一个数组用来存放数据

下面用C++来实现顺序表

#include<iostream>
#include<assert.h>
using namespace std;
typedef int DataType;
class SeqList//顺序表
{
private:
    DataType*_array;
    size_t _size;
    size_t _capacity;
public:
    SeqList()
        :_array(NULL)
        ,_size(0)
        ,_capacity(0)
    {}
    ~SeqList()
    {
        if(_array==NULL)
        {
            return;
        }
        delete[]_array;
    }
    SeqList(const SeqList&s)//拷贝构造，深浅拷贝
    {
        _array = (DataType*)malloc(s._size*sizeof(DataType));
        memcpy(_array,s._array,s._size*sizeof(DataType));
        _size = _capacity = s._size;//拷贝size大小的空间
    }
    SeqList&operator = (const SeqList&s)
    {
    //  //传统写法
    //  //if(this!=&s)
    //  //{
    //  //  _array = (DataType*)malloc(s._size*sizeof(DataType));
    //  //  memcpy(_array,s._array,s._size*sizeof(DataType));
    //  //  _size = _capacity = s._size;//拷贝size大小的空间 
    //  //}
    //  //return *this;
    //  //现代写法
        if(this!=&s)
        {
            SeqList tmp(s);//拷贝构造出来，就不用再开空间
            Swap(tmp);
        }
        return *this;
    }
    //赋值运算符的另一种写法
    //SeqList&operator = (SeqList s)//直接传值
    //{
    //  Swap(s);
    //  return *this;
    //}
    void PushBack(DataType d)
    {
        CheckCapacity();
        Insert(_size,d);//实现复用代码
        /*_array[_size++] = d;*/

    }
    void PopBack()
    {

        if(_size==0)
        {
            return;
        }
        //--_size;
        Erase(_size-1);

    }
    void Swap(SeqList & s)//传引用，否则无法进行交换
    {
        swap(_array,s._array);
        swap(_size,s._size);
        swap(_capacity,s._capacity);
    }
    void PushFront(DataType x)
    {
        CheckCapacity();
        Insert(0,x);
        /*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-1;++i)
        {
            _array[i] = _array[i+1];
        }
        --_size;*/
        Erase(0);
    }
    void Insert(size_t pos, DataType x)
    {
        assert(pos<=_size);
        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-1;++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;
    }

};
//测试用例，可以自行写主函数进行测试
void SeListTest()
{
    SeqList s1;
    s1.PushBack(1);
    s1.PushBack(3);
    s1.PushBack(5);
    s1.PushBack(6);
    s1.PushFront(0);
    s1.PopFront();
    s1.Insert(2,0);
    s1.Erase(2);
    /*s1.PopBack();
    s1.PopBack();
    s1.PopBack();
    s1.PopBack();
    s1.PopBack();*/
    SeqList s2(s1);
    SeqList s3;


    s3 = s1;
    s3.Print();
    s2.Print();
    s1.Print();
}

void SeListTest1()
{
    SeqList s1;
    s1.PushBack(1);
    s1.PushBack(3);
    s1.PushBack(5);
    s1.PushBack(6);
    cout<<s1[3]<<endl;

}