C++实现顺序表的基本操作

顺序表的主要功能有：
1、初始化顺序表
2、顺序表的头插
3、顺序表的尾插
4、顺序表的头删
5、顺序表的尾删
6、顺序表的任意点插入
7、顺序表的查找删除
8、顺序表的排序
9、清空顺序表
10、打印顺序表

代码实现：

typedef int DataType;
#define MAX 5

class SeqList
{
public:
    SeqList()
        :_pData(new DataType[3])
        , _capacity(3)
        , _size(0)
    {}

    SeqList(DataType* array,size_t size)
        :_pData(new DataType[size])
        , _capacity(size)
        , _size(size)
    {
        //memccpy(_pData, array, sizeof(DataType),_size);
        for (size_t i = 0; i < size; ++i)
            _pData[i] = array[i];
    }

    SeqList(const SeqList& s)
        :_pData(new DataType[s._size])
        , _capacity(s._size)
        , _size(s._size)
    {
        for (size_t i = 0; i < _size; ++i)
            _pData[i] = s._pData[i];
    }

    SeqList& operator=(const SeqList& s)
    {
        if (this != &s)
        {
            DataType* pTemp = new DataType[s._size];
            for (size_t i = 0; i < s._size; ++i)
                pTemp[i] = s._pData[i];
            delete[] _pData;
            _pData = pTemp;
        }
        return *this;
    }

    ~SeqList()
    {
        if (_pData)
        {
            delete[] _pData;
            _pData = NULL;
            _capacity = 0;
            _size = 0;
        }
    }

    void Print()//打印顺序表
    {
        if (_size > 0)
        {
            for (size_t i = 0; i < _size; ++i)
                cout << _pData[i] << " ";
            cout << endl;
        }
        else
            cout << "顺序表为空" << endl;
    }

    void CheckCapacity()//顺序表扩容
    {
        if (_size < _capacity)
        {
            return;
        }
        else
        {
            DataType* pTemp = new DataType[_size+MAX*2];
            for (size_t i = 0; i <_size; ++i)
                pTemp[i] =_pData[i];
            delete[] _pData;
            _pData = pTemp;
            _capacity = _size + MAX * 2;
            cout << "增容成功"<<endl;
        }
    }
    void PushBack(const DataType data)//顺序表的尾插
    {
        CheckCapacity();
        _pData[_size++] = data;
    }

    void PopBack()//顺序表的尾删
    {
        if (_size > 0)
         _size--;
    }
    void PushFront(DataType x) //顺序表的头插
    {
        CheckCapacity();
        for (size_t i = _size; i >0; --i)
        {
            _pData[i] = _pData[i-1];
        }
        _pData[0] = x;
        _size++;
    }
    void PopFront()//顺序表的头删
    {
        if (_size > 0)
        {
            for (size_t i = 0; i < _size-1; ++i)
            {
                _pData[i] = _pData[i+1];
            }
            --_size;
        }
    }
    void InsertSeqList(size_t x, DataType y)//顺序表的插入
    {
        CheckCapacity();
        if (x>0 && x < _size)
        {
            for (size_t i = _size-1; i>=x; --i)
                _pData[i+1] = _pData[i];
            _pData[x] = y;
            ++_size;
        }
        else
        {
            cout << "index is error" << endl;
        }
    }
    int FindSeqList(DataType x)//顺序表查找元素
    {
        for (size_t i = 0; i < _size; ++i)
        {
            if (_pData[i] == x)
                return i;
        }
        return -1;
    }
    void DeleteSeqList(DataType x)//顺序表删除
    {
        int index = 0;
        if (_size>0)
        {
            index = FindSeqList(x);
            if (index != -1)
            {
                for (size_t i = index; i < _size-1; ++i)
                    _pData[i] = _pData[i + 1];
                --_size;
            }
            else
                cout << "没有你要查找的数据" << endl;
        }
    }
    void SeqListSort()//顺序表排序
    {
        for (size_t i = 0; i < _size - 1; ++i)
        {
            int flag = 0;
            for (size_t j = 0; j < _size - i - 1; ++j)
            {
                if (_pData[j]>_pData[j + 1])
                {
                    swap(_pData[j], _pData[j + 1]);
                    flag = 1;
                }
            }
            if (flag == 0)
                break;
        }
    }
    void EmptySeqList()//清空顺序表
    {
        _size = 0;
    }

    size_t Size()const
    {
        return _size;
    }

    size_t Capacity()const
    {
        return _capacity;
    }

    bool Empty()const
    {
        return 0 == _size;
    }

    DataType& operator[](size_t index)
    {
        assert(index < _size);
        return _pData[index];

    }
    const DataType& operator[](size_t index)const
    {
        assert(index < _size);
        return _pData[index];
    }

    DataType& Front()
    {
        return _pData[0];
    }

    const DataType& Front()const
    {
        return _pData[0];
    }

    DataType& Front()
    {
        return _pData[0];
    }

    DataType& Back()
    {
        return _pData[_size-1];
    }

    const DataType& Back()const
    {
        return _pData[_size - 1];
    }
    friend ostream& operator<<(ostream& cout, const SeqList& s);
private:
    DataType* _pData;  
    size_t _capacity;  //最大元素的个数
    size_t _size;      //有效元素  
};

ostream& operator<<(ostream& cout, const SeqList& s)
{
    for (size_t i = 0; i < s._size; ++i)
        cout << s._pData[i];
    return cout;
}


int main()
{
    int array[10] = { 1, 2, 7, 4, 5, 6, 7, 8, 9, 10 };
    SeqList s1(array, sizeof(array) /sizeof(array[0]));
    SeqList s2(s1);
    SeqList s3 = s2;
    s1.Print();
    s2.Print();
    s3.Print();
    s1.PushBack(11);
    s1.Print();
    s1.PopBack();
    s1.Print();
    s1.PushFront(12);
    s1.Print();
    s1.PopFront();
    s1.Print();
    s1.InsertSeqList(4, 15);
    s1.Print();
    s1.DeleteSeqList(15);
    s1.Print();
    s1.SeqListSort();
    s1.Print();
    s1.EmptySeqList();
    s1.Print();
    return 0;
}

运行结果：