C++实现动态顺序表

顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。这样的存储方式使得线性表逻辑上相邻的元素，其在物理存储单元中也是相邻的。只要知道了第一个元素的存储地址，就可以知道线性表中任何一个元素的存储地址。本文利用C++语言，在Windows平台 Visual Studio 2015开发环境下实现。功能：应用C++语言实现顺序表的各项操作。基本的成员函数：构造函数、拷贝构造函数、赋值运算符的重载、析构函数。

// 顺序表构造成功之后，里面存放了n个元素data
Vector(size_t n, const DataType& data = DataType());
Vector(const Vector& v);  
Vector& operator=(const Vector& v);
~Vector();

void PushBack(const DataType& data);  //尾插
void PopBack();  //尾删

void Print()//打印顺序表

// 给顺序表重新赋值，该函数执行完里面存放了n个元素data
void Assign(size_t n, const DataType& data);

// 在顺序表的pos位置上插入元素data
void Insert(size_t pos, const DataType& data);

// 删除顺序表pos位置上的元素
void Erase(size_t pos);

// 改变顺序表中的元素为n个，如果n>原来顺序表中的元素的个数，多出来的空间用data来填充
void ReSize(size_t n, const DataType& data = DataType());

// 清空顺序表中的元素-->请自己动手验证是否需要清理vector中的空间
void Clear();

// 返回顺序表中有效元素的大小
size_t Size()const;

// 返回顺序表中空间容量的大小
size_t Capacity()const;

// 顺序表是否为空，若为空返回true，否则返回null
bool Empty()const;

// 通过下边访问顺序表index位置上的元素。 思考为什么要成对的来重载
DataType& operator[](size_t index);
const DataType& operator[](size_t index)const;

// 返回顺序表中第一个元素的引用，思考为什么要返回应用，为什么要成对重载
DataType& Front();
const DataType& Front()const;

// 返回顺序表中最后一个的元素的引用，思考为什么要返回引用，为什么要成对重载
DataType& Back();
const DataType& Back()const;

void _CheckCapacity()// 动态扩容

int Find(const DataType & data)//查找数据

 #ifndef __VECTOR_H__
 #define __VECTOR_H__

 #include<iostream>
 #include<stdio.h>
 #include<assert.h>
 using namespace std;

 #define COW 4
 typedef int DataType;

 class Vector
 {
 public:
     Vector()
         : _array(NULL)
         , _size()
         , _capacity()
     {}

     // 顺序表构造成功之后，里面存放了n个元素data
     Vector(size_t n, const DataType& data = DataType())
     {
             _array = new DataType[n];
             _size = n;
             _capacity = n;
             for(size_t i = ; i<n;i++)
             _array[i] = data;

     }
     Vector(const Vector& v)
         :_array(new DataType[v._size])
         , _size(v._size)
         ,_capacity(v._capacity)
     {
         memcpy(_array, v._array, sizeof(DataType)*_size);
     }
     Vector& operator=(const Vector& v)
     {
         if (this != &v)
         {
             DataType *temp = new DataType[v._size];
             temp = v._array;
             delete[] _array;
             _array = temp;
             _size = v._size;
             _capacity = v._capacity;
             memcpy(_array, v._array, sizeof(DataType)*_size);
         }
         return *this;
     }
     ~Vector()
     {
         if (_array)
         {
             delete[] _array;
             _array = NULL;
             _size = ;
             _capacity = ;
         }
     }

 public:
     void PushBack(const DataType& data)
     {
         _CheckCapacity();
         _array[_size++] = data;
     }
     void PopBack()
     {
         assert(!Empty());
         --_size;
     }
     void Print()
     {
         for (size_t i = ; i < _size; ++i)
         {
             cout << _array[i] << " ";
         }
         cout << endl;
     }
     // 给顺序表重新赋值，该函数执行完里面存放了n个元素data
     void Assign(size_t n, const DataType& data)
     {
         assert(n<_size);
         for (size_t i = ; i<n; i++)
             _array[i] = data;
     }

     // 在顺序表的pos位置上插入元素data
     void Insert(size_t pos, const DataType& data)
     {
         assert(pos<_size);    //需检验pos的合法性
         _CheckCapacity();
         if (pos == _size - )  //在最后一个位置插入数据等于尾插
         {
             PushBack(data);
             return;
         }
         else
         {
             for (size_t i = _size; i > pos; --i)
             {
                 _array[i] = _array[i - ];
             }
             _array[pos] = data;
             _size++;
         }
     }

     // 删除顺序表pos位置上的元素
     void Erase(size_t pos)
     {
         assert(pos<_size);    //需检验pos的合法性
         if (pos == _size - )  //在最后一个位置删除数据等于尾删
         {
             PopBack();
             return;
         }
         else
         {
             for (size_t i = pos; i < _size - ; i++)
             {
                 _array[i] = _array[i + ];
             }
             --_size;
         }
     }

     // 改变顺序表中的元素为n个，如果n>原来顺序表中的元素的个数，多出来的空间
     // 请用data来填充
     void ReSize(size_t n, const DataType& data = DataType())
     {
         if (n > _size)
         {
             size_t i = _size;
             _size = n;
             _CheckCapacity();
             for (i; i < n; i++)
                 _array[i] = data;
         }
         else
         {
             size_t i = n;
             for(i; i<_size; i++)
                 PopBack();
         }
     }

     // 清空顺序表中的元素-->请自己动手验证是否需要清理vector中的空间
     void Clear()
     {
         delete[] _array;
         _array = NULL;
         _size = ;
         _capacity = ;
     }
     // 返回顺序表中有效元素的大小
     size_t Size()const
     {
         return _size;
     }
     // 返回顺序表中空间容量的大小
     size_t Capacity()const
     {
         return _capacity;
     }
     // 顺序表是否为空，若为空返回true，否则返回null
     bool Empty()const
     {
         return _size == ;
     }

     // 通过下边访问顺序表index位置上的元素
     // 思考为什么要成对的来重载
     DataType& operator[](size_t index)
     {
         assert(index);
         return _array[index];
     }
     const DataType& operator[](size_t index)const
     {
         assert(index);
         return _array[index];
     }
     // 返回顺序表中第一个元素的引用，思考为什么要返回应用，为什么要成对重载
     DataType& Front()
     {
         return _array[];
     }
     const DataType& Front()const
     {
         return _array[];

     }
     // 返回顺序表中最后一个的元素的引用，思考为什么要返回引用，为什么要成对重载
     DataType& Back()
     {
         return _array[_size - ];
     }
     const DataType& Back()const
     {
         return _array[_size - ];
     }
 private:
     // 动态扩容-->该函数中有坑，请找出坑在哪？
     void _CheckCapacity()
     {
         // 2*_capacity  有问题？
         if (_size >= _capacity)
         {
             DataType* pTemp = new DataType[_capacity * ];
             //memcpy(pTemp, _array, _size*sizeof(DataType));
             for (size_t index = ; index < _size; ++index)
                 pTemp[index] = _array[index];
             delete[] _array;
             _array = pTemp;
             _capacity *= ;
         }
     }
     int Find(const DataType & data)
     {
         assert(_array != NULL);
         for (size_t i = ; i < _size; i++)
         {
             if (_array[i] == data)
                 return i;
         }
         return -;
     }
 private:
     DataType* _array;
     size_t _size;  // 保存有效元素的个数
     size_t _capacity;  // 空间的实际大小
 };

 #endif //__VECTOR_H__

代码当中的问题及思考提示将在下一篇文章中探讨。