详解 二叉搜索树-----AVL树

二叉搜索树

  1. 根结点比左子树中所有结点都大
  2. 根结点比右子树所有结点都小
  3. 最小的元素在最左侧
  4. 最大的元素在最右侧
  5. 中序遍历有序

具有以上的特征的二叉树就是二叉搜索树也叫二叉排序数

二叉搜索树的操作

查找

在这里插入图片描述
在这里插入图片描述
要保存查找值的双亲，以便于后续执行插入操作

Node* Find(const T& data){Node *pCur = _pRoot;Node *pParent = nullptr;while (pCur){pParent = pCur;  //保存双亲if (data == pCur->_data)return pCur;else if (data < pCur->_data)pCur = pCur->_pLeft;elsepCur = pCur->_pRight;}//走到这个位置，当前元素一定不存在return nullptr;}

插入

  1. 树为空，则直接插入
  2. 树不空，按二叉搜索树性质查找插入位置，插入新节点

在这里插入图片描述

bool Insert(const T& data){//空树--->直接插入if (_pRoot == nullptr){_pRoot = new Node(data);return true;}//非空//找到待插入元素在二叉搜索树中的位置Node *pCur = _pRoot;Node *pParent = nullptr;while (pCur){pParent = pCur;  //记录cur变化前的位置，就是记录cur的双亲if (data < pCur->_data){pCur = pCur->_pLeft;}else if (data > pCur->_data)pCur = pCur->_pRight;elsereturn false;}//插入结点pCur = new Node(data);if (data < pParent->_data)pParent->_pLeft = pCur;elsepParent->_pRight = pCur;return true;}

删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情况：

  • 要删除的结点无孩子结点
  • 要删除的结点只有左孩子结点
  • 要删除的结点只有右孩子结点
  • 要删除的结点有左、右孩子结点

总结一下，实际情况要删除的话，分为三步

  1. 删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点
  2. 删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点
  3. ：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中， 再来处理该结点的删除问题

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

//删除
bool Delete(const T& data)
{if (nullptr == _pRoot)return false;//找到待删除元素再二叉搜索树中的位置
Node *pCur = _pRoot;
Node *pParent = nullptr;
while (pCur)
{if (data < pCur->_data){pParent = pCur;pCur = pCur->_pLeft;}else if (data>pCur->_data){pParent = pCur;pCur = pCur->_pRight;}elsebreak;
}//结点不存在
if (nullptr == pCur)return false;//结点已经找到----分情况删除
//1.左右孩子都不存在
//2.只有左孩子
//3.只有右孩子
//4.左右孩子均存在
Node *pDelNode = pCur;
if (nullptr == pCur->_pRight)
{// 叶子结点 || 只有左孩子if (nullptr == pParent){_pRoot = pCur->_pLeft;}else{if (pCur == pParent->_pLeft)pParent->_pLeft = pCur->_pLeft;elsepParent->_pRight = pCur->_pLeft;}
}
else if (nullptr == pCur->_pLeft)
{// 只有右孩子if (nullptr == pParent)_pRoot = pCur->_pRight;else{if (pCur == pParent->_pLeft)pParent->_pLeft = pCur->_pRight;elsepParent->_pRight = pCur->_pRight;}
}
else
{//左右孩子均存在，不能直接删除，必须在其子树中找一个替代结点进行删除//方式一:在其左子树中找最大的结点---->最右侧的结点//方式二:在其右子树中找最小的结点---->最左侧的结点//在右子树中查找替代结点Node *pMostLeft = pCur->_pRight;pParent = pCur;while (pMostLeft->_pLeft){pParent = pMostLeft;  //每次变动前保存双亲pMostLeft = pMostLeft->_pLeft;}pCur->_data = pMostLeft->_data;//删除替代结点if (pMostLeft == pParent->_pLeft)pParent->_pLeft = pMostLeft->_pRight;elsepParent->_pRight = pMostLeft->_pLeft;pDelNode = pMostLeft;
}delete pDelNode;
return true;
}

时间复杂度

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。
但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树

最优情况

在这里插入图片描述
在这里插入图片描述

最差情况

在这里插入图片描述
在这里插入图片描述

总体代码

#include<iostream>
using namespace std;template<class T>
struct BSTreeNode
{BSTreeNode(const T& data = T())  //初始化   T()默认值:_pLeft(nullptr), _pRight(nullptr), _data(data){}BSTreeNode<T>* _pLeft;  //指向左子树BSTreeNode<T>* _pRight; //指向右子树T _data;
};template<class T>
class BsTree
{typedef BSTreeNode<T>  Node;public:BsTree():_pRoot(nullptr)  //空树就是一颗二叉搜索树{}~BsTree(){_Destroy(_pRoot);}bool Insert(const T& data){//空树--->直接插入if (_pRoot == nullptr){_pRoot = new Node(data);return true;}//非空//找到待插入元素在二叉搜索树中的位置Node *pCur = _pRoot;Node *pParent = nullptr;while (pCur){pParent = pCur;  //记录cur变化前的位置，就是记录cur的双亲if (data < pCur->_data){pCur = pCur->_pLeft;}else if (data > pCur->_data)pCur = pCur->_pRight;elsereturn false;}//插入结点pCur = new Node(data);if (data < pParent->_data)pParent->_pLeft = pCur;elsepParent->_pRight = pCur;return true;}//获取最左侧结点Node *LeftMost(){if (nullptr == _pRoot)return nullptr;Node *pCur = _pRoot;while (pCur->_pLeft)pCur = pCur->_pLeft;return pCur;}//获取最右侧结点Node *RightMost(){if(nullptr == _pRoot)return nullptr;Node *pCur = _pRoot;while (pCur->_pRight)pCur = pCur->_pRight;return pCur;}void InOrder()			//再封装一层是为了让用户方便，尽量不要让用户传参数{_InOrder(_pRoot);}//删除bool Delete(const T& data){if (nullptr == _pRoot)return false;//找到待删除元素再二叉搜索树中的位置Node *pCur = _pRoot;Node *pParent = nullptr;while (pCur){if (data < pCur->_data){pParent = pCur;pCur = pCur->_pLeft;}else if (data>pCur->_data){pParent = pCur;pCur = pCur->_pRight;}elsebreak;}//结点不存在if (nullptr == pCur)return false;//结点已经找到----分情况删除//1.左右孩子都不存在//2.只有左孩子//3.只有右孩子//4.左右孩子均存在Node *pDelNode = pCur;if (nullptr == pCur->_pRight){// 叶子结点 || 只有左孩子if (nullptr == pParent){_pRoot = pCur->_pLeft;}else{if (pCur == pParent->_pLeft)pParent->_pLeft = pCur->_pLeft;elsepParent->_pRight = pCur->_pLeft;}}else if (nullptr == pCur->_pLeft){// 只有右孩子if (nullptr == pParent)_pRoot = pCur->_pRight;else{if (pCur == pParent->_pLeft)pParent->_pLeft = pCur->_pRight;elsepParent->_pRight = pCur->_pRight;}}else{//左右孩子均存在，不能直接删除，必须在其子树中找一个替代结点进行删除//方式一:在其左子树中找最大的结点---->最右侧的结点//方式二:在其右子树中找最小的结点---->最左侧的结点//在右子树中查找替代结点Node *pMostLeft = pCur->_pRight;pParent = pCur;while (pMostLeft->_pLeft){pParent = pMostLeft;  //每次变动前保存双亲pMostLeft = pMostLeft->_pLeft;}pCur->_data = pMostLeft->_data;//删除替代结点if (pMostLeft == pParent->_pLeft)pParent->_pLeft = pMostLeft->_pRight;elsepParent->_pRight = pMostLeft->_pLeft;pDelNode = pMostLeft;}delete pDelNode;return true;}Node* Find(const T& data){Node *pCur = _pRoot;Node *pParent = nullptr;while (pCur){pParent = pCur;  //保存双亲if (data == pCur->_data)return pCur;else if (data < pCur->_data)pCur = pCur->_pLeft;elsepCur = pCur->_pRight;}//走到这个位置，当前元素一定不存在return nullptr;}private:void _InOrder(Node * pRoot){if (pRoot){_InOrder(pRoot->_pLeft);cout << pRoot->_data << " ";_InOrder(pRoot->_pRight);}}void _Destroy(Node*& pRoot){if (pRoot){_Destroy(pRoot->_pLeft);_Destroy(pRoot->_pRight);delete pRoot;pRoot = nullptr;}}
private:Node *_pRoot;  //记录根结点 就是保存了整颗树
};void TestBSTree()
{int a[] = { 5, 3, 4, 1, 7, 8, 2, 6, 0, 9 };BsTree<int>t;for (auto e : a)t.Insert(e);cout << t.LeftMost() << endl;cout << t.RightMost() << endl;t.InOrder();printf("\n");t.Delete(8);t.InOrder();printf("\n");t.Delete(0);t.InOrder();printf("\n");t.Delete(1);t.InOrder();printf("\n");t.Delete(5);t.InOrder();printf("\n");
}

在这里插入图片描述

如何让二叉搜索树不出现最差情况

把单支树变的平衡那就是AVL树

二叉搜索树转化为双向链表

AVL树

二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当 于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年 发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之 差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度

AVL树的性质

  • 它的左右子树都是AVL树
  • 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)
  • 也可以为空树

在这里插入图片描述

如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在log2N ，搜索时间复杂度O( log2N)。

AVL树结点定义

template<class T>
struct AVLTreeNode{AVLTreeNode(const T& data = T()):_pLeft(nullptr), _pRight(nullptr), _pParent(nullptr), _data(data), _bf(0){}AVLTreeNode<T>* _pLeft;AVLTreeNode<T>* _pRight;AVLTreeNode<T>* _pParent;T _data;int _bf;  //当前结点的平衡因子
};

AVL树的插入

AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树也可以看成是二叉搜索树。那么AVL树的插入 过程可以分为两步：

  1. 按照二叉搜索树的方式插入新节点
  2. 调整节点的平衡因子

平衡因子的判定

  1. 先按照二叉搜索树的规则将节点插入到AVL树中
  2. 新节点插入后，AVL树的平衡性可能会遭到破坏，此时就需要更新平衡因子，并检测是否破坏了AVL树的平衡性
  3. pCur插入后，pParent的平衡因子一定需要调整，在插入之前，pParent的平衡因子分为三种情况：-1，0, 1, 分以下两种情况：
	1. 如果pCur插入到pParent的左侧，只需给pParent的平衡因子-1即可      2. 如果pCur插入到pParent的右侧，只需给pParent的平衡因子+1即可
  1. 此时：pParent的平衡因子可能有三种情况：0，正负1， 正负2
1. 如果pParent的平衡因子为0，说明插入之前pParent的平衡因子为正负1，插入后被调整成0，此时满 足         AVL树的性质，插入成功      
2. 如果pParent的平衡因子为正负1，说明插入前pParent的平衡因子一定为0，插入后被更新成正负1， 此         时以pParent为根的树的高度增加，需要继续向上更新      
3. 如果pParent的平衡因子为正负2，则pParent的平衡因子违反平衡树的性质，需要对其进行旋转处理

旋转处理

如果parent的平衡因子是2或者-2，需要对以parent为根的二叉树进行旋转处理：

  • 左单旋
  • 右单旋
  • 左右双旋
  • 右左双旋

左单旋

新结点插入到较高右子树的右侧----右右---->左单旋

在这里插入图片描述

上图在插入前，AVL树是平衡的，新节点插入到30的左子树(注意：此处不是左孩子)中，30左子树增加 了一层，导致以60为根的二叉树不平衡，要让60平衡，只能将60左子树的高度减少一层，右子树增加一 层
即将左子树往上提，这样60转下来，因为60比30大，只能将其放在30的右子树，而如果30有右子树，右 子树根的值一定大于30，小于60，只能将其放在60的左子树，旋转完成后，更新节点的平衡因子即可。在旋转过程中，有以下几种情况需要考虑：

  1. 30节点的右孩子可能存在，也可能不存在
  2. 60可能是根节点，也可能是子树 如果是根节点，旋转完成后，要更新根节点 如果是子树，可能是某个节点的左子树，也可能是右子树

左单旋实现

在这里插入图片描述

//左单旋void _RotateLeft(Node * pParent){Node * pSubR = pParent->_pRight;Node * pSubRL = pSubR->_pLeft;//第一步pParent->_pRight = pSubRL;if (pSubRL)pSubRL->_pParent = pParent;//第一步完//第二步pSubR->_pLeft = pParent;Node * pPParent = pParent->_pParent;pSubR->_pParent = pPParent;pParent->_pParent = pSubR;//第二步完//第三步if (nullptr == pPParent)_pRoot = pSubR;else{if (pParent == pPParent->_pLeft)pPParent->_pLeft = pSubR;elsepPParent->_pRight = pSubR;}//第三步完pParent->_bf = pSubR->_bf = 0;}

右单旋

新节点插入较高左子树的左侧—左左：右单旋
在这里插入图片描述

右单旋实现

在这里插入图片描述

//右单旋void _RotateLeft(Node * pParent){//第一步Node *pSubL = parent->_pLeft; // pParent的左孩子 Node*pSubLR = pSubL->_pRight; //左子树的右孩子//旋转完成之后//更新孩子指针域pParent->_pLeft = pSubLR;if (pSubLR)pSubLR->_pParent = pParent;//第一步完//第二步pSubL->_pRight = pParent;//更新双亲指针域Node* pPParent = pParent->_pParent;pParent->_pParent = pSubL;pSubL->_pParent = pPParent;//第二步完//第三步//对pParent分情况:根结点||非根结点(pParent可能为其双亲的左||右孩子)if (nullptr == pPParent)_pRoot = pSubL;else{if (pParent == pPParent->_pLeft)pPParent->_pLeft = pSubL;elsepPParent->_pRight = pSubL;}//第三步完//更新平衡因子pParent->_bf = pSubL->_bf = 0;}

左右双旋

新节点插入较高左子树的右侧—左右：先左单旋再右单旋
在这里插入图片描述
在这里插入图片描述

左右双旋实现

void _RotateLR(Node *pParent){Node* pSubL = pParent->_pLeft;Node* pSubLR = pSubL->_pRight;int bf = pSubLR->_bf;_RotateL(pParent->_pLeft);_RotateR(pParent);if (-1 == bf)pParent->_bf = 1;else if (1 == bf)pSubL->_bf = -1;}

右左双旋

新节点插入较高右子树的左侧—右左：先右单旋再左单旋
在这里插入图片描述

右左双旋实现

//右左双旋void _RotateRL(Node * pParent){Node *pSubR = pParent->_pRight;Node*pSubL = pSubR->_pLeft;int bf = pSubL->_bf;_RotateR(pParent->_pRight);_RotateL(pParent);if (-1 == bf)pSubR->_bf = 1;else if (1 == bf)pParent->_bf = -1;}

总结

假如以pParent为根的子树不平衡，即pParent的平衡因子为2或者-2，分以下情况考虑

  1. pParent的平衡因子为2，说明pParent的右子树高，设pParent的右子树的根为pSubR
	1.当pSubR的平衡因子为1时，执行左单旋 2.当pSubR的平衡因子为-1时，执行右左双旋
  1. pParent的平衡因子为-2，说明pParent的左子树高，设pParent的左子树的根为pSubL
	1.当pSubL的平衡因子为-1是，执行右单旋 2.当pSubL的平衡因子为1时，执行左右双旋

AVL树的验证

AVL树是在二叉搜索树的基础上加入了平衡性的限制，因此要验证AVL树，可以分两步：

  1. 验证其为二叉搜索树
如果中序遍历可得到一个有序的序列，就说明为二叉搜索树
  1. 验证其为平衡树
	1.每个结点子树高度差的绝对值不超过1(注意节点中如果没有平衡因子) 2.结点的平衡因子是否计算正确
bool _IsVaildAVLTree(Node *pRoot){if (nullptr = pRoot)return true;size_t leftHeight = _Height(pRoot->_pLeft);size_t rightHeight = _Height(pRoot->_pRight);if (!(pRoot->_bf >= -1 && pRoot->_bf <= 1 && pRoot->_bf == rightHeight - leftHeight))return false;return _IsVaildAVLTree(pRoot->_pLeft) && (pRoot->_pRight);}size_t _Height(Node *pRoot){if (nullptr == pRoot)return 0;size_t leftHeight = _Height(pRoot->_pLeft);size_t rightHeight = _Height(pRoot->_pRight);return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;}

AVL树的删除

因为AVL树也是二叉搜索树，可按照二叉搜索树的方式将节点删除，然后再更新平衡因子，只不过与删除不同的是，删除节点后的平衡因子更新，差情况下一直要调整到根结点的位置。
参考 《算法导论》或《数据结构-用面向对象方法与C++描述》殷人昆版。

AVL树的性能

AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这样可以保证 查询时高效的时间复杂度，即 。但是如果要对AVL树做一些结构修改的操作，性能非常低下，比如： 插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，有可能一直要让旋转持续到根的位置。 因此：如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树， 但一个结构经常修改，就不太适合。

总体代码

#pragma once
#include<iostream>
using namespace std;template<class T>
struct AVLTreeNode{AVLTreeNode(const T& data = T()):_pLeft(nullptr), _pRight(nullptr), _pParent(nullptr), _data(data), _bf(0){}AVLTreeNode<T>* _pLeft;AVLTreeNode<T>* _pRight;AVLTreeNode<T>* _pParent;T _data;int _bf;  //当前结点的平衡因子
};template<class T>
class AVLTree
{typedef AVLTreeNode<T> Node;
public:AVLTree():_pRoot(nullptr){}bool Insert(const T& data){if (nullptr == _pRoot){_pRoot = new Node(data);return true;}//非空//按照二叉搜索树的性质:找待插入结点在AVL树中的位置Node *pCur = _pRoot;Node *pParent = nullptr;while (pCur){pParent = pCur;if (data < pCur->_data)pCur = pCur->_pLeft;else if (data>pCur->_data)pCur = pCur->_pRight;elsereturn false;}//插入新结点pCur = new Node(data);if (data < pParent->_data)pParent->_pLeft = pCur;elsepParent->_pRight = pCur;pCur->_pParent = pParent;//可能会导致pParent结点的平衡因子不满足AVL树的性质while (pParent){//必须更新平衡因子//按左子树-右子树if (pCur == pParent->_pLeft)pParent->_bf--;elsepParent->_bf++;if (0 == pParent->_bf)return true;else if (-1 == pParent->_bf || 1 == pParent->_bf){pCur = pParent;pParent = pCur->_pParent;}else{//双亲的平衡因子不满足AVL树的的性质//双亲的结点的平衡因子为:2 或者-2//需要对以双亲为根的二叉树进行旋转处理if (2 == pParent->_bf)		//双亲平衡因子和pcur的平衡因子是同号，用单旋{//右子树高if (1 == pCur->_bf)_RotateL(pParent);else_RotateRL(pParent);}else{//左子树高if (-1 == pCur->_bf)_RotateR(pParent);else_RotateLR(pParent);}break;}}return true;}void Inorder(){_Inorder(_pRoot);}bool IsVaildAVLTree(){return _IsVaildAVLTree(_pRoot);}protected:bool _IsVaildAVLTree(Node *pRoot){if (nullptr == pRoot)return true;int leftHeight = _Height(pRoot->_pLeft);int rightHeight = _Height(pRoot->_pRight);if (!(pRoot->_bf >= -1 && pRoot->_bf <= 1 && pRoot->_bf == rightHeight - leftHeight))return false;return _IsVaildAVLTree(pRoot->_pLeft) && _IsVaildAVLTree(pRoot->_pRight);}int _Height(Node *pRoot){if (nullptr == pRoot)return 0;int leftHeight = _Height(pRoot->_pLeft);int rightHeight = _Height(pRoot->_pRight);return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;}void _Inorder(Node *pRoot){if (pRoot){_Inorder(pRoot->_pLeft);cout << pRoot->_data << " ";_Inorder(pRoot->_pRight);}}//右单旋void _RotateR(Node * pParent){//第一步Node *pSubL = pParent->_pLeft; // pParent的左孩子 Node *pSubLR = pSubL->_pRight; //左子树的右孩子//旋转完成之后//更新孩子指针域pParent->_pLeft = pSubLR;if (pSubLR)pSubLR->_pParent = pParent;//第一步完//第二步pSubL->_pRight = pParent;//更新双亲指针域Node* pPParent = pParent->_pParent;pParent->_pParent = pSubL;pSubL->_pParent = pPParent;//第二步完//第三步//对pParent分情况:根结点||非根结点(pParent可能为其双亲的左||右孩子)if (nullptr == pPParent)_pRoot = pSubL;else{if (pParent == pPParent->_pLeft)pPParent->_pLeft = pSubL;elsepPParent->_pRight = pSubL;}//第三步完//更新平衡因子pParent->_bf = pSubL->_bf = 0;}//左单旋void _RotateL(Node * pParent){Node * pSubR = pParent->_pRight;Node * pSubRL = pSubR->_pLeft;//第一步pParent->_pRight = pSubRL;if (pSubRL)pSubRL->_pParent = pParent;//第一步完//第二步pSubR->_pLeft = pParent;Node * pPParent = pParent->_pParent;pSubR->_pParent = pPParent;pParent->_pParent = pSubR;//第二步完//第三步if (nullptr == pPParent)_pRoot = pSubR;else{if (pParent == pPParent->_pLeft)pPParent->_pLeft = pSubR;elsepPParent->_pRight = pSubR;}//第三步完pParent->_bf = pSubR->_bf = 0;}//右左双旋void _RotateRL(Node * pParent){Node *pSubR = pParent->_pRight;Node*pSubL = pSubR->_pLeft;int bf = pSubL->_bf;_RotateR(pParent->_pRight);_RotateL(pParent);if (-1 == bf)pSubR->_bf = 1;else if (1 == bf)pParent->_bf = -1;}//左右双旋void _RotateLR(Node *pParent){Node* pSubL = pParent->_pLeft;Node* pSubLR = pSubL->_pRight;int bf = pSubLR->_bf;_RotateL(pParent->_pLeft);_RotateR(pParent);if (-1 == bf)pParent->_bf = 1;else if (1 == bf)pSubL->_bf = -1;}
private:Node *_pRoot;
};void TestAVLTree()
{//int array[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };int array[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };AVLTree<int>t;for (auto e : array)t.Insert(e);t.Inorder();printf("\n");if (t.IsVaildAVLTree()){cout << "t is vailed AVL Tree" << endl;}else{cout << "t is not vaild AVL Tree" << endl;}
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/383154.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

json格式与cJSON函数库

json格式与cJSON函数库

json的格式 键/值对 key:value&#xff0c;用半角冒号分割文档对象 JSON对象写在花括号中&#xff0c;可以包含多个键/值对。数组 JSON 数组在方括号中书写&#xff1a; 数组成员可以是对象&#xff0c;值&#xff0c;也可以是数组(只要有意义)。 { "stars":[ { &qu…
阅读更多...
HTTP清晰的学习笔记

HTTP清晰的学习笔记

HTTP协议—应用层 请求消息(Request)—浏览器给服务器发 包含四部分 请求行&#xff1a;说明请求类型&#xff0c;要访问的资源&#xff0c;以及使用的http版本请求头&#xff1a;说明服务器要使用的附加信息,由键值对构成的空行&#xff1a;空行是必须要有的&#xff0c;即…
阅读更多...
如何在 Centos7 x86_64下将vim一键配置为一款强大的C++，IDE

如何在 Centos7 x86_64下将vim一键配置为一款强大的C++，IDE

vim功能很强大&#xff0c;但是对于我这样的小白很不友好 然后就有一位大佬&#xff0c;为了辅助我这样的菜鸡&#xff0c;然后供我们一键搞定&#xff0c;在vim畅快编写代码的功能。 首先强烈不推荐在root用户下使用&#xff0c;确保电脑连着网。在普通用户下执行此命令 cur…
阅读更多...
详解string容器(应用+模拟实现，string练习题)

详解string容器(应用+模拟实现，string练习题)

为什么要有string容器 string&#xff1a;其实就是一个字符串,c对字符串进行了封装的&#xff0c;封装到一个类里面&#xff0c;这样用户就不用担心开辟空间的问题&#xff0c;只需要往string类里放字符串就可以了&#xff0c;string其实还可以自增长 很多人就会有一个疑问&am…
阅读更多...
浅拷贝+引用计数--写时拷贝---模拟实现string容器

浅拷贝+引用计数--写时拷贝---模拟实现string容器

引用计数 深拷贝 多个对象共享同一份资源时&#xff0c;最后能够保证该资源只被释放一次 应该由哪个对象释放资源&#xff1f; 由最后一个使用该资源的对象去释放 怎么知道一个对象是最后一个使用该资源的对象&#xff1f; 给一个计数&#xff0c;记录使用该资源对象的个数 实…
阅读更多...
详解vector容器(应用+模拟实现，vector相关练习题)

详解vector容器(应用+模拟实现，vector相关练习题)

vector容器 动态的顺序表&#xff0c;数组。 vector操作 vector操作及其概念 构造 vector<int>v1;vector<int>v2(10, 5);vector<int>v3(v2);int array[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };vector<int>v4(array, array sizeof(array) / sizeof(a…
阅读更多...
详解list容器(应用+模拟实现)

详解list容器(应用+模拟实现)

list容器 带头结点的双向循环链表 list操作 list容器的概念及其操作 构造和销毁 list<int>L1;list<int>L2(10, 5);vector<int>v{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };list<int>L3(v.begin(), v.end());list<int>L4(L3);元素访问 cout << L3.…
阅读更多...
vector和list容器有哪些区别

vector和list容器有哪些区别

这个问题的本质还是在问顺序表和链表的区别 底层结构不同 vector容器list容器一段连续的空间带头结点的双向循环链表 元素访问方式 vector容器list容器支持随机访问—O(1)不支持随机访问—O(N)需要扩容不需要扩容任意位置插入元素----O(N)–搬移元素O(1) 迭代器不同 vector…
阅读更多...
复习栈和队列，详解最小栈，栈的弹出压入序列，逆波兰表达式求值

复习栈和队列，详解最小栈，栈的弹出压入序列，逆波兰表达式求值

栈和队列的概念 栈:吃进去吐出来 对列&#xff1a;吃进去拉出来 数据结构中的栈和内存中的区别 数据结构中的栈具有后进先出的特性&#xff0c;而内存中的栈是一个内存空间&#xff0c;只不过这个内存空间具与数据结构的栈具有相同的特性。 栈和队列操作 栈和队列基本操作…
阅读更多...
详解优先级队列priority_queue(应用+模拟实现)

详解优先级队列priority_queue(应用+模拟实现)

优先级队列的概念 优先队列是一种容器适配器&#xff0c;根据严格的弱排序标准&#xff0c;它的第一个元素总是它所包含的元素中最大的此上下文类似于堆&#xff0c;在堆中可以随时插入元素&#xff0c;并且只能检索最大堆元素(优先队列中位于顶部的元 素)。优先队列被实现为容…
阅读更多...
私人博客定制

私人博客定制

项目背景 可行性方面 需求分析&#xff1a; 详细设计&#xff1a; 数据库设计 博客管理API的设计 标签相关API 服务器端的实现 对数据库操作进行封装 对服务器操作进行封装 客户端实现 具体操作 使用markdown 具体实现 测试 项目效果展示 维护 完整代码 项目…
阅读更多...
初识c++中的函数模板

初识c++中的函数模板

函数模板 函数模板概念 函数模板:编译器生成代码的一个规则。函数模板代表了一个函数家族&#xff0c;该函数模板与类型无关&#xff0c;在使用时被参数化&#xff0c;根据实参类型产生函数的特定类型版本。 函数模板格式 //要让这个函数与类型无关 //Add函数模板 template…
阅读更多...
深入理解c++中的函数模板

深入理解c++中的函数模板

非类型模板参数 模板参数分类类型形参与非类型形参。 类型形参&#xff1a;出现在模板参数列表中&#xff0c;跟在class或者typename之类的参数类型名称。 非类型形参&#xff0c;就是用一个常量作为类(函数)模板的一个参数&#xff0c;在类(函数)模板中可将该参数当成常量来使…
阅读更多...
c++中的IO流

c++中的IO流

c语言中的IO操作 标准类型的输入输出: 输入------>数据来源是通过键盘进行输入输出------>程序中的数据输出到控制台 c语言中: scanf:输入 printf:输出 两个函数的相同点 1 —格式串 2 —不定参数 两个函数的缺陷 1 —用户要提供数据的格式—用户要记忆大量的格式串—…
阅读更多...
201301 JAVA2~3级---走格子

201301 JAVA2~3级---走格子

请编写一个函数&#xff08;允许增加子函数&#xff09;&#xff0c;计算n x m的棋盘格子&#xff08;n为横向的格子数&#xff0c;m为竖向的格子数&#xff09;沿着各自边缘线从左上角走到右下角&#xff0c;总共有多少种走法&#xff0c;要求不能走回头路&#xff0c;即&…
阅读更多...
复习Linux基本操作----常见指令

复习Linux基本操作----常见指令

Linux基本操作 ls命令 ls(list):相当于windows上的文件资源管理器 语法&#xff1a; ls [选项][目录或文件] 功能&#xff1a;对于目录&#xff0c;该命令列出该目录下的所有子目录与文件。对于文件&#xff0c;将列出文件名以及其他信息。 常用选项&#xff1a; -a 列出目…
阅读更多...
复习Linux基础操作---权限操作

复习Linux基础操作---权限操作

shell命令以及运行原理 Linux严格意义上说的是一个操作系统&#xff0c;我们称之为“核心&#xff08;kernel&#xff09;“ &#xff0c;但我们一般用户&#xff0c;不能直接使用kernel。而是通过kernel的“外壳”程序&#xff0c;也就是所谓的shell&#xff0c;来与kernel沟…
阅读更多...
【剑指offer】_01 (二维数组中的查找)

【剑指offer】_01 (二维数组中的查找)

题目描述 在一个二维数组中&#xff08;每个一维数组的长度相同&#xff09;&#xff0c;每一行都按照从左到右递增的顺序排序&#xff0c;每一列都按照从上到下递增的顺序排序。请完成一个函数&#xff0c;输入这样的一个二维数组和一个整数&#xff0c;判断数组中是否含有该…
阅读更多...
再谈c++中的多态

再谈c++中的多态

何为多态 多态的概念&#xff1a;通俗来说&#xff0c;就是多种形态&#xff0c;具体点就是去完成某个行为&#xff0c;当不同的对象去完成时会产生出不同的状态。 多态的实现 在继承的体系下 基类中必须有虚函数(被virtual关键字修饰的成员函数)&#xff0c;在派生类中必须…
阅读更多...
再谈c++中的继承

再谈c++中的继承

继承的概念 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段&#xff0c;它允许程序员在保持原有类特性的基础上进行扩展&#xff0c;增加功能&#xff0c;这样产生新的类&#xff0c;称派生类。继承呈现了面向对象程序设计的层次结构&#xff0c;体现了…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023