首页 > （转）二叉树系列面试问题

（转）二叉树系列面试问题

转自 ：http://blog.csdn.net/luckyxiaoqiang/article/details/7518888/

 

版权所有，转载请注明出处，谢谢！

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 plaincopy
  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 plaincopy
  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 plaincopy
  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 plaincopy
  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 plaincopy
  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 plaincopy
  1. void LevelTraverse(BinaryTreeNode * pRoot)  
  2. {  
  3.     if(pRoot == NULL)  
  4.         return;  
  5.     queue 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 plaincopy
  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 plaincopy
  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 plaincopy
  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 plaincopy
  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 plaincopy
  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 plaincopy
  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 plaincopy
  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 plaincopy
  1. bool GetNodePath(BinaryTreeNode * pRoot, BinaryTreeNode * pNode,   
  2.                  list & 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 path1;  
  25.     bool bResult1 = GetNodePath(pRoot, pNode1, path1);  
  26.     list path2;  
  27.     bool bResult2 = GetNodePath(pRoot, pNode2, path2);  
  28.     if(!bResult1 || !bResult2)   
  29.         return NULL;  
  30.     BinaryTreeNode * pLast = NULL;  
  31.     list::const_iterator iter1 = path1.begin();  
  32.     list::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 plaincopy
  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 plaincopy
  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 plaincopy
    1. bool IsCompleteBinaryTree(BinaryTreeNode * pRoot)  
    2. {  
    3.     if(pRoot == NULL)  
    4.         return false;  
    5.     queue 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. }  

转载于:https://www.cnblogs.com/wrencai/p/5863714.html

更多相关：

  • 边缘计算架构_Openshift为边缘计算提供三节点架构部署

    当一个IT组织开始走到需要实施网络边缘的旅程时，他们很快意识到面对的挑战与他们在传统数据中心内所经历的挑战不同。 第一个挑战是空间。与更大的核心或区域数据中心同类产品相比，许多边缘站点的物理尺寸更小，因此，需要仔细计划好，尝试在未为其专门设计的空间中安装硬件。  第二个挑战是运行环境。还必须解决的可能面对的冷热温度变化 ，天气，无...

  • node 获取表单数据 为空_数据结构与算法(python)单向循环链表

    单向循环链表单链表的一个变形是单向循环链表, 链表的最后一个节点的next域不再为None, 而是指向链表的头节点.单向循环链表如图所示:单向循环链表同样单向循环链表也是要使用python来对它的基本功能进行一个封装. 总体大致的功能如下:is_empty() 判断链表是否为空length() 返回链表的长度travel() 遍历ad...

  • 剑指offer：面试题36. 二叉搜索树与双向链表

    题目： 二叉搜索树与双向链表 输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的循环双向链表。要求不能创建任何新的节点，只能调整树中节点指针的指向。 为了让您更好地理解问题，以下面的二叉搜索树为例： 我们希望将这个二叉搜索树转化为双向循环链表。链表中的每个节点都有一个前驱和后继指针。对于双向循环链表，第一个节点的前驱是最后一...

  • 剑指offer：面试题18. 删除链表的节点

    题目：删除链表的节点 给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。 返回删除后的链表的头节点。 注意：此题对比原题有改动 示例 1: 输入: head = [4,5,1,9], val = 5 输出: [4,1,9] 解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为...

  • 从零开始的ROS四轴机械臂控制-目录

    【从零开始的ROS四轴机械臂控制】（一）- 实际模型制作、Solidworks文件转urdf与rviz仿真 一、模型制作 1.实际模型制作 2.Solidworks模型制作 二、Solidworks文件转urdf 1.sw_urdf_exporter插件 2.添加坐标系和转轴 3.导出urdf文件 三、rivz仿真...

  • 20162325 金立清 S2 W8 C17

    20162325 2017-2018-2 《程序设计与数据结构》第8周学习总结 教材学习内容概要 二叉查找树是一棵二叉树，对于其中的每个结点，左子树上的元素小于父结点的值，而右子树上的元素大于等于父结点的值。 最有效的二叉树是平衡的，所以每次比较时可以排除一半的元素。 如果没有其他操作，二叉查找树的树形由元素的添加次序来决定。 当...

  • C++ 中NULL 和 nullptr 的区别

    在使用空时，习惯这么赋值  int *p = NULL;  编译器进行解释程序时，NULL会被直接解释成0，所以这里的参数根本就不是大家所想的NULL，参数已经被编译器偷偷换成了0，0是整数。  因此这面的问题就尴尬了 不好意思图片引用于网络中。 为啥呢不是this is the ptr function…这个。这就是C++中的...

  • js在post后台接口的时候，一行代码完成删除对象中所有值为null、undefined或为空字符串““的属性

    var d= {a: 1,b: null,c: 3,d: undefined };Object.keys(d).forEach(k=>d[k]==null&&delete d[k]);//去掉值为null或undefined的对象属性//Object.keys(d).forEach(k=>(d[k]==null||d[k]==='')...

  • 【全网最精简写法】ES6获取浏览器url跟参

    //ES6获取浏览器url跟参 public getUrlParam = a => (a = location.search.substr(1).match(new RegExp(`(^|&)${a}=([^&]*)(&|$)`)),a?a[2]:null);...

  • 设计模式 之美 -- 工厂方法模式

    文章目录1. 解决问题2. 应用场景3. 实现如下C++实现C语言实现4. 缺点 1. 解决问题 在简单工厂模式中，我们使用卖衣服进行举例，同一种工厂可以卖很多不同种类的衣服，工厂只是将衣服的生产过程进行了封装。 当我们增加衣服种类的时候，在简单工厂模式中需要修改工厂的代码，破坏了类的开闭原则（对扩展开发， 对修改关闭），...

  • AnsiToUtf8 和 Utf8ToAnsi

    在服务端数据库的处理当中，涉及中文字符的结构体字段，需要转为Utf8后再存储到表项中。从数据库中取出包含中文字符的字段后，如果需要保存到char *类型的结构体成员中，需要转为Ansi后再保存。从数据库中取出类型数字的字段后，如果需要保存到int型的结构体成员中，需要调用atoi函数进行处理后再保存。 1 static char *...

©2024 11GX.COM