C++万字总结(中篇)
文章目录
-
- 菜狗程序员 C++ 万字总结，从入门到入土(中篇)
-
- STL
-
- vector
- string
- list
- stack
- queue
- 二叉搜索树
- AVL 树
菜狗程序员 C++ 万字总结，从入门到入土(中篇)
STL
vector
模拟实现
#include vector 迭代器失效问题：
引起迭代器失效的情况有两种，
- 一种是像 resize、reserve、insert、push_back 这些能改变数据空间的操作，扩容操作会使原先空间销毁，从而产生野指针，因此需要对迭代器重新赋值。
- 即使不扩容，只要发生数据挪动，迭代器原先指向的空间可能也会发生变化，从而迭代器失效，比如 erase 操作。
另一种
string
模拟实现
# include list
模拟实现
namespace Schuyler
{
// list 节点类型
template
struct ListNode
{
ListNode(const T& val = T())
{
_val = val;
_pre = nullptr;
_next = nullptr;
}
T _val;
ListNode* _pre;
ListNode* _next;
};
// list 的迭代器是对原生指针的封装
// 这里的模板使用 3 种类型，是为了可以同时用一份代码，实例化出 const 和 非 const 的迭代器
template
class ListIterator
{
typedef ListIterator self;
typedef ListNode* node;
public:
// 通过一个节点指针去初始化迭代器指针
ListIterator(node* pNode)
{
_node = pNode;
}
// 通过迭代器去初始化一个迭代器指针
ListIterator(const self& it)
{
_node = it._node;
}
// 为了使迭代器可以像指针一样去使用，需要重载 operator*() 和 operator->()
// 重载解引用运算符，这里就体现了模板的好处：Ref 可以是 const(只读) ，也可以是可读可写
Ref operator*()
{
return _node->_val;
}
// 重载->运算符
Ptr operator->()
{
return &_node->_val;
}
// == 和 != 运算符
bool operator==(const self& s) const
{
return s._node == _node;
}
bool operator!=(const self& s) const
{
return s._node != _node;
}
// 重载++，实现指针的移动
self& operator++()
{
_node = _node->_next;
return *this;
}
// 后置++
self operator++(int)
{
self tmp(*this);
_node = _node->_next;
return tmp;
}
// 重载--
self& operator--()
{
_node = _node->_pre;
return *this;
}
self operator--(int)
{
self tmp(*this);
_node = _node->_pre;
return tmp;
}
private:
// 迭代器是对指针的封装
node _node;
};
template
class list
{
typedef ListNode node;
// 体现模板的好处，不用再声明一份 const 的迭代器
typedef ListIterator iterator;
typedef ListIterator const_iterator;
private:
// 哨兵节点
node* _head;
public:
// 返回第一个有效元素的位置
iterator begin()
{
return iterator(_head->_next);
}
// 返回最后一个有效元素的下一个位置
iterator end()
{
return iterator(_head);
}
// const 对象调用
const_iterator begin() const
{
return const_iterator(_head->_next);
}
const_iterator end() const
{
return const_iterator(_head);
}
// 判断 list 是否为空
bool empty()
{
return begin() == end();
}
// 插入一个节点
void insert(iterator pos, const T& x)
{
if (pos._node == nullptr)
throw new _exception{ 0, "索引错误" };
node* newNode = new node(x);
node* cur = pos._node;
node* pre = cur->_pre;
pre->_next = newNode;;
newNode->_pre = pre;
newNode->_next = cur;
cur->_pre = newNode;
}
void push_back(const T& x)
{
insert(end(), x);
}
void push_front(const T& x)
{
insert(begin(), x);
}
void pop_back()
{
erase(--end());
}
void pop_front()
{
erase(begin());
}
// 删除节点
iterator erase(iterator pos)
{
if (pos == nullptr || pos == end())
throw new _exception{ 0, "索引错误" };
node* pre = pos._node->_pre;
node* next = pos._node->_next;
pre->_next = next;
next->_pre = pre;
delete pos._node
return iterator(next);
}
void clear()
{
iterator it = begin();
while (it != end())
{
erase(it++);
}
}
// 构造函数，构造双向带头链表
list()
{
_head = new node;
_head->_next = _head;
_head->_pre = _head;
}
// 拷贝构造函数
list(const list _list)
{
_head = new node;
_head->_next = _head;
_head->_pre = _head;
for (auto& e : _list)
{
push_back(e);
}
}
// 析构函数
~list()
{
clear();
delete _head;
_head = nullptr;
}
// 拷贝构造
list& operator=(list _list)
{
swap(_head, _list._head);
return *this;
}
int size()
{
int sz = 0;
iterator it = begin();
while (it != end())
{
sz++;
++it;
}
return sz;
}
};
}
list 同样存在迭代器失效问题，与 vector 不同的是，首先进行插入时，list 不会扩容，不会产生野指针，因此插入操作不会导致迭代器失效；
其次，进行删除时 vector 需要挪动元素，导致迭代器指向的元素发生改变，list 进行删除时，则会返回删除元素的下一个位置的迭代器，只会使删除位置的迭代器失效。
stack
stack 是一种容器适配器，底层容器可以是 vector、list等(只要支持 push_back 尾插、pop_back、top 获取栈顶元素和 empty 判空即可)，
默认底层容器使用 deque。
模拟实现
#include queue
队列也是一种容器适配器，底层容器应该支持：front 返回队头元素引用、back 返回队尾元素引用、push_back 队尾入队列、pop_back 队头出队列
默认情况下底层容器使用 deque。
模拟实现
#include 优先队列
// 声明仿函数
template<class T>
struct less
{
bool operator()(const T& x1, const T& x2)
{
return x1 < x2;
}
};
template<class T>
struct greater
{
bool operator()(const T& x1, const T& x2)
{
return x1 > x2;
}
};
// 优先队列：底层用堆实现,堆就是用数组存储的完全二叉树
template<class T, class Container = std::vector<T>, class Compare = less<T>>
class priority_queue
{
public:
bool empty() const
{
return _con.empty();
}
int size() const
{
return _con.size();
}
T& top()
{
return _con[0];
}
// 堆中任意子节点向上调整
void AjustUp(int child)
{
Compare com;
int parent = child / 2;
while (child > 0)
{
if (com(_con[parent], _con[child]))
{
// 仿函数比较条件为 true，调整父节点和子节点位置
swap(_con[parent], _con[child]);
child = parent;
parent = parent / 2;
}
else
{
// 找到 child 的正确位置，退出循环
break;
}
}
}
void push(const T& x)
{
// 将 x 插入堆的尾部
_con.push_back(x);
// 再向上调整到正确位置
AjustUp(_con.size() - 1);
}
// 用于删除操作的向下调整，将任意一个元素向下调整
void AjustDown(int parent)
{
Compare com;
int child = parent * 2 + 1;
while (child < _con.size())
{
//找到较大的孩子节点
if (child + 1 < _con.size() && com(_con[child], _con[child + 1]))
{
++child;
}
// 比较父子节点并调整位置
if (com(_con[parent], _con[child]))
{
swap(_con[parent], _con[child]);
parent = child;
child = child * 2 + 1;
}
else
{
break;
}
}
}
// 删除堆顶元素
void pop()
{
// 堆顶元素和堆的最后一个元素交换位置
swap(_con[0], _con[_con.size() - 1]);
// 删除交换后的堆顶元素
_con.pop_back();
// 调整此时堆顶元素
AjustDown(0);
}
private:
Container _con;
};
额外知识点：堆的建立首先按顺序建立二叉树，其次从最后一个有孩子的节点开始，一层一层往上调。时间复杂度为 O(N)。
为什么使用 deque 作为 stack 和 queue 的底层容器：
- stack 和 queue 不需要遍历，只需要在固定一端或两端进行操作
- stack 和 queue 在元素增长时，效率高
二叉搜索树
模拟实现
#include 类型
namespace KV
{
template<class K, class V>
struct BSTreeNode
{
BSTreeNode<K, V>* _left;
BSTreeNode<K, V>* _right;
K _key;
V _value;
BSTreeNode(const K& key, const V& value)
:_left(nullptr)
, _right(nullptr)
,_key(key)
,_value(value)
{}
};
template<class K, class V>
class BSTree
{
typedef BSTreeNode<K, V> Node;
public:
// 插入节点，成功插入返回 true，否则返回 false
bool _Insert(Node*& root, const K& key, const V& value)
{
if (root == nullptr)
{
root = new Node(key, value);
return true;
}
// 插入的节点大于 root，往 root 的右子树插
if (root->_key < key)
{
return _Insert(root->_right, key, value);
}
// 插入的节点小于 root，往 root 的左子树插
else if (root->_key > key)
{
return _Insert(root->_left, key, value);
}
else
{
return false;
}
}
// 查找 key
Node* _Search(Node* root, const K& key)
{
// 根节点为空或者根节点恰好是要找的，返回 root
if (root == nullptr || root->_key == key)
{
return root;
}
// 根节点大于 key，到左子树中查找
if (root->_key > key)
{
return _Search(root->_left, key);
}
// 根节点小于 key，到右子树中查找
else if (root->_key < key)
{
return _Search(root->_right, key);
}
}
// 删除节点，成功删除返回 true，否则返回 false
bool _Erase(Node*& root, const K& key)
{
if (root == nullptr)
{
return false;
}
// root 大于要删的元素 ，从 root 的左子树中删除
if (root->_key > key)
{
return _Erase(root->_left, key);
}
// root 小于要删的元素 ，从 root 的右子树中删除
else if (root->_key < key)
{
return _Erase(root->_right, key);
}
// 找到要删除的元素
else
{
if (root->_left == nullptr)
{
Node* del = root;
// 父节点指向删除节点的右孩子节点
root = root->_right;
// 删除节点
delete del;
}
else if (root->_right == nullptr)
{
Node* del = root;
// 父节点指向删除节点的左孩子节点
root = root->_left;
// 删除节点
delete del;
}
else
{
// 对删除元素的右子树遍历得到最小值
Node* minRight = root->_right;
while (minRight->_left)
{
minRight = minRight->_left;
}
K min_key = minRight->_key;
V min_value = minRight->_value;
// 删除 root 右子树最小元素
_Erase(root->_left, min_key);
// 并用最小元素替换删除的元素
root->_key = min_key;
root->_value = min_value;
}
return true;
}
}
// 拷贝一棵树
Node* _Copy(Node* root)
{
if (root == nullptr)
{
return nullptr;
}
Node* newNode = new Node(root->_key, root->_value);
// 直到叶子节点开始返回，将节点之间相“连接”
newNode->_left = _Copy(root->_left);
newNode->_right = _Copy(root->_right);
return newNode;
}
// 释放树中的节点，销毁树
void _Destroy(Node* root)
{
if (root == nullptr)
{
return;
}
_Destroy(root->_left);
_Destroy(root->_right);
delete root;
}
public:
BSTree():_root(nullptr)
{}
BSTree(const BSTree<K, V>& t)
{
_root = _Copy(t._root);
}
BSTree<K, V>& operator=(BSTree<K,V> t)
{
swap(_root, t._root);
return *this;
}
~BSTree()
{
_Destroy(_root);
_root = nullptr;
}
private:
Node* _root;
};
}
AVL 树
模拟实现
#include