• 面试算法 二叉树的遍历，方法 ：线索二叉树 ( morris ) ，前序遍历: 中序遍历: 后序遍历

    1.题目：二叉树遍历
    前序遍历:根左右
    中序遍历:左根右
    后序遍历:左右根
    层序遍历:从上往下、从左往右

     算法： morris遍历

    2.算法：

    morris算法：

    3.算法思想： （这东西讲不清    bibi  看视频！！！）

    前序遍历 
    总结： 1.首先遇到节点左边是 NULL  打印自己 ，遍历自己的右节点  
         2.遇到右节点为空 ，打印数据 节点数据    还有 就是建立线索二叉树，继续遍历自己的左节点， 
             3.遇到线索二叉树，消除线索二叉树 ,遍历自己的 右节点 
     

    中序遍历 
    总结： 1.首先到达最左边的时候 需要打印数据
           2.断开线索连接的时候 打印数据 
           3.节点的最左边为 NULL  打印当前节点的数据 
     

    后序遍历
    总结： 断开线索二叉树的时候，链表反转，打印数据 

    4.代码：

    1. /*************************************************
    2. 作者：She001
    3. 时间:2022/9/31
    4. 题目：二叉树遍历
    5. 前序遍历:根左右
    6. 中序遍历:左根右
    7. 后序遍历:左右根
    8.  
    9. 算法 ： morris遍历(线索二叉树) 
    10. ***************************************************/
    11.  
    12. #include<bits/stdc++.h>
    13. using namespace std;
    14.  
    15.  
    16. typedef struct student
    17. {
    18. 	int a;
    19. 	struct student * left;
    20. 	struct student * right;
    21. 	int shendu;//树的深度 
    22. }node;  //指针类型的 
    23. /*//二叉树模型 
    24. 						
    25. 					a1
    26. 			a2              a3
    27. 		a4	  a5        a6     a7
    28. 		            a8
    29.                        a9
    30. */
    31. ///
    32.  
    33. //遍历的方法实现 
    34. /*
    35. 前序遍历:根左右
    36. 中序遍历:左根右
    37. 后序遍历:左右根
    38. 层序遍历:从上往下、从左往右
    39. */
    40.  
    41. // 手写方法1 的 前序遍历  过程   
    42. /*
    43. 1.开始  cur== a1  ,定义了 mostright=NULL   ， 
    44. 2.mostright = cur->left =a1->lift  = a2 ;||   mostright 进入循环 ->  一直到  mostright= a5 ,
    45. 3. 退出 while 循环 进入判断  判读条件成功的为  mostright == NULL   ,所以我们建立 线索二叉树     ====|||a5 ->right =a1;||||====  
    46. 打印数据  输出数据    cur ->a =  打印 a1->a   ; cur=cur->left= a2; continue;
    47. 4.这次从 a2 开始  我们开始   
    48. 5. mostright = cur->lift =  a2->lift =a4;
    49. 6.不能进入while 循环 ，因为 s4->right =NULL ;   
    50. 7. 进入if  判断  所以      =====||||a4 -> right = a2;|||||=====    
    51. 输出数据 cur->a   =  输出数据 a2-> a  ;     cur= cur->left  =a4   continue;
    52. 8.这次从 a4 开始  
    53. 9.开始  mostright= cur->left =a4 ->left =NULL
    54. 10. 进入 mostright ==NULL  的判断  判断不成立 所以进入 else 的里面 输出数据   cur ->a   =  a4->a    然后我们的出来最后有一个  cur =cur -> right =  a4->right ; cur=a2 
    55. 11. cur=a2    mostright = a2->left = a4 ;  进入 while  循环   退出循环，， 因为 mostright ->right=cur  ;  删除 线索二叉树 cur  = cur->right = a2->right= a5; 
    56. 12. 这时候 从 cur =  a5 开始 
    57. 13. mostright =cur ->left  =a5->left =NULL 
    58. 14.mostright =NULL   if 判断  ，  mostright =NULL  所以我们进入 else  空间 ，所以执行  打印数据，cur ->a  =  a5->a  , 
    59. 15.cur=cur->right  = a5->  right    = a1; 
    60. 16.mostright= cur->left =a2 ;  进入循环 ， 退出循环因为  mostright->right = a2-> right=a5 , mostright->right=a5->right =a1  ,  mostright ==cur 这个原因退出循环
    61. 17.进入判断  因为 mostright == cur 所以 删除 线索二叉树的连接！  cur = cur -> right  = a1 -> a3;
    62. 18. mostright =cur->left  =a3->left  = a6   进入 循环出来   判断   mostright -> right =NULL       ========||||||||  a6  ->right  = a3;  
    63.    打印 cur-> a  = a3->a ;   cur=cur ->left = a3->left =a6; 
    64. 19. mostright = cur-> left = a6->left = a8 ;      mostright进入循环 ，直到  a9 的时候停止。 ======||||||||||||a9->right =a6;
    65. 	打印cur ->a  =a6 ->a    ;  cur= cur->left = a6->left = a8 ; 
    66. 20.mostright =cur ->left  =NULL   打印 a8->a   cur=cur->right  = a9; 
    67. 21. mostright= a9->left = NULL;  所以  停止，打印 cur-> a = a9->a;  cur =a9 ->right  = a6 ;
    68. 21 mostright= cur-> left  =a8 ; a8->right = a9  a9 ->right =a6   mostright== cur  循环停止  所以消除线索二叉树  ， cur = cur->right = a6-> right = a3; 
    69. 22.mostright = cur->left = a3->left=a6;   mostright->right ===cur 循环结束   所以消除线索二叉树 ， cur = cur -> right = a7; 
    70. 23. mostright = a7->right =NULL  ;   建立线索二叉树， a7->right = a7;  , 打印 a7  ;  cur= cur->left = NULL  ,
    71. 24.if   判断   cur  == NULl  退出外部的大循环！ 
    72. */
    73. /*
    74. 前序遍历 
    75. 总结： 1.首先遇到节点左边是 NULL  打印自己 ，遍历自己的右节点  
    76.  		2.遇到右节点为空 ，打印数据 节点数据    还有 就是建立线索二叉树，继续遍历自己的左节点， 
    77. 		 3.遇到线索二叉树，消除线索二叉树 ,遍历自己的 右节点 
    78. */
    79. void fangfa_1(node * cur)//前序遍历
    80. {
    81. 	if(cur == NULL)
    82. 	{
    83. 		return ;
    84. 	} 
    85. 	node * mostright = NULL; //寻找最左边子树的 最靠右的叶子节点   标记位
    86. 	while(cur !=NULL)
    87. 	{		
    88. 		mostright=cur->left;//寻找开始，从当前节点的下一个左边节点 ，开始寻找，寻找当前节点左子树的最靠右的叶子节点   (假如没有就 没有)
    89. 		if(mostright !=NULL)
    90. 		{
    91. 			while(mostright->right!=NULL && mostright->right!=cur)//一直找，停止的条件，第一个是当前节点的右节点为 NULL  ， 第二个是 当前线索二叉树已经建立， 
    92. 			{
    93. 				mostright=mostright->right;//往右走 
    94. 			}
    95. 			if(mostright->right==NULL)//找到了 cur 节点的子树的最右边节点 ,建立线索二叉树 
    96. 			{
    97. 				mostright->right=cur;  //我们建立线索二叉树  实现子树 最右边的节点 连接 当前的节点 
    98. 				//因为 这个是 前序的遍历，所以我们到了 节点 就打印
    99. 				cout<<cur->a<<"   ";
    100. 				cur=cur->left;//寻找当前节点的左边节点的线索二叉树
    101. 				continue; //结束，再次循环 //防止与下一步冲突 
    102. 			}
    103. 			else//已经含有线索二叉树，我们需要删除节点， 
    104. 			{
    105. 				mostright->right=NULL;//删除含有线索的叶子节点 的连接 
    106. 			} 		
    107. 		}
    108. 		else//当我们的  mostright==NULL  的时候我们需要打印数值 // 因为此时是二叉树的最左边的节点 ，打印当前的节点的值 
    109. 		{
    110. 			cout<<cur->a<<"   ";	//打印数值		
    111. 		}
    112. 		cur=cur->right; 
    113. 	} 
    114. } 
    115.  
    116. /*
    117. 中序遍历 
    118. 总结： 1.首先到达最左边的时候 需要打印数据
    119.        2.断开线索连接的时候 打印数据 
    120.        3.节点的最左边为 NULL  打印当前节点的数据 
    121. */
    122.  
    123.  
    124. void fangfa_2(node * cur)//中序遍历
    125. {
    126. 	if(cur == NULL)
    127. 	{
    128. 		return ;
    129. 	} 
    130. 	node * mostright = NULL; //寻找最左边子树的 最靠右的叶子节点   标记位
    131. 	while(cur !=NULL)
    132. 	{		
    133. 		mostright=cur->left;//寻找开始，从当前节点的下一个左边节点 ，开始寻找，寻找当前节点左子树的最靠右的叶子节点   (假如没有就 没有)
    134. 		if(mostright !=NULL)
    135. 		{
    136. 			while(mostright->right!=NULL && mostright->right!=cur)//一直找，停止的条件，第一个是当前节点的右节点为 NULL  ， 第二个是 当前线索二叉树已经建立， 
    137. 			{
    138. 				mostright=mostright->right;//往右走 
    139. 			}
    140. 			if(mostright->right==NULL)//找到了 cur 节点的子树的最右边节点 ,建立线索二叉树 
    141. 			{
    142. 				mostright->right=cur;  //我们建立线索二叉树  实现子树 最右边的节点 连接 当前的节点 
    143. 			
    144. 				cur=cur->left;//寻找当前节点的左边节点的线索二叉树
    145. 				continue; //结束，再次循环 //防止与下一步冲突 
    146. 			}
    147. 			else//已经含有线索二叉树，我们需要删除节点， 
    148. 			{
    149. 				mostright->right=NULL;//删除含有线索的叶子节点 的连接 
    150. 			} 		
    151. 		}
    152. 		else//当我们的  mostright==NULL  的时候我们需要打印数值 // 因为此时是二叉树的最左边的节点 ，打印当前的节点的值 
    153. 		{
    154. 			
    155. 		}
    156. 		cout<<cur->a<<"   ";	//打印数值		
    157. 		cur=cur->right; 
    158. 	} 
    159. } 
    160.  
    161. /*
    162. 后序遍历
    163. 总结： 断开线索二叉树的时候，链表反转，打印数据 
    164.  
    165.  
    166. */
    167.  
    168. node* reverse(node* head)//链表反转 
    169. {
    170. 	node* prev =NULL;
    171. 	node* curr;
    172. 	node* next;
    173. 	curr=head;
    174. 	while(curr!=NULL)
    175. 	{
    176. 		next=curr->right;
    177. 		curr->right=prev;
    178. 		prev=curr;
    179. 		curr=next;
    180. 	}
    181. 	return prev;
    182. 	
    183. }
    184.  
    185.  
    186. void printnode(node *head)//打印数据  ，步骤，链表反转，打印数据，还原链表，保持二叉树的完整性
    187. {
    188. 	node *hh = reverse(head);//第一反过来 
    189. 	node * ww=hh;//保存开头的节点 
    190. 	while(hh!=NULL)//打印数据 
    191. 	{
    192. 		cout<<hh->a<<"   ";
    193. 		hh=hh->right;
    194. 	}
    195. 	reverse(ww);	//还原 
    196. } 
    197.  
    198.  
    199. void fangfa_3(node * cur)//中序遍历
    200. {
    201. 	if(cur == NULL)
    202. 	{
    203. 		return ;
    204. 	} 
    205. 	node * mostright = NULL; //寻找最左边子树的 最靠右的叶子节点   标记位
    206. 	node * jj=cur;
    207. 	while(cur !=NULL)
    208. 	{		
    209. 		mostright=cur->left;//寻找开始，从当前节点的下一个左边节点 ，开始寻找，寻找当前节点左子树的最靠右的叶子节点   (假如没有就 没有)
    210. 		if(mostright !=NULL)
    211. 		{
    212. 			while(mostright->right!=NULL && mostright->right!=cur)//一直找，停止的条件，第一个是当前节点的右节点为 NULL  ， 第二个是 当前线索二叉树已经建立， 
    213. 			{
    214. 				mostright=mostright->right;//往右走 
    215. 			}
    216. 			if(mostright->right==NULL)//找到了 cur 节点的子树的最右边节点 ,建立线索二叉树 
    217. 			{
    218. 				mostright->right=cur;  //我们建立线索二叉树  实现子树 最右边的节点 连接 当前的节点 
    219. 				
    220. 				cur=cur->left;//寻找当前节点的左边节点的线索二叉树
    221. 				continue; //结束，再次循环 //防止与下一步冲突 
    222. 			}
    223. 			else//已经含有线索二叉树，我们需要删除节点， 
    224. 			{
    225. 				
    226. 				mostright->right=NULL;//删除含有线索的叶子节点 的连接 
    227. 				printnode(cur->left);
    228. 			} 		
    229. 		}
    230. 		cur=cur->right; 
    231. 	} 
    232. 	printnode(jj);
    233. } 
    234.  
    235.  
    236.  
    237.  
    238.  
    239.  
    240.  
    241. int main()
    242. {
    243. 	//数据初始化，建立树 
    244. 	struct student *a1 =new struct student; 
    245. 	struct student *a2 =new struct student; 
    246. 	struct student *a3 =new struct student; 
    247. 	struct student *a4 =new struct student; 
    248. 	struct student *a5 =new struct student; 
    249. 	struct student *a6 =new struct student; 
    250. 	struct student *a7 =new struct student; 
    251. 	struct student *a8 =new struct student; 
    252. 	struct student *a9 =new struct student; 
    253. 	//数值的赋值 
    254. 	a1->a=1; 
    255. 	a2->a=2; 
    256. 	a3->a=3; 
    257. 	a4->a=4; 
    258. 	a5->a=5; 
    259. 	a6->a=6; 
    260. 	a7->a=7; 
    261. 	a8->a=8; 
    262. 	a9->a=9; 
    263. 	//节点的连接 
    264. 	a1->left=a2;
    265. 	a1->right=a3;
    266. 	a2->left=a4;
    267. 	a2->right=a5;
    268. 	a3->left=a6;
    269. 	a3->right=a7;
    270. 	a6->left=a8;
    271. 	a8->right=a9;
    272. 	//节点为空的设置
    273. 	a4->left=NULL;
    274. 	a4->right=NULL;
    275. 	a5->left=NULL;
    276. 	a5->right=NULL;
    277. 	a8->left=NULL;
    278. 	a9->left=NULL;
    279. 	a9->right=NULL;
    280. 	a6->right=NULL;
    281. 	a7->left=NULL;
    282. 	a7->right=NULL;
    283. 	
    284. 	
    285. 		//打印前序遍历
    286. 	cout<<"前序遍历：  "; 
    287. 	fangfa_1(a1); 
    288. 	cout<<endl; 
    289. 		//打印中序遍历
    290. 	cout<<"中序遍历：  "; 
    291. 	fangfa_2(a1); 
    292. 	cout<<endl; 
    293. 	
    294. 		
    295. 		//打印后序遍历 
    296. 	cout<<"后序遍历 ：  "; 
    297. 	fangfa_3(a1); 
    298. 	cout<<endl; 
    299. 	
    300. 	//释放空间 
    301. 	delete a1;
    302. 	delete a2;
    303. 	delete a3;
    304. 	delete a4;
    305. 	delete a5;
    306. 	delete a6;
    307. 	delete a7;
    308. 	delete a8;
    309. 	delete a9;	
    310.  
    311. 	return 	0;
    312. }

     5.线索二叉树的解释

    线索二叉树是链表表示的树，它是利用了二叉树未被使用的 n + 1个闲置的指针构成的树；
    根据二叉树的三种遍历方式构成了三种不同的线索二叉树；
    二叉树的遍历只能从根结点开始依次遍历，而构建了线索二叉树后，就可以从二叉树中任何一个结点进行遍历，这就是线索化最大的意义了；
    实际上线索二叉树的应用面是很窄的，但是学习它最重要的意义还是理解它的这种思想；
    就是将闲置的空间充分利用起来，这应该是最重要的意义了；

    本质：

    二叉树的遍历本质上是将一个复杂的非线性结构转换为线性结构，使每个结点都有了唯一前驱和后继（第一个结点无前驱，最后一个结点无后继）。对于二叉树的一个结点，查找其左右子女是方便的，其前驱后继只有在遍历中得到。为了容易找到前驱和后继，有两种方法。一是在结点结构中增加向前和向后的指针，这种方法增加了存储开销，不可取；二是利用二叉树的空链指针。

    优势

    (1)利用线索二叉树进行中序遍历时，不必采用堆栈处理，速度较一般二叉树的遍历速度快，且节约存储空间。

    (2)任意一个结点都能直接找到它的前驱和后继结点。 

    不足

    (1)结点的插入和删除麻烦，且速度也较慢。

    (2)线索子树不能共用。 

    密语：

    其实无论是什么样的序列化，只需要记得下面这三句话：

    • 如果结点有左孩子：那么Lchild指向他的左孩子，否则指向遍历序列中他的前驱结点。
    • 如果结点有右孩子：那么Rchild依然指向他的左孩子，否则指向遍历序列的后继节点。
    • 前驱或者后驱没有，就为NULL。
  • 相关阅读:
    Hystrix 服务熔断
    java的JSR、JCP访问地址
    Flutter快学快用02 事件循环：Flutter 中代码是如何执行和运行的
    大数据生态圈完整知识体系
    abc 137 Count 1‘s 【经典思维】
    html5学习笔记19-SSE服务器发送事件(Server-Sent Events)
    LabVIEW挖坑指南
    2022年最新Android面试题整理，全网都在看，史上最全面试攻略
    【HDR】Deep high dynamic range imaging of dynamic scenes
    逐字稿 | 8 视频理解论文串讲（上）【论文精读】
  • 原文地址：https://blog.csdn.net/she666666/article/details/126664383