一、vector和list的使用
(1)vector
基本概念:vector的底层结构和数组类似,拥有一段连续的内存空间,并且起始地址不变。因此可以高效的进行随机随机存取,时间复杂度为o(1);但是因为内存空间是连续的,所以在进行插入和删除操作时,需要移动数据,当数组内存空间不足时,会重新申请一块内存块的拷贝,时间复杂度为o(N).
头文件:
#include<vector>
基本使用:
#include<iostream>
#include<vector>
using namespace std;
void TestVector()
{
vector<int> v;//创建一个容器
v.push_back(1);//在顺序表末尾插入数据
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
cout<<v.front()<<endl;//返回第一个元素
cout<<v.back()<<endl;//返回最后一个元素
v.insert(v.begin(),10);//插入数据
v.insert(v.begin(),20);
v.insert(v.begin(),30);
v.erase(v.begin());//删除指定位置元素
//v.assign(2,100);//改变顺序表的size,并重新赋值
vector<int>::iterator it = v.begin();
while(it != v.end())
{
cout<<*it<<" ";
++it;
}
cout<<endl;
cout<<v[2]<<endl;//访问第三个元素
cout<<v.at(2)<<endl;//访问第三个元素
v.pop_back();//删除最后一个数据
cout<<v.size()<<endl;//返回数据个数
cout<<v.capacity()<<endl;//返回容量
cout<<v.empty()<<endl;//判断顺序表是否为空
cout<<v.max_size()<<endl;//求最大的size
v.clear();//清空数据
//v.resize(5,200);//开空间并初始化
v.reserve(10);//不会影响size,只会把容量开够
cout<<v.capacity()<<endl;
vector<int>::iterator it1 = v.begin();
while(it1 != v.end())
{
cout<<*it1<<" ";
++it1;
}
cout<<endl;
}
int main()
{
TestVector();
return 0;
}
(2)list
基本概念:list由双向链表实现的,因此空间内存不是连续的。由于list的实现原理,所以随机存取非常没有效率,只能通过指针访问数据,时间复杂度为o(N).由于链表的特点,能高效地进行插入和删除。
头文件:
#include<list>
基本使用:
#include<iostream>
#include<list>
using namespace std;
void TestList()
{
list<int> l;//创建一个list容器
l.push_back(1);//在list进行尾插
l.push_back(2);
l.push_back(3);
l.push_back(3);
l.push_back(4);
l.push_back(3);
l.push_front(10);//在list进行头插
l.push_front(20);
l.push_front(30);
l.sort();//排序
l.unique();//去重,但要求重复的必须有序
l.erase(l.begin());//删除某个位置
l.remove(10);//删除指定元素
list<int> l1;
l1.push_back(9);
l1.push_back(8);
l1.push_back(7);
l1.sort();
l.merge(l1);//合并两个有序list
list<int>::iterator it = l.begin();
while(it != l.end())
{
cout<<*it<<" ";
++it;
}
cout<<endl;
l.pop_back();//尾删
l.pop_front();//头删
l.insert(l.begin(),60);//插入数据
l.insert(l.end(),60);
//l.assign(3,100);//改变list的size,并进行初始化
cout<<l.front()<<endl;//返回第一个元素
cout<<l.back()<<endl;//返回最后一个元素
cout<<l.size()<<endl;//返回元素个数
cout<<l.max_size()<<endl;//返回max_size
l.clear();//清空list
l.resize(5,100);//开空间并且进行初始化
cout<<l.empty()<<endl;//判断list是否为空
}
int main()
{
TestList();
return 0;
}
二、模拟实现MyVector
#include<iostream>
#include<assert.h>
using namespace std;
template <class T>
class Vector
{
public:
typedef T* Iterator;
typedef const T* ConstIterator;
public:
Vector()
:_start(NULL)
,_finsh(NULL)
,_endOfStorage(NULL)
{}
void PushBack(const T& x)
{
Iterator end = End();
Insert(end,x);
}
void Insert(Iterator& pos,const T& x)
{
size_t n = pos - _start;
if(_finsh == _endOfStorage)
{
size_t len = Capacity() == 0 ? 3 : Capacity()*2;
Expand(len);
}
pos = _start + n;
for(Iterator end = End();end != pos;--end)
{
*end = *(end-1);
}
*pos = x;
++_finsh;
}
void Erase(Iterator& pos)
{
assert(pos);
for(Iterator start = pos;start != End();++start)
{
*start= *(start+1);
}
--_finsh;
}
void PopBack()
{
if(_start == NULL)
{
return;
}
--_finsh;
}
void Resize(size_t n,const T& val = T())
{
if(n<Size())
{
_finsh = _start + n;
}
else
{
Reserve(n);
size_t len = n-Size();
for(size_t i = 0;i<len;i++)
{
PushBack(val);
}
}
}
void Reserve(size_t n)
{
Expand(n);
}
size_t Size()
{
return _finsh-_start;
}
size_t Capacity()
{
return _endOfStorage-_start;
}
Iterator End()
{
return _finsh;
}
Iterator Begin()
{
return _start;
}
void Expand(size_t n)
{
const size_t size = Size();
const size_t capacity = Capacity();
if(n>capacity)
{
T* tmp = new T[n];
for(size_t i = 0;i<size;++i)
{
tmp[i] = _start[i];
}
delete _start;
_start = tmp;
_finsh = _start + size;
_endOfStorage = _start + n;
}
}
T& operator[] (size_t pos)
{
assert(pos<Size());
return _start[pos];
}
const T& operator[](size_t pos)const
{
assert(pos<Size());
return _start[pos];
}
protected:
Iterator _start;
Iterator _finsh;
Iterator _endOfStorage;
};
void TestVector()
{
Vector<int> v;
v.PushBack(1);
v.PushBack(2);
v.PushBack(3);
v.PushBack(4);
Vector<int>::Iterator pos = v.Begin();
v.Erase(pos);
v.PopBack();
v.PopBack();
cout<<v.Size()<<endl;
cout<<v.Capacity()<<endl;
cout<<v[0]<<endl;
v.Resize(10);
Vector<int>::Iterator pos = v.Begin();
v.Insert(pos,10);
v.Insert(pos,20);
v.Insert(pos,30);
v.Insert(pos,40);
Vector<int>::Iterator it = v.Begin();
while(it != v.End())
{
cout<<*it<<" ";
++it;
}
cout<<endl;
}
int main()
{
TestVector();
return 0;
}
三、模拟实现MyList
#include <iostream>
#include<assert.h>
using namespace std;
template<class T>
struct __ListNode
{
T _data;
__ListNode<T>* _prev;
__ListNode<T>* _next;
__ListNode<T>(const T& x)
:_data(x)
,_next(NULL)
,_prev(NULL)
{}
};
template <class T,class Ref,class Ptr>
class __ListIterator
{
public:
typedef __ListNode<T> Node;
typedef __ListIterator <T,Ref,Ptr> Iterator;
__ListIterator(Node* node)
:_node(node)
{}
bool operator == (const Iterator& x)
{
return _node == x._node;
}
bool operator != (const Iterator& x)
{
return _node != x._node;
}
Iterator operator ++() //前置
{
_node = _node->_next;
return *this;
}
Iterator operator ++(int)//后置
{
Iterator tmp = *this;
_node = _node->_next;
return tmp;
}
Iterator operator --()//前置
{
_node = _node->_prev;
return *this;
}
Iterator operator --(int)//后置
{
Iterator tmp = *this;
_node = _node->_prev;
return tmp;
}
Ref operator *()//解引用
{
return _node->_data;
}
Ptr operator ->()//指针
{
return &(_node->_data);
}
const Ref operator *()const
{
return _node->_data;
}
const Ptr operator ->()const
{
return &(_node->_data);
}
Node* _node;
};
template <class T>
class List
{
typedef __ListNode<T> Node;
public:
typedef __ListIterator <T,T&,T*> Iterator;
typedef __ListIterator <T,const T&,const T*> ConstIterator;
/*Node* GetNode(const T& x)
{
return new Node(x);
}
List()
{
_head = GetNode(T());
_head->_next = _head;
_head->_prev = _head;
}*/
List()//无参构造函数
{
_head = new Node(T());
_head->_prev = _head;
_head->_next = _head;
}
List(const T& x)//有参构造函数
:_head(new Node(x))
{
_head->_next = _head;
_head->_prev = _head;
}
~List()
{
Clear();
delete _head;
_head = NULL;
}
Iterator Begin()
{
return Iterator(_head->_next);
}
Iterator End()
{
return Iterator(_head);
}
ConstIterator Begin()const
{
return Iterator(_head->_next);
}
ConstIterator End()const
{
return Iterator(_head);
}
void Clear()
{
Iterator it = Begin();
while(it != End())
{
Node* del = it._node;
++it;
delete del;
}
_head ->_next = _head;
_head ->_prev = _head;
}
void PushBack(const T& x)
{
/*Node* tmp = new Node(x);
Node* tail = _head->_prev;
tail->_next = tmp;
tmp->_prev = tail;
tmp->_next = _head;
_head->_prev = tmp;*/
Insert(End(),x);
}
void PushFront(const T& x)
{
Insert(Begin(),x);
}
//在pos的前面插入
void Insert(Iterator pos,const T& x)
{
Node* cur = pos._node;
Node* prev = cur->_prev;
Node* tmp = new Node(x);
prev->_next = tmp;
tmp->_next = cur;
cur->_prev = tmp;
tmp->_prev = prev;
}
void PopFront()
{
Erase(Begin());
}
void PopBack()
{
Erase(--End());
}
Iterator Erase(Iterator pos)
//有迭代器失效的问题,所以此处返回要删除的节点的下一个位置的迭代器
{
assert(pos != End() && pos._node);
Node* cur = pos._node;
Node* prev = cur->_prev;
Node* next = cur->_next;
prev->_next = next;
next->_prev = prev;
delete cur;
//pos._node = prev;
return next;
}
Iterator Find(const T& x)
{
Iterator it = Begin();
while(it != End())
{
if(*it == x)
{
return it;
}
++it;
}
}
bool Empty()
{
return _head = _head->_next;
}
protected:
Node* _head;
};
void Print(List<int>& l)
{
List<int>::Iterator it = l.Begin();
while(it != l.End())
{
cout<<*it<<" ";
++it;
}
cout<<endl;
}
void TestList()
{
List<int> l1;
l1.PushBack(1);
l1.PushBack(2);
l1.PushBack(3);
l1.PushBack(4);
l1.PushFront(0);
l1.PushBack(5);
List<int> ::Iterator it1 = l1.Find(0);
l1.Erase(it1);
l1.PopFront();
l1.PopBack();
List<int>::Iterator it = l1.Begin();
while(it != l1.End())
{
cout<<*it<<" ";
++it;
}
cout<<endl;
//List<int>::Iterator it = l1.Begin();
//while(it != l1.End())
//{
// if(*it % 2 == 0)
// {
// it = l1.Erase(it);
// }
// else
// {
// ++it;
// }
//}
//Print(l1);
}
int main()
{
TestList();
return 0;
}