求二叉树中节点的最大距离

合集下载

二叉树知识点总结

二叉树知识点总结1. 二叉树的性质1.1 二叉树的性质一：二叉树的深度二叉树的深度是指从根节点到叶子节点的最长路径长度。

对于一个空树而言，它的深度为0；对于只有一个根节点的树而言，它的深度为1。

根据定义可知，深度为k的二叉树中，叶子节点的深度值为k。

由此可知，二叉树的深度为所有叶子节点深度的最大值。

1.2 二叉树的性质二：二叉树的高度二叉树的高度是指从根节点到叶子节点的最短路径长度。

对于一个空树而言，它的高度为0；对于只有一个根节点的树而言，它的高度为1。

由此可知，二叉树的高度总是比深度大一。

1.3 二叉树的性质三：二叉树的节点数量对于一个深度为k的二叉树而言，它最多包含2^k - 1个节点。

而对于一个拥有n个节点的二叉树而言，它的深度最多为log2(n+1)。

1.4 二叉树的性质四：满二叉树满二叉树是一种特殊类型的二叉树，它的每个节点要么是叶子节点，要么拥有两个子节点。

满二叉树的性质是：对于深度为k的满二叉树而言，它的节点数量一定是2^k - 1。

1.5 二叉树的性质五：完全二叉树完全二叉树是一种特殊类型的二叉树，它的所有叶子节点都集中在树的最低两层，并且最后一层的叶子节点从左到右依次排列。

对于一个深度为k的完全二叉树而言，它的节点数量一定在2^(k-1)和2^k之间。

2. 二叉树的遍历二叉树的遍历是指按照一定的顺序访问二叉树的所有节点。

二叉树的遍历主要包括前序遍历、中序遍历和后序遍历三种。

2.1 前序遍历（Pre-order traversal）前序遍历的顺序是：根节点 -> 左子树 -> 右子树。

对于一个二叉树而言，前序遍历的结果就是按照“根-左-右”的顺序访问所有节点。

2.2 中序遍历（In-order traversal）中序遍历的顺序是：左子树 -> 根节点 -> 右子树。

对于一个二叉树而言，中序遍历的结果就是按照“左-根-右”的顺序访问所有节点。

2.3 后序遍历（Post-order traversal）后序遍历的顺序是：左子树 -> 右子树 -> 根节点。

计算机数据结构今年考研真题及答案

20091.为解决计算机与打印机之间速度不匹配的问题，通常设置一个打印数据缓冲区，主机将要输出的数据依次写入该缓冲区，而打印机则依次从该缓冲区中取出数据。

该缓冲区的逻辑结构应该是A.栈B.队列C.树D.图2.设栈S和队列Q的初始状态均为空，元素abcdefg依次进入栈S。

若每个元素出栈后立即进入队列Q，且7个元素出队的顺序是bdcfeag，则栈S的容量至少是A．1 B.2 C.3 D.43.给定二叉树图所示。

设N代表二叉树的根，L代表根结点的左子树，R代表根结点的右子树。

若遍历后的结点序列为3，1，7，5，6，2，4，则其遍历方式是A．LRN B.NRL C.RLN D.RNL4.下列二叉排序树中，满足平衡二叉树定义的是5.已知一棵完全二叉树的第6层（设根为第1层）有8个叶结点，则完全二叉树的结点个数最多是A．39 B.52 C.111 D.1196.将森林转换为对应的二叉树，若在二叉树中，结点u是结点v的父结点的父结点，则在原来的森林中，u和v可能具有的关系是I．父子关系II.兄弟关系III.u的父结点与v的父结点是兄弟关系A.只有IIB.I和IIC.I和IIID.I、II和III7.下列关于无向连通图特性的叙述中，正确的是I．所有顶点的度之和为偶数II.边数大于顶点个数减1 III.至少有一个顶点的度为1A.只有IB.只有IIC.I和IID.I和III8.下列叙述中，不符合m阶B树定义要求的是A．根节点最多有m棵子树 B.所有叶结点都在同一层上C．各结点内关键字均升序或降序排列 D.叶结点之间通过指针链接9.已知关键序列5，8，12，19，28，20，15，22是小根堆（最小堆），插入关键字3，调整后得到的小根堆是A．3，5，12，8，28，20，15，22，19B.3，5，12，19，20，15，22，8，28C．3，8，12，5，20，15，22，28，19D.3，12，5，8，28，20，15，22，1910.若数据元素序列11，12，13，7，8，9，23，4，5是采用下列排序方法之一得到的第二趟排序后的结果，则该排序算法只能是A．起泡排序 B.插入排序 C.选择排序 D.二路归并排序41.（10分）带权图（权值非负，表示边连接的两顶点间的距离）的最短路径问题是找出从初始顶点到目标顶点之间的一条最短路径。

《编程之美》求二叉树中节点的最大距离

《编程之美》求二叉树中节点的最大距离问题定义(动态规划)如果我们把二叉树看成一个图，父子节点之间的连线看成是双向的，我们姑且定义"距离"为两节点之间边的个数。

写一个程序求一棵二叉树中相距最远的两个节点之间的距离。

书上的解法书中对这个问题的分析是很清楚的，我尝试用自己的方式简短覆述。

计算一个二叉树的最大距离有两个情况:情况A: 路径经过左子树的最深节点，通过根节点，再到右子树的最深节点。

情况B: 路径不穿过根节点，而是左子树或右子树的最大距离路径，取其大者。

只需要计算这两个情况的路径距离，并取其大者，就是该二叉树的最大距离。

我也想不到更好的分析方法。

但接着，原文的实现就不如上面的清楚(源码可从这里下载):1234 5 6 7 8 9101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081// 数据结构定义structNODE{NODE* pLeft;// 左子树NODE* pRight;// 右子树intnMaxLeft;// 左子树中的最长距离intnMaxRight;// 右子树中的最长距离charchValue;// 该节点的值};intnMaxLen = 0;// 寻找树中最长的两段距离voidFindMaxLen(NODE* pRoot){// 遍历到叶子节点，返回if(pRoot == NULL){return;}// 如果左子树为空，那么该节点的左边最长距离为0 if(pRoot -> pLeft == NULL){pRoot -> nMaxLeft = 0;}// 如果右子树为空，那么该节点的右边最长距离为0 if(pRoot -> pRight == NULL){pRoot -> nMaxRight = 0;}// 如果左子树不为空，递归寻找左子树最长距离if(pRoot -> pLeft != NULL){FindMaxLen(pRoot -> pLeft);}// 如果右子树不为空，递归寻找右子树最长距离if(pRoot -> pRight != NULL){FindMaxLen(pRoot -> pRight);}// 计算左子树最长节点距离if(pRoot -> pLeft != NULL){intnTempMax = 0;if(pRoot -> pLeft -> nMaxLeft > pRoot -> pLeft -> nMaxRight) {nTempMax = pRoot -> pLeft -> nMaxLeft;}else{nTempMax = pRoot -> pLeft -> nMaxRight;}pRoot -> nMaxLeft = nTempMax + 1;}// 计算右子树最长节点距离if(pRoot -> pRight != NULL){intnTempMax = 0;if(pRoot -> pRight -> nMaxLeft > pRoot -> pRight -> nMaxRight) {nTempMax = pRoot -> pRight -> nMaxLeft;}else{nTempMax = pRoot -> pRight -> nMaxRight;}pRoot -> nMaxRight = nTempMax + 1;}// 更新最长距离if(pRoot -> nMaxLeft + pRoot -> nMaxRight > nMaxLen){nMaxLen = pRoot -> nMaxLeft + pRoot -> nMaxRight;}}这段代码有几个缺点:算法加入了侵入式(intrusive)的资料nMaxLeft, nMaxRight使用了全局变量nMaxLen。

数据结构习题及答案

3
A．bacde
D．ecbad
22. 设用一维数组 A[n]存储一个栈，令 A[n]为栈底，用整型变量 T 指示当前栈顶位置， A[T] 为栈顶元素。当从栈中弹出一个元素时，变量 T 的变化为（）。 A) T=T+1 C) T 不变 B) T=T-1 D) T=n-1
28. 设 s1＝”I am a student”，s2＝”a student”，则 Index(s1,s2)的值是
29. 假设有二维数组 A5×6，每个元素用相邻的 4 个字节存储，存储器按字节编址。已知 A 的基地址为 1000，则数组 A 的最后一个元素 a45 的第一个字节的地址是储时，元素 a14 的第一个字节的地址是个字节的地址是 30. 一个非空广义表的表头（ A．一定是子表 C．不能是子表。）。 B．一定是原子 D．可以是原子，也可以是子表，tail(L)＝。；按行存
O(1)、线性阶
、平方阶 O(n2)、对数阶
4 以下关于数据结构的基本概念中，叙述正确的是 A) 数据元素是数据不可分割的最小单位。 B) 数据是数据对象的子集。 C) 数据元素之间的关系在计算机中可用顺序映像和非顺序映像两种不同的方法表示。 D) 数据结构在计算机中的表示又称为逻辑结构。 5. 在数据结构中，数据的逻辑结构包括（）。 A) 线性结构和非线性结构 B) 逻辑结构和物理结构
《数据结构》习题及答案
2013 年 8 月
1
第一章——第五章习题
一、单选或填空题
。
1. 下列程序段中 S 语句的执行频度为 for(i＝0；i＜n；i++ ） for(j＝0；j＜i；j++ ） S； 2. 下列算法的时间复杂度是（ for(i＝0；i＜n；i++ ） c[i]＝i； 3. 算法的时间复杂度可表示为 O(logn)和指数阶 O(2n)等。）。

Java 数据结构经典题

1.把二元查找树转变成排序的双向链表题目：输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。

要求不能创建任何新的结点，只调整指针的指向。

10/ \6 14/ \ / \4 8 12 16转换成双向链表4=6=8=10=12=14=16。

首先我们定义的二元查找树节点的数据结构如下：struct BSTreeNode{int m_nValue; // value of nodeBSTreeNode *m_pLeft; // left child of nodeBSTreeNode *m_pRight; // right child of node};2.设计包含min函数的栈。

定义栈的数据结构，要求添加一个min函数，能够得到栈的最小元素。

要求函数min、push以及pop的时间复杂度都是O(1)。

3.求子数组的最大和题目：输入一个整形数组，数组里有正数也有负数。

数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。

求所有子数组的和的最大值。

要求时间复杂度为O(n)。

例如输入的数组为1, -2, 3, 10, -4, 7, 2, -5，和最大的子数组为3, 10, -4, 7, 2，因此输出为该子数组的和18。

4.在二元树中找出和为某一值的所有路径题目：输入一个整数和一棵二元树。

从树的根结点开始往下访问一直到叶结点所经过的所有结点形成一条路径。

打印出和与输入整数相等的所有路径。

例如输入整数22和如下二元树10/ \5 12/ \4 7则打印出两条路径：10, 12和10, 5, 7。

二元树节点的数据结构定义为：struct BinaryTreeNode // a node in the binary tree{int m_nValue; // value of nodeBinaryTreeNode *m_pLeft; // left child of nodeBinaryTreeNode *m_pRight; // right child of node};5.查找最小的k个元素题目：输入n个整数，输出其中最小的k个。

并行计算(陈国良版)课后答案

第三章互连网络3.1 对于一颗K 级二叉树（根为0级，叶为k-1级）,共有N=2^k —1个节点，当推广至m —元树时（即每个非叶节点有m 个子节点)时,试写出总节点数N 的表达式。

答:推广至M 元树时，k 级M 元树总结点数N 的表达式为：N=1+m^1+m^2+。

.。

+m^（k —1）=(1—m^k)*1/(1-m);3.2二元胖树如图3.46所示，此时所有非根节点均有2个父节点.如果将图中的每个椭圆均视为单个节点，并且成对节点间的多条边视为一条边，则他实际上就是一个二叉树。

试问：如果不管椭圆，只把小方块视为节点，则他从叶到根形成什么样的多级互联网络？答：8输入的完全混洗三级互联网络.3.3 四元胖树如图3.47所示，试问：每个内节点有几个子节点和几个父节点?你知道那个机器使用了此种形式的胖树？答:每个内节点有4个子节点，2个父节点。

CM —5使用了此类胖树结构.3.4 试构造一个N=64的立方环网络,并将其直径和节点度与N=64的超立方比较之,你的结论是什么?答：A N=64的立方环网络,为4立方环（将4维超立方每个顶点以4面体替代得到），直径d=9，节点度n=4B N=64的超立方网络,为六维超立方(将一个立方体分为8个小立方，以每个小立方作为简单立方体的节点，互联成6维超立方)，直径d=6，节点度n=63.5 一个N=2^k 个节点的 de Bruijin 网络如图3。

48。

个节点的二进制表示，。

试问:该网络的直径和对剖宽度是多少？答：N=2^k 个节点的 de Bruijin 网络直径d=k 对剖宽带w=2^(k-1）3.6 一个N=2^n 个节点的洗牌交换网络如图3.49所示.试问：此网络节点度==?网络直径==？网络对剖宽度==？答：N=2^n 个节点的洗牌交换网络,网络节点度为=2 ，网络直径=n —1 ,网络对剖宽度=43.7 一个N=（k+1)2^k 个节点的蝶形网络如图3.50所示.试问:此网络节点度=？网络直径=?网络对剖宽度=?答：N=（k+1）2^k 个节点的蝶形网络,网络节点度=4 ，网络直径=2＊k ，网络对剖宽度=2^k3。

二叉树常见面试题（进阶）

⼆叉树常见⾯试题（进阶）⼀、常见题型1. 求两个节点的最近公共祖先；2. 求⼆叉树中最远的两个节点的距离；3. 由前序遍历和中序遍历重建⼆叉树（如：前序序列：1 2 3 4 5 6 - 中序序列：3 2 4 1 6 5）；4. 判断⼀棵树是否是完全⼆叉树；5. 将⼆叉搜索树转换成⼀个排序的双向链表。

要求不能创建任何新的结点，只能调整树中结点指针的指向；6.求⼆叉树的宽度；7. 判断⼀棵⼆叉树是否是平衡⼆叉树；8.判断⼀颗⼆叉树是否是另⼀颗树的⼦树。

⼆、解题思路分析1.两个节点的最近公共祖先求两个节点的最近公共祖先可分为三种情况，分别为：（1）求搜索⼆叉树的最近公共祖先。

根据搜索⼆叉树的性质，左⼦树的所有节点⽐根节点⼩，右⼦树的所有节点⽐跟节点⼤。

如果两个节点都⽐根节点⼩，则递归左⼦树；如果两个节点都⽐跟节点⼤，则递归右⼦树；否则，两个节点⼀个在左⼦树，⼀个在右⼦树，则当前节点就是最近公共祖先节点。

1 Node* GetAncestor(Node* root, Node* x1, Node* x2)//1.该⼆叉树为搜索⼆叉树2 {3 assert(x1 && x2);4if (x1->_data <= root->_data && x2->_data <= root->_data)5 {6return GetAncestor(root->_left, x1, x2);//两个节都⼩于根节点，最近公共祖先在左⼦树中7 }8else if (x1->_data > root->_data && x2->_data > root->_data)9 {10return GetAncestor(root->_right, x1, x2);//两个节都⼤于根节点，最近公共祖先在左⼦树中11 }12else13return root; //⼀个在左⼦树，⼀个在右⼦树，找到公共祖先1415 }（2）三叉链，带⽗节点时求最近公共祖先，⼆叉树节点有指向⽗节点的指针。

九章算法——精选推荐

九章算法前⾔第⼀天的算法都还没有缓过来，直接就进⼊了第⼆天的算法学习。

前⼀天⼀直在整理Binary Search的笔记，也没有提前预习⼀下，好在Binary Tree算是⾃⼰最熟的地⽅了吧（LeetCode上⾯Binary Tree的题刷了4遍，⽬前95%以上能够Bug Free）所以还能跟得上，今天听了⼀下，觉得学习到最多的，就是把Traverse和Divide Conquer分开来讨论，觉得开启了⼀⽚新的天地！今天写这个博客我就尽量把两种⽅式都写⼀写吧。

Outline:⼆叉树的遍历前序遍历traverse⽅法前序遍历⾮递归⽅法前序遍历分治法遍历⽅法与分治法Maximum Depth of Binary TreeBalanced Binary Tree⼆叉树的最⼤路径和 (root->leaf)Binary Tree Maximum Path Sum II (root->any)Binary Tree Maximum Path Sum (any->any)⼆叉查找树Validate Binary Search TreeBinary Search Tree Iterator⼆叉树的宽度优先搜索Binary Tree Level-Order Traversal课堂笔记1.⼆叉树的遍历这个应该是⼆叉树⾥⾯最基本的题了，但是在⾯试过程中，不⼀定会考递归的⽅式，很有可能会让你写出⾮递归的⽅法，上课的时候⽼师也提到过，应该直接把⾮递归的⽅法背下来。

这⾥我就不多说了，直接把中序遍历的两种⽅法贴出来吧，最后再加⼊⼀个分治法（这也是第⼀次写，感觉很棒呢，都不需要太多的思考）。

1.1 前序遍历traverse⽅法（Bug Free）：vector<int> res;void helper(TreeNode* root) {if (!root) return;res.push_back(root->val);if (root->left) {helper(root->left);}if (root->right) {helper(root->right);}}vector<int> preorderTraversal(TreeNode *root) {if (!root) {return res;}helper(root);return res;}1.2 前序遍历⾮递归⽅法（Bug Free）：vector<int> preorderTraversal(TreeNode *root) {vector<int> res;if (!root) {return res;}stack<TreeNode*> s;s.push(root);while (!s.empty()) {TreeNode* tmp = s.top();s.pop();res.push_back(tmp->val);// 这⾥注意：栈是先进后出，所以先push右⼦树if (tmp->right) {s.push(tmp->right);}if (tmp->left) {s.push(tmp->left);}}return res;}1.3 前序遍历分治法（Java实现）：vector<int> preorderTraversal(TreeNode *root) {vector<int> res;if (!root) {return res;}//Dividevector<int> left = preorderTraversal(root->left);vector<int> right = preorderTraversal(root->right);//Conquerres.push_back(root->val);res.insert(res.end(), left.begin(), left.end());res.insert(res.end(), right.begin(), right.end());return res;}这三种⽅法也是⽐较直观的，前两个⽐较基础，我就不详细叙述了，但是分治法是值得重点说⼀说的。

数据结构算法设计笔试面试题1

【字符串】1、输入一个字符串，打印出该字符串中字符的所有排列。

例如输入字符串abc，则输出由字符a、b、c所能排列出来的所有字符串abc、acb、bac、bca、cab和cba。

2、有一个由大小写组成的字符串，现在需要对他进行修改，将其中的所有小写字母排在大写字母的前面（大写或小写字母之间不要求保持原来次序），如有可能尽量选择时间和空间效率高的算法。

c语言函数原型void proc（char *str），也可以采用你自己熟悉的语言。

3、编写反转字符串的程序，要求优化速度、优化空间。

4、用C语言实现函数void * memmove(void *dest, const void *src, size_t n)。

memmove函数的功能是拷贝src所指的内存内容前n个字节到dest所指的地址上。

分析：由于可以把任何类型的指针赋给void类型的指针，这个函数主要是实现各种数据类型的拷贝。

5、编程找出两个字符串中最大公共子字符串,如"abccade", "dgcadde"的最大子串为"cad"。

6、输入一个字符串，输出该字符串中对称的子字符串的最大长度。

比如输入字符串"google"，由于该字符串里最长的对称子字符串是"goog"，因此输出4。

7、字符串原地压缩。

题目描述：“eeeeeaaaff" 压缩为"e5a3f2"，请编程实现。

8、请以回溯与不回溯算法实现字符串匹配。

9、输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变。

句子中单词以空格符隔开。

为简单起见，标点符号和普通字母一样处理。

例如：输入"I am a student."，则输出"student. a am I"。

10、在一个字符串中找到第一个只出现一次的字符。

如输入abaccdeff，则输出b。

树和二叉树习题及答案

树和二叉树习题及答案一、填空题1. 不相交的树的聚集称之为森林。

2. 从概念上讲，树与二叉树是两种不同的数据结构，将树转化为二叉树的基本目的是_树可采用孩子-兄弟链表（二叉链表）做存储结构，目的是利用二叉树的已有算法解决树的有关问题。

3. 深度为k的完全二叉树至少有2 k-1个结点。

至多有2 k-1个结点，若按自上而下，从左到右次序给结点编号（从1开始），则编号最小的叶子结点的编号是2 k-2+1。

4. 在一棵二叉树中，度为零的结点的个数为n，度为2的结点的个数为n2，则有n= n2+1。

5. 一棵二叉树的第i（i≥1）层最多有2 i-1个结点；一棵有n （n>0）个结点的满二叉树共有（n+1）/2个叶子和（n-1）/2个非终端结点。

6.现有按中序遍历二叉树的结果为abc，问有5种不同形态的二叉树可以得到这一遍历结果。

7. 哈夫曼树是带权路径最小的二叉树。

8. 前缀编码是指任一个字符的编码都不是另一个字符编码的前缀的一种编码方法，是设计不等长编码的前提。

9. 以给定的数据集合{4，5，6，7，10，12，18}为结点权值构造的Huffman树的加权路径长度是 165 。

10. 树被定义为连通而不具有回路的（无向）图。

11. 若一棵根树的每个结点最多只有两个孩子，且孩子又有左、右之分，次序不能颠倒，则称此根树为二叉树。

12. 高度为k，且有个结点的二叉树称为二叉树。

2k-1 满13. 带权路径长度最小的二叉树称为最优二叉树，它又被称为树。

Huffman14. 在一棵根树中，树根是为零的结点，而为零的结点是结点。

入度出度树叶15. Huffman树中，结点的带权路径长度是指由到之间的路径长度与结点权值的乘积。

结点树根16. 满二叉树是指高度为k，且有个结点的二叉树。

二叉树的每一层i上，最多有个结点。

2k-1 2i-1二、单选题1. 具有10个叶结点的二叉树中有 (B) 个度为2的结点。

(A)8 (B)9 (C)10 (D)112．对二叉树的结点从1开始进行连续编号，要求每个结点的编号大于其左右孩子的编号，同一结点的左右孩子中，其左孩子的编号小于其右孩子的编号，则可采用_（3）次序的遍历实现编号。

6.4数据结构---树的深度

6.4数据结构---树的深度⼀、最⼤深度1.⼆叉树的最⼤深度 leetcode104给定⼀个⼆叉树，找出其最⼤深度。

⼆叉树的深度为根节点到最远叶⼦节点的最长路径上的节点数。

说明: 叶⼦节点是指没有⼦节点的节点。

⽰例：给定⼆叉树 [3,9,20,null,null,15,7]，3/ \9 20/ \15 7返回它的最⼤深度 3思路1：深度优先搜索（递归）终⽌条件：如果⼆叉树为空,则深度为0；递归体：如果不为空,分别求左⼦树的深度和右⼦树的深度,取最⼤的再加1def maxDepth(root):""":type root: TreeNode:rtype: int"""if root == None:return 0leftDepth = maxDepth(root.left) + 1rightDepth = maxDepth(root.right) + 1return leftDepth if leftDepth > rightDepth else rightDepth思路2：把树看做是图，⽤dfs求最长长度的路径from collections import defaultdictdef maxDepth2(nodes):#输⼊:nodes [3,9,20,null,null,15,7]#由节点列表构造图的邻接表def define_graph(arr):neig_dict = defaultdict(list)for i in range(len(arr)):if arr[i] != None:if (2*i+1) <= len(arr)-1 and arr[2*i+1]:#如果左节点存在neig_dict[arr[i]].append(arr[2*i+1])if (2*i+2) <= len(arr)-1 and arr[2*i+2]:#如果右节点存在neig_dict[arr[i]].append(arr[2*i+2])if (i-1)//2 >= 0 and arr[(i-1)//2]:#左⼦树的⽗节点neig_dict[arr[i]].append(arr[(i-1)//2])elif (i-2)//2 >= 0 and arr[(i-2)//2]:#右⼦树的⽗节点neig_dict[arr[i]].append(arr[(i-2)//2])return neig_dict#遍历邻接表,返回⼀次遍历的长度def dfs(nei_dict,i,visit):for j in nei_dict[i]:if j not in visit:visit.add(j)dfs(neig_dict,j,visit)return len(visit)neig_dict = define_graph(nodes)init_node = nodes[0]#图的起始点visit = set()visit.add(init_node)max_len = 0for i in neig_dict[init_node]:#遍历初始点的所有邻接点visit.add(i)max_len = max(dfs(neig_dict,i,visit),max_len)print('visit',visit)visit = set()#每遍历完⼀条路径之后,都要重新定义visitvisit.add(init_node)return max_len# res = maxDepth2([3,9,20,None,None,15,7])# print("最⼤深度",res)思路3：层次遍历，计算有多少层，即为树的深度def maxDepth_leverOrder(arr,arr_level):def levelOrder(arr,i,arr_lever):#i是当前节点是index#先序遍历树的每⼀个节点,当前节点的层数等于上⼀层加⼀if (i-1)//2 >= 0 and arr[(i-1)//2]:#左节点存在arr_lever[i] = arr_lever[(i-1)//2] + 1#等于⽗节点层数加⼀elif (i-1)//2 >= 0 and arr[(i-1)//2]:#右节点存在arr_lever[i] = arr_lever[(i-1)//2] + 1for i in range(1,len(arr)):#遍历除了根节点的其他节点if arr[i] == None:continueelse:levelOrder(arr,i,arr_level)arr = [3,9,20,None,None,15,7]if len (arr) == 1:print(1)else:arr_level = defaultdict(int)arr_level[0] = 1 # 根节点为第⼀层print ('arr_level before',arr_level)maxDepth_leverOrder(arr,arr_level)print('arr_level after',arr_level)print('深度',max(arr_level.items(),key=lambda x:x[1]))#5,3==> 树在列表中的index值,对应的深度def level_Order_init(root):# 层次遍历的递归写法def maxDepth_leverOrder_recur(level, result, node):if node:print('level=%s,result长度=%s'%(level,len(result)))#level<len(result)，说明有下⼀层,但是还没放数据#level=len(result)，说明有下⼀层且该层数据已经遍历完if level == len(result):#说明该层数据已经遍历完成,下⼀步要遍历下⼀层的数据result.append([])result[level].append(node.val)#该层maxDepth_leverOrder_recur(level+1,result,node.left)#左,下⼀层maxDepth_leverOrder_recur(level+1,result,node.right)#右,下⼀层level,result = 0,[]maxDepth_leverOrder_recur(level,result,root)print('深度',len(result))return resultL1 = TreeNode(3)L2 = TreeNode(9)L3 = TreeNode(20)L4 = TreeNode(15)L5 = TreeNode(7)L1.left = L2L1.right = L3L2.left = NoneL2.right = NoneL3.left = L4L3.right = L5res = level_Order_init(L1)print(res)2.N叉树的最⼤深度 leetcode559题⽬：给定⼀个N叉树，找到其最⼤深度。

完全二叉树的总结点数公式

完全二叉树的总结点数公式在解决完全二叉树问题时，有一个重要的公式可以帮助我们计算完全二叉树的总结点数。

根据完全二叉树的特性，我们可以通过判断左子树或右子树的高度来确定完全二叉树是满二叉树还是完全二叉树，并利用递归的方式计算总结点数。

下面是完全二叉树总结点数的公式：若完全二叉树的高度为h，根节点的高度为0，那么：-如果左子树的高度等于右子树的高度（即完全二叉树是满二叉树），则左子树为高度为h-1的满二叉树，其总结点数为2^(h-1)-1，右子树为高度为h-2的完全二叉树，其总结点数可以通过递归的方式计算。

-如果左子树的高度大于右子树的高度（即完全二叉树不是满二叉树），则右子树为高度为h-1的满二叉树，其总结点数为2^(h-2)-1，左子树为高度为h-1的完全二叉树，其总结点数可以通过递归的方式计算。

具体地，我们可以通过以下步骤来计算完全二叉树的总结点数：1.对于给定的完全二叉树，首先计算树的高度h。

可以从根节点开始，通过逐层遍历左子树来计算。

2.判断左子树和右子树的高度是否相等。

如果相等，表示完全二叉树是满二叉树，根据上述公式计算左子树和右子树的总结点数。

3.如果左子树的高度大于右子树的高度，表示完全二叉树不是满二叉树，根据上述公式计算左子树和右子树的总结点数。

4.将左子树和右子树的总结点数相加，并加上根节点，即得到完全二叉树的总结点数。

下面是一个具体的例子来说明完全二叉树的总结点数公式：```/\23/\/\4567```对于上述的完全二叉树，根节点的高度为0，左子树的高度为1，右子树的高度为2、因此，左子树为高度为1的完全二叉树，其总结点数为2^1-1=1，右子树为高度为2的完全二叉树，其总结点数为2^2-1=3、将左子树和右子树的总结点数相加，并加上根节点，即1+3+1=5，所以该完全二叉树的总结点数为5综上所述，完全二叉树的总结点数公式为根据完全二叉树的特性来判断树是满二叉树还是完全二叉树，并利用递归的方式计算总结点数。

设计求一棵二叉树中结点总数的算法

设计求一棵二叉树中结点总数的算法要是你有一颗二叉树，想知道这棵树一共有多少个结点，哎哟，那可不是个简单的事儿，得想办法一一数清楚，不能让一个结点跑掉了。

就像你去买菜，老板给你算价钱的时候，你可得一个个地看着，别把漏掉的菜给忘了。

所以啊，数结点这个事儿，咱们可得小心翼翼地做。

咱们要知道二叉树的结构。

嗯，说白了，二叉树就是一个树形结构，每个“节点”都有最多两个孩子，就像是爸爸妈妈带着孩子们一起玩，孩子们也可以有自己的孩子。

你想啊，树的最顶端是“根”，然后往下分支，慢慢地每个分支又可能分出新的枝条。

这些枝条上的每一个小点，都是一个“结点”。

想想看，能数清楚每个结点，就像找出每棵树上的果子。

哈哈，难不成你觉得那么简单？不过别着急，咱们慢慢来。

数结点，咱们得从根节点开始，从树的顶端开始，逐层数下去。

别看这是个简单的事儿，真到实际操作时可就有点麻烦了。

因为二叉树是一个递归结构，也就是说，数一个节点，其实就是先数它的左右孩子，左右孩子再数它们的孩子，直到没有孩子为止。

所以，我们就得从树的最底层往上数，一层一层地往上汇总，最后就能得出结点总数。

举个例子吧。

假设你有这么一棵二叉树，最上面就是一个根节点，它有两个孩子，一个左孩子和一个右孩子。

好，这两个孩子每个又有自己的孩子，这样一来，咱们就得开始动手数了。

咱们从根节点开始，根节点就是一个结点，对吧？然后，根节点的左孩子是不是又是一个结点？当然是啦！咱们数右孩子，右孩子也是结点。

继续，左孩子的左孩子是结点，左孩子的右孩子是结点，右孩子的左孩子是结点，右孩子的右孩子也是结点。

这样一来，一层一层地数，最终你会发现，哎呀，原来这棵树一共有这么多结点呢。

你要是问我，怎么才能数清楚这些结点，我告诉你，最简单的办法就是用递归。

什么叫递归？嗯，其实就是“自己找自己”。

比如说，你先数这个节点，然后去数它的左子树，再去数右子树，最后把这三部分的结点数加起来，就得到了整个树的结点总数。

编程之美

那当任务管理器报告 CPU 使用率为 0 的时候，谁在使用 CPU 呢？通过任务管理器的“进程（Process）”一栏可以看到，System Idle Process 占用了 CPU 空闲的时间——这时候大家该回忆起在“操作系统原理”这门课上学到的一些知识了吧。系统中有那么多进程，它们什么时候能“闲下来”呢？答案很简单，这些程序或者在等待用户的输入，或者在等待某些事件的发生（WaitForSingleObject()），或者进入休眠状态（通过 Sleep()来实现）。
2 如果应聘者从来没有琢磨过任务管理器，那还是不要在简历上说“精通 Windows”为好。
编程之美——微软技术面试心得
4
1.1 让 CPU 占用率曲线听你指挥
作 1 秒钟，然后休息 1 秒钟，波形很有可能就是锯齿状的——先达到一个峰值（大于>50%），然后跌到一个很低的占用率。
我们尝试着降低两个数量级，令 n = 9 600 000，而睡眠时间相应改为 10 毫秒（Sleep(10)）。用 10 毫秒是因为它不大也不小，比较接近 Windows 的调度时间片。如果选得太小（比如 1 毫秒），则会造成线程频繁地被唤醒和挂起，无形中又增加了内核时间的不确定性影响。最后我们可以得到如下代码：
第1章游戏之乐游戏中碰到的题目11让cpu占用率曲线听你指挥12中国象棋将帅问题13一摞烙饼的排序14买书问题15快速找出故障机器16饮料供货17光影切割问题18小飞的电梯调度算法19高效率地安排见面会110双线程高效下载111nim1一排石头的游戏112nim2拈游戏分析113nim3两堆石头的游戏114连连看游戏设计115构造数独116点游戏117俄罗斯方块游戏118挖雷游戏第2章数字之魅数字中的技巧21求二进制数中1的个数22不要被阶乘吓倒23寻找发帖水王24的数目25寻找最大的k个数26精确表达浮点数27最大公约数问题28找符合条件的整数29斐波那契fibonacci数列210寻找数组中的最大值和最小值211寻找最近点对212快速寻找满足条件的两个数213子数组的最大乘积214求数组的子数组之和的最大值215子数组之和的最大值二维216求数组中最长递增子序列217数组循环移位218数组分割219区间重合判断220程序理解和时间分析221只考加法的面试题第3章结构之法字符串及链表的探索31字符串移位包含的问题32电话号码对应英语单词33计算字符串的相似度34从无头单链表中删除节点35最短摘要的生成36编程判断两个链表是否相交37队列中取最大值操作问题38求二叉树中节点的最大距离39重建二叉树310分层遍历二叉树311程序改错第4章数学之趣数学游戏的乐趣41金刚坐飞机问题42瓷砖覆盖地板43买票找零44点是否在三角形内45磁带文件存放优化46桶中取黑白球47蚂蚁爬杆48三角形测试用例49数独知多少410数字哑谜和回文411挖雷游戏的概率11让cpu占用率曲线听你指挥1编程之美微软技术面试心得编程之美微软技术面试心得38070是微软亚洲研究院技术创新组研发主管邹欣继移山之道vsts软件开发指南后的最新力作

最近公共祖先问题LCA

最近公共祖先问题LCA2018-03-10 18:04:55在图论和计算机科学中，最近公共祖先，LCA(Lowest Common Ancestor)是指在⼀个树或者有向⽆环图中同时拥有v和w作为后代的最深的节点。

计算最近公共祖先往往是很有⽤的，⽐如在计算树中两个节点的距离的时候，可以分别计算根到各个节点的距离，然后计算根到最近公共祖先的距离，⽤之前的距离和减去2倍的根到最近公共祖先的距离就可以得到两个节点的距离。

计算最近公共祖先问题是⼀个⾮常经典的问题，相关的研究也进⾏了很多年，这类问题的求解⽅法也有很多种，这⾥会对其中的⼀些主流的算法做⼀些介绍。

⼀、⼆叉搜索树中的LCA问题描述：给定⼀个⼆叉搜索树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表⽰为⼀个结点 x，满⾜ x 是 p、q 的祖先且 x 的深度尽可能⼤（⼀个节点也可以是它⾃⼰的祖先）。

”例如，给定如下⼆叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]⽰例 1:输⼊: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8输出: 6解释: 节点 2 和节点 8 的最近公共祖先是 6。

⽰例 2:输⼊: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4输出: 2解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本⾝。

说明:所有节点的值都是唯⼀的。

p、q 为不同节点且均存在于给定的⼆叉搜索树中。

问题求解：⼆叉搜索树中的LCA问题可以认为是普通LCA问题的简化版本，因为在⼆叉搜索树中可以通过⽐较数值的⼤⼩来确定当前节点和待查找节点的相对位置关系。

具体来说如下(不妨设v < w):v <= cur <= w :说明v和w位于cur的两侧，或者就是cur，那么cur就是他们的最近公共祖先；cur < v :说明cur ⽐这两个待查找的节点都⼩，也就是说这两个节点都在其右⼦树上，因此递归的在其右⼦树上进⾏查找就可以了；cur > w :同理，只需要递归的在其左⼦树上查找即可。

二叉树的常考算法题目

二叉树的常考算法题目
二叉树是计算机科学中常见的数据结构，以下是几个常见的二叉树相关算法题目：
1. 二叉树的深度：给定一个二叉树，求其深度。

2. 判断二叉树是否为完全二叉树：给定一个二叉树，判断它是否是完全二叉树。

3. 查找二叉树中的最大值和最小值：给定一个二叉树，找到其中的最大值和最小值。

4. 二叉树的镜像：给定一个二叉树，将其镜像（即左右节点交换）。

5. 反转二叉树：给定一个二叉树，将其反转。

6. 二叉树的左视图：给定一个二叉树，找到其左视图。

7. 二叉树的右视图：给定一个二叉树，找到其右视图。

8. 查找二叉树中的前驱节点和后继节点：给定一个二叉树和一个节点，找到该节点的前驱节点和后继节点。

9. 二叉树的层序遍历：给定一个二叉树，使用层序遍历的方式访问其节点。

10. 二叉树的先序遍历、中序遍历和后序遍历：给定一个二叉树，分别使用先序遍历、中序遍历和后序遍历的方式访问其节点。

这些题目是常见的二叉树算法题目，对于掌握二叉树相关算法非常重要。

程序算法总结没有密码版本

注：所有程序以及算法均为本人从网络，书籍中收集，程序均为手写调试完成，供RD001内部使用，参考，谢绝其他一切形式的扩散，共享。

应聘的环节主要包括面试和笔试，其中不免会涉及到很多算法和数据结构的问题，在这里将其先分为两大类，笔试的时候算法题为非即时算法考察，面试的时候算法题为即时算法考察。

笔试时写的算法允许有较长的思考时间，可以专注功能的实现，而暂时不管空间以及时间复杂度，面试的时候不一样，当你写出一个半吊子算法，往往面试官会让你写出一个更好的，一般也会有一些提示。

面试的时候算法的提问一般不会给你很长时间，短则2分钟最长也5分钟你连思路也没有的话基本就pass了。

这里不管是不是即时考察题型，暂且归纳为一起。

Algorithms and Data Structures1明确数据结构，单一进行操作1-1单一数据结构1-1-1链表在单数据结构（即在题目中明确提到了某种数据结构，没有掺杂，也没有背景，只是进行某些特定操作）的题型中，链表是一大类，而单链表因为其特定的存储结构和读取方法又成为考查的重点。

列举题目如下(注：以下题目的给定Node节点全部为如下定义方式)public class Node{public Node next;public object data;}1-1-1-1单链表的反转给定单链表的头节点Node head.给出将此链表反转的方法。

public void ReverseLinkedList(Node head){//首先，反转后必然head为尾部节点，将head的一份拷贝赋值给一个新的node 节点，用于托管旧的链表。

Node nDele = head;//等你将旧链表需要摘取的项加到新链表头部时，需要用另一个node暂时托管旧链表。

Node nNext = null;//此时就将head 置为了新链表的末尾了。

head = null;while (nDele != null){//这几部依次为：先存下当前节点的下一节点用于备份，之后将dele节点指向新链表的头部并且将新链表的头位置前移，同时控制每次循环都能指向后一个节点向前进行。

二叉树的宽度算法

二叉树的宽度算法一、引言二叉树是一种常见的数据结构，在计算机科学和算法领域有着广泛的应用。

二叉树的宽度是指树中某一层节点的最大数量。

计算二叉树的宽度是一项重要的任务，本文将介绍一种常用的二叉树宽度算法。

二、二叉树的定义二叉树是一种特殊的树结构，其中每个节点最多有两个子节点，分别称为左子节点和右子节点。

二叉树可以为空树，或者由根节点和两个分别称为左子树和右子树的二叉树组成。

三、二叉树的宽度算法二叉树的宽度算法是一种层次遍历的算法。

具体步骤如下：1. 创建一个队列，用于存储待遍历的节点。

2. 将根节点加入队列。

3. 循环执行以下步骤，直到队列为空：a. 记录当前队列的长度，即当前层节点的数量。

b. 遍历当前队列中的节点，将其左子节点和右子节点加入队列。

c. 更新最大宽度值，如果当前层节点的数量大于最大宽度值。

d. 从队列中移出当前层节点。

4. 返回最大宽度值。

四、算法实现下面通过一个示例来演示二叉树的宽度算法的实现。

考虑以下二叉树：```1/ \2 3/ \ \4 5 6```按照宽度算法，首先将根节点1加入队列，然后遍历队列，将2和3加入队列。

此时队列中的节点为[2, 3]，记录当前层节点的数量为2，更新最大宽度值为2。

接下来从队列中移出当前层节点，继续遍历队列，将4、5和6加入队列。

此时队列中的节点为[4, 5, 6]，记录当前层节点的数量为3，更新最大宽度值为3。

最后从队列中移出当前层节点，队列为空，返回最大宽度值3。

五、算法分析二叉树的宽度算法的时间复杂度为O(n)，其中n是二叉树中节点的数量。

在算法中，我们需要遍历二叉树的每个节点一次，并将其加入队列，所以时间复杂度为O(n)。

空间复杂度为O(m)，其中m是二叉树中某一层节点的最大数量。

在算法中，我们需要使用一个队列来存储待遍历的节点，所以空间复杂度为O(m)。

六、总结二叉树的宽度算法是一种常用的层次遍历算法，用于计算二叉树中某一层节点的最大数量。

层次遍历算法

层次遍历算法简介是一种二叉树遍历方式，又称为广度优先算法，它是一种从上至下、从左至右的遍历方式，最常用于树形结构进行搜索或者遍历。

可以解决一些问题，例如求二叉树的最小深度、最大深度、它的节点数、它的叶子节点数、它的某个路径等问题。

实现的方法1.使用队列实现使用队列实现是一种常用的方法。

具体步骤如下：（1）将树的根节点入队，初始化队列。

（2）当队列非空时，进行下列操作：①取出队列中的一个节点，访问该节点。

②如果该节点的左子节点不为空，则将左子节点入队。

③如果该节点的右子节点不为空，则将右子节点入队。

实现代码如下：```pythondef level_order_traversal(root):queue = []result = []if root is None:return resultqueue.append(root)while queue:node = queue.pop(0)result.append(node.val)if node.left:queue.append(node.left)if node.right:queue.append(node.right)return result```2.使用递归实现使用递归实现一般需要借助队列，并且需要知道每个节点所在的层数。

具体步骤如下：- （1）使用递归遍历左子树，直到最底层。

在遍历左子树时，需要记录当前所在的层数。

- （2）使用递归遍历右子树，直到最底层。

在遍历右子树时，需要记录当前所在的层数。

- （3）将左子树和右子树的结果合并，即可得到二叉树的层次遍历结果。

实现代码如下：```pythondef level_order_traversal(root):queue = []result = []def dfs(node, level):if not node:returnif level == len(result):result.append([])result[level].append(node.val)dfs(node.left, level+1)dfs(node.right, level+1)dfs(root, 0)return result```的应用在二叉树中的应用是十分广泛的，可以用于如下几个问题的解决：1.求最小深度二叉树的最小深度是从根节点到最近的叶子节点的距离。