顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。这样的存储方式使得线性表逻辑上相邻的元素，其在物理存储单元中也是相邻的。只要知道了第一个元素的存储地址，就可以知道线性表中任何一个元素的存储地址。本文利用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__
代码当中的问题及思考提示将在下一篇文章中探讨。