程序员经验分享-hwhale

轻松搞定面试中的二叉树题目

2023-05-16

版权所有，转载请注明出处，谢谢！
http://blog.csdn.net/walkinginthewind/article/details/7518888

树是一种比较重要的数据结构，尤其是二叉树。二叉树是一种特殊的树，在二叉树中每个节点最多有两个子节点，一般称为左子节点和右子节点（或左孩子和右孩子），并且二叉树的子树有左右之分，其次序不能任意颠倒。二叉树是递归定义的，因此，与二叉树有关的题目基本都可以用递归思想解决，当然有些题目非递归解法也应该掌握，如非递归遍历节点等等。本文努力对二叉树相关题目做一个较全的整理总结，希望对找工作的同学有所帮助。

二叉树节点定义如下：
struct BinaryTreeNode
{
    int m_nValue;
    BinaryTreeNode* m_pLeft;
    BinaryTreeNode* m_pRight;
};

相关链接：
轻松搞定面试中的链表题目

题目列表：

1. 求二叉树中的节点个数
2. 求二叉树的深度
3. 前序遍历，中序遍历，后序遍历
4.分层遍历二叉树（按层次从上往下，从左往右）
5. 将二叉查找树变为有序的双向链表
6. 求二叉树第K层的节点个数
7. 求二叉树中叶子节点的个数
8. 判断两棵二叉树是否结构相同
9. 判断二叉树是不是平衡二叉树
10. 求二叉树的镜像
11. 求二叉树中两个节点的最低公共祖先节点
12. 求二叉树中节点的最大距离
13. 由前序遍历序列和中序遍历序列重建二叉树
14.判断二叉树是不是完全二叉树

详细解答

1. 求二叉树中的节点个数
递归解法：
（1）如果二叉树为空，节点个数为0
（2）如果二叉树不为空，二叉树节点个数 = 左子树节点个数 + 右子树节点个数 + 1
参考代码如下：

[cpp]  view plain  copy
  1. int GetNodeNum(BinaryTreeNode * pRoot)  
  2. {  
  3.     if(pRoot == NULL) // 递归出口  
  4.         return 0;  
  5.     return GetNodeNum(pRoot->m_pLeft) + GetNodeNum(pRoot->m_pRight) + 1;  
  6. }  
2. 求二叉树的深度
递归解法：
（1）如果二叉树为空，二叉树的深度为0
（2）如果二叉树不为空，二叉树的深度 = max(左子树深度， 右子树深度) + 1
参考代码如下：
[cpp]  view plain  copy
  1. int GetDepth(BinaryTreeNode * pRoot)  
  2. {  
  3.     if(pRoot == NULL) // 递归出口  
  4.         return 0;  
  5.     int depthLeft = GetDepth(pRoot->m_pLeft);  
  6.     int depthRight = GetDepth(pRoot->m_pRight);  
  7.     return depthLeft > depthRight ? (depthLeft + 1) : (depthRight + 1);   
  8. }  
3. 前序遍历，中序遍历，后序遍历
前序遍历递归解法：
（1）如果二叉树为空，空操作
（2）如果二叉树不为空，访问根节点，前序遍历左子树，前序遍历右子树
参考代码如下：
[cpp]  view plain  copy
  1. void PreOrderTraverse(BinaryTreeNode * pRoot)  
  2. {  
  3.     if(pRoot == NULL)  
  4.         return;  
  5.     Visit(pRoot); // 访问根节点  
  6.     PreOrderTraverse(pRoot->m_pLeft); // 前序遍历左子树  
  7.     PreOrderTraverse(pRoot->m_pRight); // 前序遍历右子树  
  8. }  
中序遍历递归解法
（1）如果二叉树为空，空操作。
（2）如果二叉树不为空，中序遍历左子树，访问根节点，中序遍历右子树
参考代码如下：
[cpp]  view plain  copy
  1. void InOrderTraverse(BinaryTreeNode * pRoot)  
  2. {  
  3.     if(pRoot == NULL)  
  4.         return;  
  5.     InOrderTraverse(pRoot->m_pLeft); // 中序遍历左子树  
  6.     Visit(pRoot); // 访问根节点  
  7.     InOrderTraverse(pRoot->m_pRight); // 中序遍历右子树  
  8. }  
后序遍历递归解法
（1）如果二叉树为空，空操作
（2）如果二叉树不为空，后序遍历左子树，后序遍历右子树，访问根节点
参考代码如下：
[cpp]  view plain  copy
  1. void PostOrderTraverse(BinaryTreeNode * pRoot)  
  2. {  
  3.     if(pRoot == NULL)  
  4.         return;  
  5.     PostOrderTraverse(pRoot->m_pLeft); // 后序遍历左子树  
  6.     PostOrderTraverse(pRoot->m_pRight); // 后序遍历右子树  
  7.     Visit(pRoot); // 访问根节点  
  8. }  

4.分层遍历二叉树（按层次从上往下，从左往右）

相当于广度优先搜索，使用队列实现。队列初始化，将根节点压入队列。当队列不为空，进行如下操作：弹出一个节点，访问，若左子节点或右子节点不为空，将其压入队列。

[cpp]  view plain  copy
  1. void LevelTraverse(BinaryTreeNode * pRoot)  
  2. {  
  3.     if(pRoot == NULL)  
  4.         return;  
  5.     queue<BinaryTreeNode *> q;  
  6.     q.push(pRoot);  
  7.     while(!q.empty())  
  8.     {  
  9.         BinaryTreeNode * pNode = q.front();  
  10.         q.pop();  
  11.         Visit(pNode); // 访问节点  
  12.         if(pNode->m_pLeft != NULL)  
  13.             q.push(pNode->m_pLeft);  
  14.         if(pNode->m_pRight != NULL)  
  15.             q.push(pNode->m_pRight);  
  16.     }  
  17.     return;  
  18. }  
5. 将二叉查找树变为有序的双向链表

要求不能创建新节点，只调整指针。
递归解法：
（1）如果二叉树查找树为空，不需要转换，对应双向链表的第一个节点是NULL，最后一个节点是NULL
（2）如果二叉查找树不为空：
如果左子树为空，对应双向有序链表的第一个节点是根节点，左边不需要其他操作；
如果左子树不为空，转换左子树，二叉查找树对应双向有序链表的第一个节点就是左子树转换后双向有序链表的第一个节点，同时将根节点和左子树转换后的双向有序链  表的最后一个节点连接；
如果右子树为空，对应双向有序链表的最后一个节点是根节点，右边不需要其他操作；
如果右子树不为空，对应双向有序链表的最后一个节点就是右子树转换后双向有序链表的最后一个节点，同时将根节点和右子树转换后的双向有序链表的第一个节点连  接。
参考代码如下：
[cpp]  view plain  copy
  1. /****************************************************************************** 
  2. 参数： 
  3. pRoot: 二叉查找树根节点指针 
  4. pFirstNode: 转换后双向有序链表的第一个节点指针 
  5. pLastNode: 转换后双向有序链表的最后一个节点指针 
  6. ******************************************************************************/  
  7. void Convert(BinaryTreeNode * pRoot,   
  8.              BinaryTreeNode * & pFirstNode, BinaryTreeNode * & pLastNode)  
  9. {  
  10.     BinaryTreeNode *pFirstLeft, *pLastLeft, * pFirstRight, *pLastRight;  
  11.     if(pRoot == NULL)   
  12.     {  
  13.         pFirstNode = NULL;  
  14.         pLastNode = NULL;  
  15.         return;  
  16.     }  
  17.   
  18.     if(pRoot->m_pLeft == NULL)  
  19.     {  
  20.         // 如果左子树为空，对应双向有序链表的第一个节点是根节点  
  21.         pFirstNode = pRoot;  
  22.     }  
  23.     else  
  24.     {  
  25.         Convert(pRoot->m_pLeft, pFirstLeft, pLastLeft);  
  26.         // 二叉查找树对应双向有序链表的第一个节点就是左子树转换后双向有序链表的第一个节点  
  27.         pFirstNode = pFirstLeft;  
  28.         // 将根节点和左子树转换后的双向有序链表的最后一个节点连接  
  29.         pRoot->m_pLeft = pLastLeft;  
  30.         pLastLeft->m_pRight = pRoot;  
  31.     }  
  32.   
  33.     if(pRoot->m_pRight == NULL)  
  34.     {  
  35.         // 对应双向有序链表的最后一个节点是根节点  
  36.         pLastNode = pRoot;  
  37.     }  
  38.     else  
  39.     {  
  40.         Convert(pRoot->m_pRight, pFirstRight, pLastRight);  
  41.         // 对应双向有序链表的最后一个节点就是右子树转换后双向有序链表的最后一个节点  
  42.         pLastNode = pLastRight;  
  43.         // 将根节点和右子树转换后的双向有序链表的第一个节点连接  
  44.         pRoot->m_pRight = pFirstRight;  
  45.         pFirstRight->m_pLeft = pRoot;  
  46.     }  
  47.   
  48.     return;  
  49. }  
6. 求二叉树第K层的节点个数
递归解法：
（1）如果二叉树为空或者k<1返回0
（2）如果二叉树不为空并且k==1，返回1
（3）如果二叉树不为空且k>1，返回左子树中k-1层的节点个数与右子树k-1层节点个数之和
参考代码如下：
[cpp]  view plain  copy
  1. int GetNodeNumKthLevel(BinaryTreeNode * pRoot, int k)  
  2. {  
  3.     if(pRoot == NULL || k < 1)  
  4.         return 0;  
  5.     if(k == 1)  
  6.         return 1;  
  7.     int numLeft = GetNodeNumKthLevel(pRoot->m_pLeft, k-1); // 左子树中k-1层的节点个数  
  8.     int numRight = GetNodeNumKthLevel(pRoot->m_pRight, k-1); // 右子树中k-1层的节点个数  
  9.     return (numLeft + numRight);  
  10. }  
7. 求二叉树中叶子节点的个数
递归解法：
（1）如果二叉树为空，返回0
（2）如果二叉树不为空且左右子树为空，返回1
（3）如果二叉树不为空，且左右子树不同时为空，返回左子树中叶子节点个数加上右子树中叶子节点个数
参考代码如下：
[cpp]  view plain  copy
  1. int GetLeafNodeNum(BinaryTreeNode * pRoot)  
  2. {  
  3.     if(pRoot == NULL)  
  4.         return 0;  
  5.     if(pRoot->m_pLeft == NULL && pRoot->m_pRight == NULL)  
  6.         return 1;  
  7.     int numLeft = GetLeafNodeNum(pRoot->m_pLeft); // 左子树中叶节点的个数  
  8.     int numRight = GetLeafNodeNum(pRoot->m_pRight); // 右子树中叶节点的个数  
  9.     return (numLeft + numRight);  
  10. }  
8. 判断两棵二叉树是否结构相同
不考虑数据内容。结构相同意味着对应的左子树和对应的右子树都结构相同。
递归解法：
（1）如果两棵二叉树都为空，返回真
（2）如果两棵二叉树一棵为空，另一棵不为空，返回假
（3）如果两棵二叉树都不为空，如果对应的左子树和右子树都同构返回真，其他返回假
参考代码如下：
[cpp]  view plain  copy
  1. bool StructureCmp(BinaryTreeNode * pRoot1, BinaryTreeNode * pRoot2)  
  2. {  
  3.     if(pRoot1 == NULL && pRoot2 == NULL) // 都为空，返回真  
  4.         return true;  
  5.     else if(pRoot1 == NULL || pRoot2 == NULL) // 有一个为空，一个不为空，返回假  
  6.         return false;  
  7.     bool resultLeft = StructureCmp(pRoot1->m_pLeft, pRoot2->m_pLeft); // 比较对应左子树   
  8.     bool resultRight = StructureCmp(pRoot1->m_pRight, pRoot2->m_pRight); // 比较对应右子树  
  9.     return (resultLeft && resultRight);  
  10. }   
9. 判断二叉树是不是平衡二叉树
递归解法：
（1）如果二叉树为空，返回真
（2）如果二叉树不为空，如果左子树和右子树都是AVL树并且左子树和右子树高度相差不大于1，返回真，其他返回假
参考代码：
[cpp]  view plain  copy
  1. bool IsAVL(BinaryTreeNode * pRoot, int & height)  
  2. {  
  3.     if(pRoot == NULL) // 空树，返回真  
  4.     {  
  5.         height = 0;  
  6.         return true;  
  7.     }  
  8.     int heightLeft;  
  9.     bool resultLeft = IsAVL(pRoot->m_pLeft, heightLeft);  
  10.     int heightRight;  
  11.     bool resultRight = IsAVL(pRoot->m_pRight, heightRight);  
  12.     if(resultLeft && resultRight && abs(heightLeft - heightRight) <= 1) // 左子树和右子树都是AVL，并且高度相差不大于1，返回真  
  13.     {  
  14.         height = max(heightLeft, heightRight) + 1;  
  15.         return true;  
  16.     }  
  17.     else  
  18.     {  
  19.         height = max(heightLeft, heightRight) + 1;  
  20.         return false;  
  21.     }  
  22. }  
10. 求二叉树的镜像
 递归解法：
（1）如果二叉树为空，返回空
（2）如果二叉树不为空，求左子树和右子树的镜像，然后交换左子树和右子树
参考代码如下：
[cpp]  view plain  copy
  1. BinaryTreeNode * Mirror(BinaryTreeNode * pRoot)  
  2. {  
  3.     if(pRoot == NULL) // 返回NULL  
  4.         return NULL;  
  5.     BinaryTreeNode * pLeft = Mirror(pRoot->m_pLeft); // 求左子树镜像  
  6.     BinaryTreeNode * pRight = Mirror(pRoot->m_pRight); // 求右子树镜像  
  7.         // 交换左子树和右子树  
  8.     pRoot->m_pLeft = pRight;  
  9.     pRoot->m_pRight = pLeft;  
  10.     return pRoot;  
  11. }  
11. 求二叉树中两个节点的最低公共祖先节点
递归解法：
（1）如果两个节点分别在根节点的左子树和右子树，则返回根节点
（2）如果两个节点都在左子树，则递归处理左子树；如果两个节点都在右子树，则递归处理右子树
参考代码如下：
[cpp]  view plain  copy
  1. bool FindNode(BinaryTreeNode * pRoot, BinaryTreeNode * pNode)  
  2. {  
  3.     if(pRoot == NULL || pNode == NULL)  
  4.         return false;  
  5.   
  6.     if(pRoot == pNode)  
  7.         return true;  
  8.   
  9.     bool found = FindNode(pRoot->m_pLeft, pNode);  
  10.     if(!found)  
  11.         found = FindNode(pRoot->m_pRight, pNode);  
  12.   
  13.     return found;  
  14. }  
  15.   
  16. BinaryTreeNode * GetLastCommonParent(BinaryTreeNode * pRoot,   
  17.                                      BinaryTreeNode * pNode1,   
  18.                                      BinaryTreeNode * pNode2)  
  19. {  
  20.     if(FindNode(pRoot->m_pLeft, pNode1))  
  21.     {  
  22.         if(FindNode(pRoot->m_pRight, pNode2))  
  23.             return pRoot;  
  24.         else  
  25.             return GetLastCommonParent(pRoot->m_pLeft, pNode1, pNode2);  
  26.     }  
  27.     else  
  28.     {  
  29.         if(FindNode(pRoot->m_pLeft, pNode2))  
  30.             return pRoot;  
  31.         else  
  32.             return GetLastCommonParent(pRoot->m_pRight, pNode1, pNode2);  
  33.     }  
  34. }  
递归解法效率很低，有很多重复的遍历，下面看一下非递归解法。
非递归解法：
先求从根节点到两个节点的路径，然后再比较对应路径的节点就行，最后一个相同的节点也就是他们在二叉树中的最低公共祖先节点
参考代码如下：
[cpp]  view plain  copy
  1. bool GetNodePath(BinaryTreeNode * pRoot, BinaryTreeNode * pNode,   
  2.                  list<BinaryTreeNode *> & path)  
  3. {  
  4.     if(pRoot == pNode)  
  5.     {     
  6.         path.push_back(pRoot);  
  7.         return true;  
  8.     }  
  9.     if(pRoot == NULL)  
  10.         return false;  
  11.     path.push_back(pRoot);  
  12.     bool found = false;  
  13.     found = GetNodePath(pRoot->m_pLeft, pNode, path);  
  14.     if(!found)  
  15.         found = GetNodePath(pRoot->m_pRight, pNode, path);  
  16.     if(!found)  
  17.         path.pop_back();  
  18.     return found;  
  19. }  
  20. BinaryTreeNode * GetLastCommonParent(BinaryTreeNode * pRoot, BinaryTreeNode * pNode1, BinaryTreeNode * pNode2)  
  21. {  
  22.     if(pRoot == NULL || pNode1 == NULL || pNode2 == NULL)  
  23.         return NULL;  
  24.     list<BinaryTreeNode*> path1;  
  25.     bool bResult1 = GetNodePath(pRoot, pNode1, path1);  
  26.     list<BinaryTreeNode*> path2;  
  27.     bool bResult2 = GetNodePath(pRoot, pNode2, path2);  
  28.     if(!bResult1 || !bResult2)   
  29.         return NULL;  
  30.     BinaryTreeNode * pLast = NULL;  
  31.     list<BinaryTreeNode*>::const_iterator iter1 = path1.begin();  
  32.     list<BinaryTreeNode*>::const_iterator iter2 = path2.begin();  
  33.     while(iter1 != path1.end() && iter2 != path2.end())  
  34.     {  
  35.         if(*iter1 == *iter2)  
  36.             pLast = *iter1;  
  37.         else  
  38.             break;  
  39.         iter1++;  
  40.         iter2++;  
  41.     }  
  42.     return pLast;  
  43. }  

在上述算法的基础上稍加变化即可求二叉树中任意两个节点的距离了。
12. 求二叉树中节点的最大距离
 即二叉树中相距最远的两个节点之间的距离。
递归解法：
（1）如果二叉树为空，返回0，同时记录左子树和右子树的深度，都为0
（2）如果二叉树不为空，最大距离要么是左子树中的最大距离，要么是右子树中的最大距离，要么是左子树节点中到根节点的最大距离+右子树节点中到根节点的最大距离，同时记录左子树和右子树节点中到根节点的最大距离。

参考代码如下：

[cpp]  view plain  copy
  1. int GetMaxDistance(BinaryTreeNode * pRoot, int & maxLeft, int & maxRight)  
  2. {  
  3.     // maxLeft, 左子树中的节点距离根节点的最远距离  
  4.     // maxRight, 右子树中的节点距离根节点的最远距离  
  5.     if(pRoot == NULL)  
  6.     {  
  7.         maxLeft = 0;  
  8.         maxRight = 0;  
  9.         return 0;  
  10.     }  
  11.     int maxLL, maxLR, maxRL, maxRR;  
  12.     int maxDistLeft, maxDistRight;  
  13.     if(pRoot->m_pLeft != NULL)  
  14.     {  
  15.         maxDistLeft = GetMaxDistance(pRoot->m_pLeft, maxLL, maxLR);  
  16.         maxLeft = max(maxLL, maxLR) + 1;  
  17.     }  
  18.     else  
  19.     {  
  20.         maxDistLeft = 0;  
  21.         maxLeft = 0;  
  22.     }  
  23.     if(pRoot->m_pRight != NULL)  
  24.     {  
  25.         maxDistRight = GetMaxDistance(pRoot->m_pRight, maxRL, maxRR);  
  26.         maxRight = max(maxRL, maxRR) + 1;  
  27.     }  
  28.     else  
  29.     {  
  30.         maxDistRight = 0;  
  31.         maxRight = 0;  
  32.     }  
  33.     return max(max(maxDistLeft, maxDistRight), maxLeft+maxRight);  
  34. }  
13. 由前序遍历序列和中序遍历序列重建二叉树
 二叉树前序遍历序列中，第一个元素总是树的根节点的值。中序遍历序列中，左子树的节点的值位于根节点的值的左边，右子树的节点的值位
于根节点的值的右边。
递归解法：
（1）如果前序遍历为空或中序遍历为空或节点个数小于等于0，返回NULL。
（2）创建根节点。前序遍历的第一个数据就是根节点的数据，在中序遍历中找到根节点的位置，可分别得知左子树和右子树的前序和中序遍
历序列，重建左右子树。
[cpp]  view plain  copy
  1. BinaryTreeNode * RebuildBinaryTree(int* pPreOrder, int* pInOrder, int nodeNum)  
  2. {  
  3.     if(pPreOrder == NULL || pInOrder == NULL || nodeNum <= 0)  
  4.         return NULL;  
  5.     BinaryTreeNode * pRoot = new BinaryTreeNode;  
  6.     // 前序遍历的第一个数据就是根节点数据  
  7.     pRoot->m_nValue = pPreOrder[0];  
  8.     pRoot->m_pLeft = NULL;  
  9.     pRoot->m_pRight = NULL;  
  10.     // 查找根节点在中序遍历中的位置，中序遍历中，根节点左边为左子树，右边为右子树  
  11.     int rootPositionInOrder = -1;  
  12.     for(int i = 0; i < nodeNum; i++)  
  13.         if(pInOrder[i] == pRoot->m_nValue)  
  14.         {  
  15.             rootPositionInOrder = i;  
  16.             break;  
  17.         }  
  18.     if(rootPositionInOrder == -1)  
  19.     {  
  20.         throw std::exception("Invalid input.");  
  21.     }  
  22.     // 重建左子树  
  23.     int nodeNumLeft = rootPositionInOrder;  
  24.     int * pPreOrderLeft = pPreOrder + 1;  
  25.     int * pInOrderLeft = pInOrder;  
  26.     pRoot->m_pLeft = RebuildBinaryTree(pPreOrderLeft, pInOrderLeft, nodeNumLeft);  
  27.     // 重建右子树  
  28.     int nodeNumRight = nodeNum - nodeNumLeft - 1;  
  29.     int * pPreOrderRight = pPreOrder + 1 + nodeNumLeft;  
  30.     int * pInOrderRight = pInOrder + nodeNumLeft + 1;  
  31.     pRoot->m_pRight = RebuildBinaryTree(pPreOrderRight, pInOrderRight, nodeNumRight);  
  32.     return pRoot;  
  33. }  
同样，有中序遍历序列和后序遍历序列，类似的方法可重建二叉树，但前序遍历序列和后序遍历序列不同恢复一棵二叉树，证明略。
14.判断二叉树是不是完全二叉树
 若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是完全
二叉树。
有如下算法，按层次（从上到下，从左到右）遍历二叉树，当遇到一个节点的左子树为空时，则该节点右子树必须为空，且后面遍历的节点左
右子树都必须为空，否则不是完全二叉树。
[cpp]  view plain  copy
  1. bool IsCompleteBinaryTree(BinaryTreeNode * pRoot)  
  2. {  
  3.     if(pRoot == NULL)  
  4.         return false;  
  5.     queue<BinaryTreeNode *> q;  
  6.     q.push(pRoot);  
  7.     bool mustHaveNoChild = false;  
  8.     bool result = true;  
  9.     while(!q.empty())  
  10.     {  
  11.         BinaryTreeNode * pNode = q.front();  
  12.         q.pop();  
  13.         if(mustHaveNoChild) // 已经出现了有空子树的节点了，后面出现的必须为叶节点（左右子树都为空）  
  14.         {  
  15.             if(pNode->m_pLeft != NULL || pNode->m_pRight != NULL)  
  16.             {  
  17.                 result = false;  
  18.                 break;  
  19.             }  
  20.         }  
  21.         else  
  22.         {  
  23.             if(pNode->m_pLeft != NULL && pNode->m_pRight != NULL)  
  24.             {  
  25.                 q.push(pNode->m_pLeft);  
  26.                 q.push(pNode->m_pRight);  
  27.             }  
  28.             else if(pNode->m_pLeft != NULL && pNode->m_pRight == NULL)  
  29.             {  
  30.                 mustHaveNoChild = true;  
  31.                 q.push(pNode->m_pLeft);  
  32.             }  
  33.             else if(pNode->m_pLeft == NULL && pNode->m_pRight != NULL)  
  34.             {  
  35.                 result = false;  
  36.                 break;  
  37.             }  
  38.             else  
  39.             {  
  40.                 mustHaveNoChild = true;  
  41.             }  
  42.         }  
  43.     }  
  44.     return result;  
  45. }  
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

轻松搞定面试中的二叉树题目

轻松搞定面试中的二叉树题目 的相关文章

  • windows10系统自带linux子系统（WSL）的安装目录

    如题 xff0c 最近一直想能不能不用VM virtualbox Hyper V等以虚拟机方式在windows10系统中安装linux xff0c 以便打造openwrt编译环境 在网上摸索了许久 xff0c 终于找到了一种方法 xff0c

  • 智慧农业IOT-onenet平台简单介绍

    智慧农业IOT onenet平台简单介绍 1 onenet平台简介 1 1 onenet简介 OneNET是由中国移动打造的PaaS物联网开放平台 平台能够帮助开发者轻松实现设备接入与设备连接 xff0c 快速完成产品开发部署 xff0c

  • 万物互联-stm32单片机简介、烧录、编程及其项目环境搭建

    万物互联 stm32单片机简介 烧录 编程 前言 xff1a stm32单片机这里给出简单介绍 xff0c 给不了解的朋友普及下硬件端的基本知识 xff0c 叙述的较为简单 xff0c 想深入研究的朋友可以去一些官方网站 论坛 博客汲取知识

  • 万物互联-IOT-ESP8266功能、作用、AT、连接onenet服务器简单介绍

    万物互联 IOT ESP8266功能 作用 AT 连接onenet服务器简单介绍 1 ESP8266简介 1 1 ESP8266简介 ESP8266是一个完整且自成体系的 WiFi 网络解决方案 xff0c 能够独立运行 xff0c 也可以

  • 云应用系统开发技术考点（面试题相关）

    云应用系统开发技术考点 xff08 面试题相关 xff09 1 CAP理论 概述 xff1a 一个分布式系统最多只能同时满足一致性 xff08 Consistency xff09 可用性 xff08 Availability xff09 和

  • Linux常用命令大全（超详细分类版）

    Linux常用命令大全 xff08 持续收集 分类 xff09 文件操作 常用 cd home 进入 39 home 39 目录 39 cd 返回上一级目录 cd 返回上两级目录 cd 进入个人的主目录 cd user1 进入个人的主目录

  • 图的基本概念、存储及基本操作(邻接矩阵法与邻接表法）

    图的基本概念 存储及基本操作 邻接矩阵法与邻接表法 xff09 1 图的基本概念 1 1 图的定义 图 xff08 Graph xff09 是由顶点的有穷非空集合和顶点之间边的集合组成 xff0c 通常表示为 xff1a G V E xff

  • 深度优先搜索（DFS）与广度优先搜索（BFS）算法详解

    深度优先搜索 xff08 DFS xff09 与广度优先搜索 xff08 BFS xff09 详解 1 广度优先搜索算法 1 1 前言 和树的遍历类似 xff0c 图的遍历也是从图中某点出发 xff0c 然后按照某种方法对图中所有顶点进行访

  • 小程序微服务单个SSL证书部署多个项目解决方案

    小程序微服务单个SSL证书部署多个项目解决方案 玩过小程序的人 xff0c 都知道小程序上线的要求比较苛刻 xff0c 并不是上架审核苛刻 xff0c 而是前期的服务器上架比较麻烦 xff0c 需要配置SSL证书 xff0c 并且只能使用8

  • 二叉树详解及二叉树的遍历（递归与非递归C++算法实现）

    二叉树详解及二叉树的遍历 xff08 递归与非递归C 43 43 算法实现 xff09 二叉树简介 树 xff08 Tree xff09 是一种由多个节点组成的有限集合T xff0c 有且仅有一个节点称为根 xff08 root xff09

  • node.js及vue安装配置详解

    一 node js 安装配置 1 下载 首先先下载node js xff0c 通过以下链接进行选择下载 https nodejs org download release 选择自己想要的版本进行下载 2 安装 下载完成后双击node exe

  • BP神经网路详解(误差反向传播-链式求导法则）

    BP神经网络详解 简介 BP xff08 Back Propagation xff09 网络是1985年由Rumelhart和McCelland为首的科学家小组提出 xff0c 是一种按误差逆传播算法训练的多层前馈网络 xff0c 是目前应

  • OpenSSL: error:14077410:SSL routines:SSL23_GET_SERVER_HELLO:sslv3 alert handshake failur

    OpenSSL error 14077410 SSL routines SSL23 GET SERVER HELLO sslv3 alert handshake failure Unable to establish SSL connect

  • CV和NLP不分家

    嗯 xff0c 好久没有登陆csdn了 xff0c 看了一下 xff0c 距离上一篇文章发表已经过去了整整半年的时间了 xff0c 消息堆叠了将近100条 也没办法一一回复了 xff0c 因为这么长时间过去了 xff0c 不知道大家的问题都

  • 2022-09-14-openstack介绍

    1 云计算介绍 计算 xff08 CPU 内存 xff09 存储和网络是 IT 系统的三类资源 通过云计算平台 xff0c 这三类资源变成了三个资源池 当需要虚机的时候 xff0c 只需要向平台提供虚机的规格 平台会快速从三个资源池分配相应

  • docker debian中apt-get源替换为阿里源

    场景 docker容器内安装太慢 xff0c 实在受不了这速度了 解决方案 将默认的debian源替换为阿里源 cat命令 因为默认不带vim 查看源配置文件 xff1a span class token function cat span

  • Spring整合Junit

    原始Junit测试Spring的问题 在测试类中 xff0c 每个测试方法都有以下两行代码 xff1a ApplicationContext ac 61 new ClassPathXmlApplicationContext 34 bean

随机推荐

  • STM32驱动舵机（附例程）

    一 PWM Mode xff1a 当计数值小于CRR寄存器值时输出为有效电平 xff0c 而有效电平要根据OCXInit来设置 xff0c 设置的有效电平为高则当CNT值小于设置的CRR寄存器值时输出有效电平高电平 xff0c 当CNT值大

  • Win10下安装Anaconda后，conda不是内部或者外部命令

    今天在安装TAnaconda时 xff0c 在开始 gt 运行 gt cmd时输入如下命令 xff1a conda version 时显示出错 xff0c cuda不是内部或者外部命令 xff1b 第一直觉就是去检查环境变量 xff0c 你

  • VM16-ubuntu16桥接网络频繁掉线

    故障说明 旧电脑使用的vm15 ubuntu16 xff0c 通过移植安装到新电脑 xff0c 后又通过升级把虚拟机升级到vm16 xff0c 更改网络连接的NAT模式到桥接模式 xff0c 发现网络即使出现正常连接的图标和正确的IP地址但

  • IPTV机顶盒刷机过程--山东电信【天邑TY608】

    IPTV机顶盒刷机过程 山东电信 天邑TY608 准备工具拆机过程开始刷机 准备工具 双公头USB数据线 刷机小板 xff0c 我用的是淘宝买的USB转TTL的CH340G的小板 电烙铁 焊锡丝 焊锡膏 单排排针 拆机过程 这个型号的机顶盒

  • OpenStack Availability Zone和Aggregate Hosts理解

    1 availability zone az是在region范围内的再次切分 xff0c 只是工程上的独立 xff0c 例如可以把一个机架上的机器划分在一个az中 xff0c 划分az是为了提高容灾性和提供廉价的隔离服务 选择不同的regi

  • Mysql 根据月份分组并返回分组中的所有数据

    现有数据如下 xff1a 交易描述 金额 时间 交易A 1000 2021 01 28 交易B 2000 2021 01 30 交易C 3000 2021 02 03 交易D 4000 2021 02 04 交易E 5000 2021 02

  • 程序设计思维与实践 Week13 作业 (3/4/数据班)

    A TT 的神秘任务1 xff08 必做 xff09 这一天 xff0c TT 遇到了一个神秘人 神秘人给了两个数字 xff0c 分别表示 n 和 k xff0c 并要求 TT 给出 k 个奇偶性相同的正整数 xff0c 使得其和等于 n

  • 安装scikit-learn问题

    1 问题描述如下 xff1a pytorch root 64 cento conda install scikit learn Solving environment failed CondaHTTPError HTTP 000 CONNE

  • 火狐下setting a property that has only a getter 的错误, 真是诡异...

    刚刚遇到了个很诡异的问题 xff0c 有一段看似没有错误的js代码硬是在火狐下会报个 setting a property that has only a getter 错误 xff0c 而在其他浏览器下却可以正常运行 xff0c 代码大概

  • 最新社区版idea插件“intellij-spring-assistant”

    1 背景 idea社区版已经用了好长时间了 xff0c 其中丰富的插件库让社区版使用起来与专业版无差异 xff0c 完全能够满足当前工作需求 xff0c 但是随着版本的不断更新 xff0c 原作者已不再更新 xff0c 导致无法在新版本上使

  • VS2017/2019中默认编码问题，修改文本编码格式 为UTF-8

    1 修改VS中单个文本编码方式 VS2017 2019中默认格式为 GB2312 很多时候可能出现乱码情况 xff0c 就是编码问题 xff0c 接下来 xff0c 可以修改编码方式 xff1a 操作方法如下所示 xff1a 首先 xff0

  • 宏定义中的括号和自增自减运算（1）

    宏定义中容易引起许多运算优先级的问题 xff0c 需要用括号加以约束 例如 define abs x x gt 0 x x abs a b abs a 43 1 带入展开后 xff0c 结果如下 xff1a a b gt 0 a b a b

  • K-means算法

    算法描述 xff1a 1 gt 从N个数据中选出K个元素作为质心 xff0c 即数据将被分成K簇 2 gt 依次计算剩下的每一个元素到K个元素的相异度 xff0c 一般是计算距离 xff0c 将这些元素分别划分到相异度最低的簇中去 3 gt

  • 编程领域中的事务概念解析

    在编程领域 xff0c 事务 xff08 Transaction xff09 是一个非常重要的概念 它可以帮助我们处理分布式系统中的并发问题 保证数据的一致性和完整性 本文将详细解释事务的概念及其在编程中的应用 一 什么是事务 xff1f

  • C++流概述

    C 43 43 流概述 在程序设计中 xff0c 数据输入 输出 xff08 I O xff09 操作是必不可少的 xff0c C 43 43 语言的数据输入 输出操作是通过I O流库来实现的 C 43 43 中把数据之间的传输操作称为流

  • kNN(K-Nearest Neighbor)最邻近规则分类

    K最近邻分类算法 方法的思路 xff1a 如果一个样本在特征空间中的k个最相似 xff08 即特征空间中最邻近 xff09 的样本中的大多数属于这一类别 xff0c 则该样本也属于这个类别 KNN算法中 xff0c 所选择的邻居都是已经正确

  • SPOOLING技术

    SPOOLING技术 xff08 Simultaneous Peripheral Operating On Line 同时联机外围操作技术 xff0c 它是关于慢速字符设备 如何与计算机主机进行数据交换 的一种技术 xff0c 通常又称 假

  • Belady现象

    Belady现象 采用FIFO算法时 xff0c 如果对 个进程未分配它所要求的全部页面 xff0c 有时就会出现分配的页面数增多但缺页率反而提高的异常现象 Belady现象的描述 xff1a 一个进程P要访问M个页 OS分配N N lt

  • 计算结构体的字节数

    结构体中的成员可以是不同的数据类型 xff0c 成员按照定义时的顺序依次存储在连续的内存空间 和数组不一样的是 xff0c 结构体的大小不是所有成员大小简单的相加 xff0c 需要考虑到系统在存储结构体变量时的地址对齐问题 看下面这样的一个

  • 轻松搞定面试中的二叉树题目

    版权所有 xff0c 转载请注明出处 xff0c 谢谢 xff01 http blog csdn net walkinginthewind article details 7518888 树是一种比较重要的数据结构 xff0c 尤其是二叉树

热门标签