C++算法学习1

最新推荐文章于 2022-02-27 11:06:55 发布

Belisarius1

最新推荐文章于 2022-02-27 11:06:55 发布

阅读量247

点赞数

文章标签： C++表

本文链接：https://blog.csdn.net/weixin_43839485/article/details/90172842

版权

表，栈和队列

一.表（在C++标准模版库）

1.vector（可增长的数组实现）常量时间内可索引，插入/删除代价昂贵
2.list（双向链表实现）插入/删除代价小，不容易索引

vector和list 的方法：

int size() const; 返回容器中元素个数
void clear()
bool empty()
void push_back(const Object &x); 在表的末尾添加X
void pop_back(); 删除表末尾的对象
const Object & back () const; 返回表末尾的对象（也提供返回引用的修改函数）
const Object & front () const; 返回表前端的对象（也提供返回引用的修改函数）

双向链表支持在表的前段进行改变（vector不支持）
void push_front(const Object &x); 在list前端添加X
void pop_front(); 在list前端删除对象

vector具有而list不具有的操作
Object & operator [] (int index); 返回vector中index索引位置的对象（不包括边界检测）
Object & at (int index); 返回vector中index索引位置的对象（包括边界检测）
int capacity() const; 返回vector内部容量
void reserve(int new capacity); 设定vector的新容量

内置类型：迭代器

1. 获得迭代器
iterator begin(); 返回指向容器的第一项的一个迭代器
iterator end(); 返回指向容器的终止标志（容器最后一项的后面的位置）的一个迭代器
2.迭代器常见的操作
itr++ & ++itr
*itr; 返回存储在迭代器itr指定位置的对象的引用
itr1 == itr2
itr1 != itr2

for(vector<int>::iterator itr = v.begin(); itr != v.end(); itr++)
cout<<*itr<<endl;

3.需要迭代器的容器操作

iterator insert (iterator pos , const Object &x) 添加X到迭代器pos所指向位置之前的位置，这对list是常量时间操作，对vector不是
iterator erase(iterator pos) 删除迭代器位置的对象，这对list是常量时间操作，对vector不是，返回之前pos指向元素的下一个元素的位置，pos失效
iterator erase(iterator start , iterator end) 删除所有从start开始，到end结束的所有元素（不包括end本身）
c.erase(c.begin() , c.end()); 删除整个表

4.示例：使用迭代器间隔地删除表中的项：

template<typename Container> 
void removeEveryOtherItem(Container & lst)
{
 typename Container ::iterator itr = lst.begin();
 while(itr != lst.end)
 {
   itr = erase(itr);
   if(itr != lst.end())
   itr++;
 }
}

5.const_iterator
const_iterator的星号返回常量引用，不能出现在赋值语句的左边，而iterator的星号返回该项本身

向量的实现

template<typename Object>
class Vector
{
  public: 
  explicit Vector(int initSize = 0)
  : theSize(initSize) , theCapacity(initSize + SPACE_CAPACITY)
  {objects = new Object[theCapacity];}
  
  Vector(const Vector & rhs): objects(NULL)
  {objects= (rhs); }
  
  ~Vector()
  {delete [] objects; }
}

const Vector &operator = (const Vector &rhs)
{
  if(this != this)
  {
    delete [] objects;
    theSize = rhs.theSize();
    theCapacity = rhs.theCapacity;
    objects = new Object[capacity()];
    for(int k = 0 ; k < size() ; k++)
    objects[k] = rhs[k];
  }
  return *this;
}

双向链表的实现（list）

template<typename Object>
class List
{
  private:
  struct Node
  {
    Object data;
    Node *prev;
    Node *next;
    Node(const Object &d = Object() , Node *p = NULL , Node *n = NULL): data(d) , prev(p) , next(n) {}
  }
  public:
  class const_iterator
  class iterator
 
  public:
  List()
  {
    init();
  }
  ~List()
  {
    clear();
    delete head;
    delete tail;
  }
  List(const List & rhs)
  {
    init();
    *this = rhs;
  }
 const  List & operator = (const List & rhs)
 {
  if(this == &rhs)
  return *this;
  clear();
  for(const_iterator itr = rhs.begin() ; itr != rhs.end() ; itr++)
  push_back(*itr);
  return *this
 }
}
void init()
{
  theSize = 0;
  head = new Node;
  tail = new Node;
  head->next = tail;
  tail->prev = head;
}
private:
int theSize;
Node *head;
Node *tail;