一、实现MyVector
顺序表
#include<iostream>
#include<assert.h>
using namespace std;
typedef int DataType;
class MyVector{
public:
//(1)构造空vector
MyVector()
:_array(new DataType[3])
, _size(0)
,_capacity(3)
{}
//(2)构造有n个值为data的元素
//data为内置对象-->0
// 自定义--》调datatype类的缺省的构造函数
MyVector(size_t n, const DataType& data=DataType())
:_array(new DataType[n])
, _size(n)
, _capacity(n)
{
size_t i;
for (i = 0; i < n; ++i)
{
_array[i]=data;
}
}
//(3)用区间进行构造
MyVector(DataType* first, DataType* last)
{
size_t size = last - first;
_array = new DataType[size];
_capacity = size;
_size = size;
int i;
for (i = 0; i < size; i++)
{
_array[i] = first[i];
}
}
//拷贝构造
MyVector(const MyVector& v)
:_array(NULL)
, _size(0)
, _capacity(0)
{
MyVector tmp(v._array,v._array+v._size);
swap(_array, tmp._array);
swap(_size, tmp._size);
swap(_capacity, tmp._capacity);
}
//赋值
MyVector& operator=(const MyVector& v)
{
if (this != &v)
{
MyVector tmp(v._array, v._array + v._size);
swap(_array, tmp._array);
swap(_size, tmp._size);
swap(_capacity, tmp._capacity);
}
return *this;
}
//析构
~MyVector()
{
if (_array)
{
delete[] _array;
_array = NULL;
_size = 0;
_capacity = 0;
}
}
//通过下标访问
DataType& operator[](size_t index)
{
assert(index < _size);
return _array[index];
}
const DataType& operator[](size_t index) const
{
assert(index < _size);
return _array[index];
}
//返回头
DataType& Front()
{
return _array[0];
}
const DataType& Front() const
{
return _array[0];
}
//返回尾
DataType& Back()
{
return _array[_size - 1];
}
const DataType& Back() const
{
return _array[_size - 1];
}
//返回个数
size_t Size() const
{
return _size;
}
size_t Capacity() const
{
return _capacity;
}
//改为n个元素,多出来的写为data
void Resize(size_t newSize, const DataType& data=DataType())
{
size_t oldSize = Size();
if (newSize <= oldSize)
{
_size= newSize;
}
else
{
if (newSize <= _capacity)
{
size_t i;
for (i = oldSize; i < newSize; i++)
{
_array[i] = data;
}
}
else
{
//开辟空间
DataType* tmp = new DataType[newSize];
//将老数据搬进来
size_t i;
for (i = 0; i < oldSize; i++)
{
tmp[i] = _array[i];
}
//将剩下的用data填充
for (i = oldSize; i < newSize; i++)
{
tmp[i] = data;
}
//将老空间释放
delete[] _array;
_array = tmp;
_size = newSize;
_capacity = newSize;
}
}
}
//当前顺序表预留空间,不能改变顺序表中有效元素个数
void Reserve(size_t NewCapacity)
{
size_t oldCapacity = Capacity();
if (NewCapacity > oldCapacity)
{
//申请空间
DataType* tmp = new DataType[NewCapacity];
//将数据搬过来
for (size_t i = 0; i < Size(); ++i)
{
tmp[i] = _array[i];
}
//释放老空间
delete[] _array;
_array = tmp;
_capacity = NewCapacity;
}
}
//尾插
void PushBack(const DataType& data)
{
_checkCapacity();
_array[_size++]=data;
}
//尾删
void Pop()
{
--_size;
}
//任意位置插入
void Insert(size_t pos, const DataType& data);
//任意位置删除
void Erase(size_t pos);
//复杂度太大
//清空
void clear()
{
_size = 0;
}
private:
void _checkCapacity()
{
if (_size == Capacity())
Reserve(2 *Capacity());
}
friend ostream& operator<<(ostream& out, const MyVector& v)
{
size_t i;
for (i = 0; i < v._size; ++i)
out <<v. _array[i] << " ";
return out;
}
private:
DataType* _array;
size_t _size;
size_t _capacity;
};
2. MyList
链表
#include<iostream>
using namespace std;
//带头结点的双向循环链表
typedef int DataType;
struct ListNode
{
ListNode(const DataType& data=DataType())
:_pNext(NULL)
, _pPre(NULL)
, _data(data)
{}
ListNode* _pNext;
ListNode* _pPre;
DataType _data;
};
class Mylist
{
public:
//无参
Mylist()
{
//创建头结点
CreateHead();
}
//将n个结点初始化为data
Mylist(size_t n, const DataType& data)
{
CreateHead();
for (size_t i = 0; i < n; i++)
{
PushBack(data);
}
}
//传区间
Mylist(DataType* pFirst, DataType* pLast)
{
CreateHead();
while (pFirst != pLast)
{
PushBack(*pFirst);
pFirst++;
}
}
//拷贝构造
Mylist(const Mylist& l)
{
CreateHead();
ListNode* pcur = l._pHead->_pNext;
while (pcur != l._pHead)
{
PushBack(pcur->_data);
pcur = pcur->_pNext;
}
}
//赋值
Mylist& operator=(const Mylist l)
{
if (this != &l)
{
Clear();
ListNode* pcur = l._pHead->_pNext;
while (pcur != l._pHead)
{
PushBack(pcur->_data);
pcur = pcur->_pNext;
}
}
return *this;
}
//析构
~Mylist()
{
//销毁链表中的有效结点-- - 头删法
Clear();
Destroy();
}
//
//个数
size_t Size() const
{
size_t cout = 0;
ListNode* pcur = _pHead->_pNext;
while (pcur != _pHead)
{
cout++;
pcur = pcur->_pNext;
}
return cout;
}
//是否为空
bool Empty() const
{
return _pHead->_pNext = _pHead;
}
//改为n个元素,多出来的写data
void Resize(size_t n, const DataType& data = DataType())
{
size_t oldSize = Size();
if (oldSize >= n)
{
for (size_t t = n; t < oldSize; ++t)
{
PopBack();
}
}
else
{
for (size_t i = oldSize; i < n; i++)
{
PushBack(data);
}
}
}
//返回头
DataType& Front()
{
return _pHead->_pNext->_data;
}
const DataType& Front() const
{
return _pHead->_pNext->_data;
}
//返回尾
DataType& Back()
{
return _pHead->_pPre->_data;
}
const DataType& Back() const
{
return _pHead->_pPre->_data;
}
///
//尾插
void PushBack(const DataType& data)
{
ListNode* pNew = new ListNode(data);
pNew->_pPre = _pHead->_pPre;
pNew->_pNext = _pHead;
_pHead->_pPre = pNew;
pNew->_pPre->_pNext = pNew;
}
//尾删
void PopBack()
{
ListNode* del = _pHead->_pPre;
if (del!=_pHead){
_pHead->_pPre = del->_pPre;
del->_pPre->_pNext = _pHead;
delete del;
}
}
//头插
void PushFront(const DataType& data)
{
ListNode* pNew = new ListNode(data);
pNew->_pPre = _pHead;
pNew->_pNext = _pHead->_pNext;
_pHead->_pNext = pNew;
pNew->_pNext->_pPre = pNew;
}
//头删
void PopFront()
{
ListNode* del=_pHead->_pNext;
if (del != _pHead){
_pHead->_pNext = del->_pNext;
del->_pNext->_pPre = _pHead;
delete del;
}
}
//任意位置插入
void Insert(ListNode* pos,const DataType& data)
{
ListNode* pNew = new ListNode(data);
pNew->_pPre = pos->_pPre;
pNew->_pNext = pos;
pNew->_pPre->_pNext = pNew;
pos->_pPre = pNew;
}
//任意位置删除
void Erase(ListNode* pos)
{
if (pos)
{
pos->_pPre->_pNext = pos->_pNext;
pos->_pNext->_pPre = pos->_pPre;
delete pos;
}
}
//清空
void Clear()
{
ListNode* pcur = _pHead->_pNext;
while (pcur != _pHead)
{
_pHead->_pNext = pcur->_pNext;
delete pcur;
pcur = _pHead->_pNext;
}
_pHead->_pNext = _pHead;
_pHead->_pPre = _pHead;
}
//查找
ListNode* Find(const DataType& data)
{
ListNode* pcur = _pHead->_pNext;
while (pcur != _pHead)
{
if (pcur->_data == data)
return pcur;
pcur = pcur->_pNext;
}
return NULL;
}
private:
void Destroy()
{
delete _pHead;
_pHead =0;
}
void CreateHead()
{
_pHead = new ListNode;
_pHead->_pNext = _pHead;
_pHead->_pPre = _pHead;
}
friend ostream& operator<< (ostream& _cout, const Mylist& l)
{
ListNode* pcur = l._pHead->_pNext;
while (pcur !=l._pHead)
{
_cout << pcur->_data << " ";
pcur = pcur->_pNext;
}
return _cout;
}
private:
ListNode* _pHead;
};