c++实现顺序表

顺序表是用一组地址连续的储存单元依次储存数据元素的线性结构。顺序表适合存储用来频繁的查找的数据结构。

头文件：

#ifndef _SEQLIST_H__
#define _SEQLIST_H__

#include<iostream>
using namespace std;


typedef int DataType;

class List
{
public:
    List();
    List(int size, DataType data);
    List(const List&l);
    List& operator=(const List&l);
    ~List();
public:
    //判断内存是否达到上限
    void CheckCapacity();
    //尾插
    void PushBack(const DataType& data);
    //weishan
    void PopBack();
    //找第一个值为data的位置
    int Find(const DataType& data);
    //任意位置插入
    void Insert(int pos,const DataType data);
    //任意位置删除
    void Erase(int pos);
    //求顺序表中实际元素的个数
    int Size()const;
    //判断链表是否为空
    bool Empty()const;
    //清空链表
    void Clear();
    //把链表中有效元素的个数改变到size个
    void Resize(int  size, const DataType& data);
    //[]操作符重载
    DataType& operator[](int  index);
    const DataType& operator[](int  index)const;
    //找顺序表的头
    DataType& Front();
    const DataType& Front()const;
    //找顺序表的尾
    DataType& Back();
    const DataType& Back()const;

public:
    void display();
private:
    DataType* _data;
    int _capacity;
    int _size;
};


#endif//_SEQLIST_H__

实现函数

#define _CRT_SECURE_NO_WARNINGS 1
#include"seqlist.h"


//构造函数
List::List()
:_data(NULL)
, _capacity(0)
, _size(0)
{
    _data = new DataType[2];
    _capacity = 2;
    _size=0;
}

List::List(int size, DataType data)
{
    _data = new DataType[size + 2];
    _capacity = size + 2;
    _size = size;
    for (int i = 0; i < size; i++)
    {
        _data[i] = data;
    }
}

//拷贝构造函数
List::List(const List&l)
{
    DataType* tmp = new DataType[l._capacity];
    for (int i = 0; i < l._size; i++)
    {
        tmp[i] = l._data[i];
    }
    _data = tmp;
    _capacity = l._capacity;
    _size = l._size;
    tmp = NULL;
}

//赋值运算符重载
List& List::operator=(const List& l)
{
    if (this != &l)
    {
        DataType* tmp = new DataType[l._capacity];
        for (int i = 0; i < l._size; i++)
        {
            tmp[i] = l._data[i];
        }
        _data = tmp;
        tmp = NULL;
        _capacity = l._capacity;
        _size = l._size;
    }
    return *this;
}

//析构函数
List::~List()
{
    if (_data)
    {
        delete[] _data;
    }
}

//判断是否需要增容
 void List:: CheckCapacity()
{
     if (_capacity == _size)
     {
         DataType* tmp = new DataType[_capacity * 2];
         for (int i = 0; i < _size; i++)
         {
             tmp[i] = _data[i];
         }
         delete[]_data;
         _data = tmp;
         _capacity *= 2;
     }
}

//尾插一个元素
void List:: PushBack(const DataType& data)
{
    if (NULL == _data)
    {
        return;
    }
    CheckCapacity();
    _data[_size] = data;
    _size++;
}

void List::PopBack()
{
    if (NULL == _data)
    {
        return;
    }
    if (0 == _size)
    {
        return;
    }
    _size--;
}

//查找顺序表中值为data第一个出现的位置
int List:: Find(const DataType& data )
{
    for (int i = 0; i < _size; i++)
    {
        if (_data[i] == data)
        {
            return i;
        }
    }
    return -1;
}

//任意位置插入一个元素
void List::Insert(int pos, const DataType data)
{
    if ((_size < pos) || (pos < 0))
    {
        return;
    }
    CheckCapacity();
    for (int i = _size; i>pos; i--)
    {
        _data[_size] = _data[_size - 1];
    }
    _data[pos] = data;
    _size++;
}

//任意位置删除一个元素
void List::Erase(int pos)
{
    if ((_size < pos) || (pos < 0))
    {
        return;
    }
    for (int i = pos; i < _size - 1; i++)
    {
        _data[pos] = _data[pos + 1];
    }
    _size--;
}

//返回顺序表中有多少个有效成员
int List::Size()const
{
    return _size;
}

//判断顺序表是否为空
bool List::Empty()const
{
    return (bool)(_size);
}

//清空顺序表
void List::Clear()
{
    _size = 0;
}

//把顺序表中有效元素个数该表到size个
void List::Resize(int  size, const DataType& data)
{
    if (_size > size)
    {
        _size = size;
    }
    else
    {
        CheckCapacity();
        for (int i = _size; i < size; i++)
        {
            _data[i] = data;
        }
    }
}


//[]操作符重载
DataType& List::operator[](int index)
{
    return _data[index];
}

const DataType& List::operator[](int index)const
{
    return _data[index];
}

//找到顺序表的头
DataType&List:: Front()
{

    return _data[0];
}

const DataType& List:: Front()const
{

    return _data[0];
}

//找到顺序表的的尾部
DataType& List::Back()
{
    return _data[_size-1];
}

const DataType& List::Back()const
{
    return _data[_size - 1];
}


void List::display()
{
    for (int i = 0; i < _size; i++)
    {
        cout << _data[i]<<"->";
    }
    cout<<"NULL"<<endl;
    cout << "capacity" << "=" << _capacity << endl;
    cout<<"size" << "="<<_size << endl;
}

测试函数

#define _CRT_SECURE_NO_WARNINGS 1
#include"seqlist.h"


void test1()
{
    List l1(3, 4);
    List l2(l1);
    l1.PushBack(1);
    l1.PushBack(2);
    l1.PushBack(3);
    l1.PushBack(4);
    l1.PushBack(5);
    l1.PopBack();
    l1.PopBack();
    l1.display();
    l1.List::Insert(3, 0);
    l1.display();
}

int main()
{

    test1();
    system("pause");
    return 0;
}