二叉树的实现以及分别使用迭代和栈来实现各种遍历的思路

最新推荐文章于 2022-02-12 01:13:56 发布
最新推荐文章于 2022-02-12 01:13:56 发布
阅读量463 收藏
点赞数
分类专栏： 数据结构和算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangwei249/article/details/70236633
版权

一。什么是二叉树遍历：

   所谓遍历(Traversal)是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问题。 
   遍历是二叉树上最重要的运算之一，是二叉树上进行其它运算之基础。

二。三种遍历顺序：   

   ① NLR：前序遍历(Preorder Traversal 亦称（先序遍历））
      访问根结点的操作发生在遍历其左右子树之前。
   ② LNR：中序遍历(Inorder Traversal)
      访问根结点的操作发生在遍历其左右子树之中（间）。
   ③ LRN：后序遍历(Postorder Traversal)

      访问根结点的操作发生在遍历其左右子树之后。


三。三种遍历的迭代实现

        public class BinTree {
		public final static int MAX = 40;
		BinTree[] elements = new BinTree[MAX];// 层次遍历时保存各个节点
		int front;// 层次遍历时队首
		int rear;// 层次遍历时队尾
		private Object data; // 数据元数
		private BinTree left, right; // 指向左,右孩子结点的链

		public BinTree() {
		}

		public BinTree(Object data) { // 构造有值结点
			this.data = data;
			left = right = null;
		}

		public BinTree(Object data, BinTree left, BinTree right) { // 构造有值结点
			this.data = data;
			this.left = left;
			this.right = right;
		}

		public String toString() {
			return data.toString();
		}

		// 前序遍历二叉树
		public static void preOrder(BinTree parent) {
			if (parent == null)
				return;
			System.out.print(parent.data + " ");
			preOrder(parent.left);
			preOrder(parent.right);
		}

		// 中序遍历二叉树
		public void inOrder(BinTree parent) {
			if (parent == null)
				return;
			inOrder(parent.left);
			System.out.print(parent.data + " ");
			inOrder(parent.right);
		}

		// 后序遍历二叉树
		public void postOrder(BinTree parent) {
			if (parent == null)
				return;
			postOrder(parent.left);
			postOrder(parent.right);
			System.out.print(parent.data + " ");
		}

		// 层次遍历二叉树 （核心逻辑：front表示打印到哪个下标了-走的慢每次循环一个，rear表示收录到哪个下标了-走的块每次循环可能收录左右两）
		public void LayerOrder(BinTree parent) {
			elements[0] = parent;
			front = 0;
			rear = 1;
			while (front < rear) {
				try {
					if (elements[front].data != null) {
						System.out.print(elements[front].data + " ");
						if (elements[front].left != null)
							elements[rear++] = elements[front].left;
						if (elements[front].right != null)
							elements[rear++] = elements[front].right;
						front++;
					}
				} catch (Exception e) {
					break;
				}
			}
		}

		// 返回树的叶节点个数
		public int leaves() {
			if (this == null)
				return 0;
			if (left == null && right == null)
				return 1;
			return (left == null ? 0 : left.leaves())
					+ (right == null ? 0 : right.leaves());
		}

		// 结果返回树的高度(核心逻辑：左右树取较大者，每次升一级)
		public int height() {
			int heightOfTree;
			if (this == null)
				return -1;
			int leftHeight = (left == null ? 0 : left.height());
			int rightHeight = (right == null ? 0 : right.height());
			heightOfTree = leftHeight < rightHeight ? rightHeight : leftHeight;
			return 1 + heightOfTree;
		}

		// 如果对象不在树中（核心逻辑：先根遍历，找不到的节点都返回-1，知道找到返回1，然后后续均加一级返回）
		public int level(Object object) {
			int levelInTree;
			if (this == null)
				return -1;
			if (object == data)
				return 1;// 规定根节点为第一层
			int leftLevel = (left == null ? -1 : left.level(object));
			int rightLevel = (right == null ? -1 : right.level(object));
			if (leftLevel < 0 && rightLevel < 0)
				return -1;
			levelInTree = leftLevel < rightLevel ? rightLevel : leftLevel;
			return 1 + levelInTree;

		}

		// 将树中的每个节点的孩子对换位置(核心逻辑：从下往上，从左往右依次交换左右节点)
		public void reflect() {
			if (this == null)
				return;
			if (left != null)
				left.reflect();
			if (right != null)
				right.reflect();
			BinTree temp = left;
			left = right;
			right = temp;
		}

		// 将树中的所有节点移走,并输出移走的节点(核心逻辑：中根遍历，先删除没有左右节点的，然后中间，然后右边，从下往上依次删除)
		public void defoliate() {
			if (this == null)
				return;
			// 若本节点是叶节点，则将其移走
			if (left == null && right == null) {
				System.out.print(this + " ");
				data = null;
				return;
			}
			// 移走左子树若其存在
			if (left != null) {
				left.defoliate();
				left = null;
			}
			// 移走本节点，放在中间表示中跟移走...
			String innerNode = this + " ";
			System.out.print(data + " ");
			data = null; 
			// 移走右子树若其存在
			if (right != null) {
				right.defoliate();
				right = null;
			}
		}

		/**
		 * @param args
		 */
		public static void main(String[] args) {
			// TODO Auto-generated method stub
			BinTree e = new BinTree("E");
			BinTree g = new BinTree("G");
			BinTree h = new BinTree("H");
			BinTree i = new BinTree("I");
			BinTree d = new BinTree("D", null, g);

			BinTree f = new BinTree("F", h, i);
			BinTree b = new BinTree("B", d, e);
			BinTree c = new BinTree("C", f, null);
			BinTree tree = new BinTree("A", b, c);

			System.out.println("前序遍历二叉树结果: ");
			tree.preOrder(tree);
			System.out.println();
			System.out.println("中序遍历二叉树结果: ");
			tree.inOrder(tree);
			System.out.println();
			System.out.println("后序遍历二叉树结果: ");
			tree.postOrder(tree);
			System.out.println();
			System.out.println("层次遍历二叉树结果: ");
			tree.LayerOrder(tree);
			System.out.println();
			System.out.println("F所在的层次: " + tree.level("F"));
			System.out.println("这棵二叉树的高度: " + tree.height());
			System.out.println("--------------------------------------");
			tree.reflect();
			System.out.println("交换每个节点的孩子节点后......");
			System.out.println("前序遍历二叉树结果: ");
			tree.preOrder(tree);
			System.out.println();
			System.out.println("中序遍历二叉树结果: ");
			tree.inOrder(tree);
			System.out.println();
			System.out.println("后序遍历二叉树结果: ");
			tree.postOrder(tree);
			System.out.println();
			System.out.println("层次遍历二叉树结果: ");
			tree.LayerOrder(tree);
			System.out.println();
			System.out.println("F所在的层次: " + tree.level("F"));
			System.out.println("这棵二叉树的高度: " + tree.height());
			System.out.println("--------------------------------------");
			tree.defoliate();
		}
	}	
	
	运行结果：
	前序遍历二叉树结果: 
	A B D G E C F H I 
	中序遍历二叉树结果: 
	D G B E A H F I C 
	后序遍历二叉树结果: 
	G D E B H I F C A 
	层次遍历二叉树结果: 
	A B C D E F G H I 
	F所在的层次: 3
	这棵二叉树的高度: 4
	--------------------------------------
	交换每个节点的孩子节点后......
	前序遍历二叉树结果: 
	A C F I H B E D G 
	中序遍历二叉树结果: 
	C I F H A E B G D 
	后序遍历二叉树结果: 
	I H F C E G D B A 
	层次遍历二叉树结果: 
	A C B F E D I H G 
	F所在的层次: 3
	这棵二叉树的高度: 4
	--------------------------------------
	C I F H A E B G D

四。二叉树的非递归的遍历实现(  B<--A-->C   D<--B-->E   C-->F)

  1.先根遍历

  （先访问根节点，再访问左子树，后访问右子树。而对于每个子树来说，又按照同样的访问顺序进行遍历）
    实现思路如下：
对于任一节点P，
1）输出节点P，然后将其入栈，再看P的左孩子是否为空；
2）若P的左孩子不为空，则置P的左孩子为当前节点，重复1）的操作；
3）若P的左孩子为空，则将栈顶节点出栈，但不输出，并将出栈节点的右孩子置为当前节点，看其是否为空；
4）若不为空，则循环至1）操作；
5）如果为空，则继续出栈，但不输出，同时将出栈节点的右孩子置为当前节点，看其是否为空，重复4）和5）操作；
6）直到当前节点P为NULL并且栈空，遍历结束。

详细分析其先序遍历的非递归实现过程：
  1. 首先，从根节点A开始，根据操作1），输出A，并将其入栈，由于A的左孩子不为空，根据操作2），将B置为当前节点，再根据操作1），将B输出，并将其入栈，           由于B的左孩子也不为空，根据操作2），将D置为当前节点，再根据操作1），输出D，并将其入栈，此时输出序列为ABD；
  2. 由于D的左孩子为空，根据操作3），将栈顶节点D出栈，但不输出，并将其右孩子置为当前节点；
  3. 由于D的右孩子为空，根据操作5），继续将栈顶节点B出栈，但不输出，并将其右孩子置为当前节点；
  4. 由于B的右孩子E不为空，根据操作1），输出E，并将其入栈，此时输出序列为：ABDE；
  5. 由于E的左孩子为空，根据操作3），将栈顶节点E出栈，但不输出，并将其右孩子置为当前节点；
  6. 由于E的右孩子为空，根据操作5），继续将栈顶节点A出栈，但不输出，并将其右孩子置为当前节点；
  7. 由于A的右孩子C不为空，根据操作1），输出C，并将其入栈，此时输出序列为：ABDEC；
  8. 由于A的左孩子F不为空，根据操作2），则将F置为当前节点，再根据操作1），输出F，并将其入栈，此时输出序列为：ABDECF；
  9. 由于F的左孩子为空，根据操作3），将栈顶节点F出栈，但不输出，并将其右孩子置为当前节点；
  10. 由于F的右孩子为空，根据操作5），继续将栈顶元素C出栈，但不输出，并将其右孩子置为当前节点；
  11. 此时栈空，且C的右孩子为NULL，因此遍历结束。
    void pre_traverse(BTree pTree)  
	{  
	    PSTACK stack = create_stack();  //创建一个空栈  
	    BTree node_pop;                 //用来保存出栈节点  
	    BTree pCur = pTree;             //定义用来指向当前访问的节点的指针 
	    
	    while(pCur || !is_empty(stack))  
	    {  
	        //循环遍历根和左孩子
	        printf("%c ", pCur->data);  
	        push_stack(stack,pCur);  
	        pCur = pCur->pLchild;  
	        //到最底部时开始遍历右孩子 
	        while(!pCur && !is_empty(stack))  
	        {  
	            pCur = getTop(stack);  
	            pop_stack(stack,&node_pop);  
	            pCur = pCur->pRchild;              
	        }  
	    }  
     }

2.中根遍历

 （先访问左子树，再访问根节点，后访问右子树，而对于每个子树来说，又按照同样的访问顺序进行遍历）
    实现思路如下：
对于任一节点P，
1）若P的左孩子不为空，则将P入栈并将P的左孩子置为当前节点，然后再对当前节点进行相同的处理；
2）若P的左孩子为空，则输出P节点，而后将P的右孩子置为当前节点，看其是否为空；
3）若不为空，则重复1）和2）的操作；
4）若为空，则执行出栈操作，输出栈顶节点，并将出栈的节点的右孩子置为当前节点，看起是否为空，重复3）和4）的操作；
5）直到当前节点P为NULL并且栈为空，则遍历结束。

详细分析其中序遍历的非递归实现过程：
  1. 首先，从根节点A开始，A的左孩子不为空，根据操作1）将A入栈，接着将B置为当前节点，B的左孩子也不为空，根据操作1），将B也入栈，接着将D置为当前节           点，由于D的左子树为空，根据操作2），输出D；
  2. 由于D的右孩子也为空，根据操作4），执行出栈操作，将栈顶结点B出栈，并将B置为当前节点，此时输出序列为DB；
  3. 由于B的右孩子不为空，根据操作3），将其右孩子E置为当前节点，由于E的左孩子为空，根据操作1），输出E，此时输出序列为DBE；
  4. 由于E的右孩子为空，根据操作4），执行出栈操作，将栈顶节点A出栈，并将节点A置为当前节点，此时输出序列为DBEA；
  5. 此时栈为空，但当前节点A的右孩子并不为NULL，继续执行，由于A的右孩子不为空，根据操作3），将其右孩子C置为当前节点，由于C的左孩子不为空，根据操           作1），将C入栈，将其左孩子F置为当前节点，由于F的左孩子为空，根据操作2），输出F，此时输出序列为：DBEAF；
  6. 由于F的右孩子也为空，根据操作4），执行出栈操作，将栈顶元素C出栈，并将其置为当前节点，此时的输出序列为：DBEAFC；
  7. 由于C的右孩子为NULL，且此时栈空，根据操作5），遍历结束。
    void in_traverse(BTree pTree)  
	{  
		PSTACK stack = create_stack();  //创建一个空栈  
		BTree node_pop;                 //用来保存出栈节点  
		BTree pCur = pTree;             //定义指向当前访问的节点的指针  
	  
		//直到当前节点pCur为NULL且栈空时，循环结束  
		while(pCur || !is_empty(stack))  
		{  
			if(pCur->pLchild)  
			{  
				//如果pCur的左孩子不为空，则将其入栈，并置其左孩子为当前节点  
				push_stack(stack,pCur);  
				pCur = pCur->pLchild;  
			}  
			else  
			{  
				//如果pCur的左孩子为空，则输出pCur节点，并将其右孩子设为当前节点，看其是否为空  
				printf("%c ", pCur->data);  
				pCur = pCur->pRchild;  
				//如果为空，且栈不空，则将栈顶节点出栈，并输出该节点，  
				//同时将它的右孩子设为当前节点，继续判断，直到当前节点不为空  
				while(!pCur && !is_empty(stack))  
				{  
					pCur = getTop(stack);  
					printf("%c ",pCur->data);      
					pop_stack(stack,&node_pop);  
					pCur = pCur->pRchild;  
				}  
			}  
		}  
	}

3.后根遍历

（先访问左子树，再访问右子树，后访问根节点，而对于每个子树来说，又按照同样的访问顺序进行遍历）
    实现思路如下：
对于任一节点P，
1）先将节点P入栈；
2）若P不存在左孩子和右孩子，或者P存在左孩子或右孩子，但左右孩子已经被输出，则可以直接输出节点P，并将其出栈，将出栈节点P标记为上一个输出的节点，再将此时的栈顶结点设为当前节点；
3）若不满足2）中的条件，则将P的右孩子和左孩子依次入栈，当前节点重新置为栈顶结点，之后重复操作2）；
4）直到栈空，遍历结束。
    
详细分析其后序遍历的非递归实现过程：
  1. 首先，设置两个指针：Cur指针指向当前访问的节点，它一直指向栈顶节点，每次出栈一个节点后，将其重新置为栈顶结点，Pre节点指向上一个访问的节点；
  2. Cur首先指向根节点A，Pre先设为NULL，由于A存在左孩子和右孩子，根据操作3），先将右孩子C入栈，再将左孩子B入栈，Cur改为指向栈顶结点B；
  3. 由于B的也有左孩子和右孩子，根据操作3），将E、D依次入栈，Cur改为指向栈顶结点D；
  4. 由于D没有左孩子，也没有右孩子，根据操作2），直接输出D，并将其出栈，将Pre指向D，Cur指向栈顶结点E，此时输出序列为：D；
  5. 由于E也没有左右孩子，根据操作2），输出E，并将其出栈，将Pre指向E，Cur指向栈顶结点B，此时输出序列为：DE；
  6. 由于B的左右孩子已经被输出，即满足条件Pre==Cur->lchild或Pre==Cur->rchild，根据操作2），输出B，并将其出栈，将Pre指向B，Cur指向栈顶结点C，此时输           出序列为：DEB；
  7. 由于C有左孩子，根据操作3），将其入栈，Cur指向栈顶节点F；
  8. 由于F没有左右孩子，根据操作2），输出F，并将其出栈，将Pre指向F，Cur指向栈顶结点C，此时输出序列为：DEBF；
  9. 由于C的左孩子已经被输出，即满足Pre==Cur->lchild，根据操作2），输出C，并将其出栈，将Pre指向C，Cur指向栈顶结点A，此时输出序列为：DEBFC；
  10. 由于A的左右孩子已经被输出，根据操作2），输出A，并将其出栈，此时输出序列为：DEBFCA；
  11. 此时栈空，遍历结束。
        void beh_traverse(BTree pTree)  
	{  
		PSTACK stack = create_stack();  //创建一个空栈  
		BTree node_pop;          //用来保存出栈的节点  
		BTree pCur;              //定义指针，指向当前节点  
		BTree pPre = NULL;       //定义指针，指向上一各访问的节点  
	  
		//先将树的根节点入栈  
		push_stack(stack,pTree);    
		//直到栈空时，结束循环  
		while(!is_empty(stack))  
		{  
		    //当前节点置为栈顶节点 
			pCur = getTop(stack);   
			
			//如果当前节点没有左右孩子，或者有左孩子或有孩子，但已经被访问输出，  
				//则直接输出该节点，将其出栈，将其设为上一个访问的节点  
			if((pCur->pLchild==NULL && pCur->pRchild==NULL) ||   
				(pPre!=NULL && (pCur->pLchild==pPre || pCur->pRchild==pPre)))  
			{   
				printf("%c ", pCur->data);  
				pop_stack(stack,&node_pop);  
				pPre = pCur;  
			}  
			else  
			{  
				//如果不满足上面两种情况,则将其右孩子左孩子依次入栈  
				if(pCur->pRchild != NULL)  
					push_stack(stack,pCur->pRchild);  
				if(pCur->pLchild != NULL)  
					push_stack(stack,pCur->pLchild);  
			}  
		}  
	}

启福铭远
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
栈实现树的前序, 中序, 后序遍历
Elo的博客
10-25 734
前序遍历: Code: vector<int> inorderTraversal(TreeNode* root) { // 中序遍历. vector<int> retvec; stack<TreeNode*> stk; while (root != NULL || !stk.empty()) { // 注意循环进行的条...
利用栈实现二叉树的后序遍历算法
W895972478的专栏
08-06 4309
二叉树的后序遍历算法是按照左子树->右子树->节点的访问顺序来遍历二叉树的。所以需要将节点依次入栈，然后分别找到他们的左子树和右子树。而且在右子树没有被访问完之前，节点要一直在栈中。所以，当我们访问左子树后根据节点去访问右子树，而当右子树访问完后访问节点退栈，两次访问节点结果却不相同，如下图： 一个是访问节点后去访问右子树，一个是访问节点后退栈访问上一个节点的右子树如果不做任何处理，那么会在
c语言 栈实现二叉树的中序非递归遍历算法
11-30
用递归先序算法建立二叉树。要求通过键盘输入二叉树的先序遍历顺序从而建立一棵二叉树。利用栈实现一棵二叉树的中序非递归遍历。要求显示遍历次序。
二叉树实现思路
weixin_33747129的博客
05-18 244
// 二叉树实现思路 function BinaryTree() { var Node = function (key) { this.key = key; this.left = null; this.right = null; }; var root = null; ...
二叉树的类实现和递归遍历思路
Pichairen
03-18 350
#ifndef BINTREE_H #define BINTREE_H #include<cstdlib> //提供size_t template<class Item>//表示这个是类模板 class binary_tree_node { public: typedef Item value_type; binary_tree_node(const Item&amp...
二叉树的遍历（前、中、后序）递归版和非递归版（用一个栈实现）
qq_45818845的博客
04-06 251
算法刷题笔记——day6 二叉树的遍历 package 树的前中后序遍历栈结构; import java.util.Stack; public class PreInPosTraversal { static class Node { public int value; public Node lChild; public Node rChild; public Node(int value) { thi
C语言实现二叉树遍历的迭代算法
09-04
以上就是C语言实现二叉树遍历的迭代算法，通过这种方式，我们可以高效地遍历二叉树，而无需像递归那样增加调用栈的压力。这对于处理大规模数据或者深度很大的二叉树特别有用。在实际编程中，理解并掌握这些算法对...
基于Java实现的二叉树的创建以及三种遍历.zip
最新发布
11-14
通过学习这个资料包，开发者可以掌握如何在实际项目中使用Java实现二叉树，并有效地进行遍历操作，这对于理解和解决各种算法问题非常有帮助。在进一步的开发工作中，这些基础将为处理复杂的数据结构和算法挑战打下...
详解java实现遍历二叉树的三种情况
08-30
实现中序遍历通常使用递归，但也可以用迭代方式，例如通过栈来实现。以下是中序遍历的伪代码： ``` function inOrderTraversal(node): if node is not null: inOrderTraversal(node.left) visit(node) ...
二叉树遍历问题，总结递归和迭代解法
11-29
}2、迭代实现：迭代方式通常使用栈，与前序遍历不同的是，先将左子节点入栈，再处理右子节点。private static void inOrderTraversal1(TreeNode root) { if (root == null) { return; } Stack<TreeNode> stack = ...
二叉树遍历出栈入栈图
02-28
二叉树递归和非递归遍历出栈入栈图。分析出栈入栈顺序。
实现一个可迭代的栈
li1358159的博客
02-12 540
文章目录范围for循环Iterable可迭代栈实现测试运行 范围for循环 集合类数据类型的基本操作之一就是迭代遍历并处理集合中的每个元素。 C++提供了范围for循环语句实现这个操作（从头到尾依次遍历元素）。 一个可用于范围for循环（可迭代）语句的类必须满足以下条件： (1)实现begin()方法。获取指向第一个元素的迭代器或指针。 (2)实现end()方法。获取指向最后一个元素的下一个元素的迭代器或指针。 (3) begin()和end()的返回值支持++操作。 std::vector<int&
堆栈（Stack）结构在迭代中的运用
Monkeyhou1992的博客
02-16 846
目录： 1. 前言 2. 栈机构的概览 3. 应用案例及分析 4. 局限性 1.前言 前段时间写了几个迭代的脚本，有感而发，于是打算系统的记录一下关于这方面的思考。顺便做一个中二的搬运工~ 迭代算法我们经常会遇到，它本身并不难，通俗讲就是重复反馈过程。无论什么情况，总会有最直接的办法，遍历每一个元素(类似穷举法)。但是当我们对时间复杂度O有所要求时候，就会去想办法加快这一进程的运算效率。下面讲述...
用栈实现迭代求值
shrimper
08-10 200
#include <stdio.h> #include <stdlib.h> #include <math.h> # define maxSize 100 int caF(int m) { int cum=1; int s[maxSize];int top=-1; while(m!=0) { s[++top]=m; m/=3; } while(top!=-1) cum*=s[top--]; return cum; } int factorial(
复习---使用基础语法实现栈及迭代
xiuyuandashen的博客
03-03 142
上图是最最基本的结构，这次我采用数组实现栈。使用数组实现栈，由于java的数组是固定长度的。所以我需要写一个增加长度的方法。然后就是迭代的问题了。使用数组实现栈的话，我们需要写一个迭代器。不过这个迭代器非常容易实现，只需要让其implements Iterator再实现Iterator接口的方法就行。下边来看看源代码吧 import java.util.Iterator; import java...
机试准备 进出栈的迭代 解法
凌风
02-24 2054
题目1547：出入栈 时间限制：1 秒 内存限制：128 兆 特殊判题：否 提交：333 解决：55 题目描述： 给定一个初始为空的栈，和n个操作组成的操作序列，每个操作只可能是出栈或者入栈。 要求在操作序列的执行过程中不会出现非法的操作，即不会在空栈时执行出栈操作，同时保证当操作序列完成后，栈恰好为一个空栈。 求符合条件的操作序列种类
java中堆和栈的区别，递归和迭代的区别
崔洪振367
06-13 904
1. 读取某个文件夹下的文件 　　采用深度优先的方法，遍历文件夹，有文件就进行文件操作。 　　深度优先方法：使用递归实现： private void recursion (Path path) {     FileStatus[] children = fs.listStatus (path);     for(FileStatus child : children){
二叉树前中后序遍历——迭代和栈方式实现
热门推荐
1024
03-08 1万+
二叉树前中后序遍历——迭代和栈方式实现用递归实现三种遍历方式只需改变递归顺序就可以实现任一顺序的遍历。而使用栈方式，则不同情况需要进行不同的考虑。首先，定义一个简单的二叉树节点的数据结构类：class Node {    int val;    Node left;    Node right;    public Node(int val) {        this.val = val;   ...
用栈实现树的三种遍历
m0_46627730的博客
04-18 2465
前言      二叉树三种遍历的算法，可谓是程序猿必须会的一个算法。最近在练习算法也对此研究了一段时间，通过递归，我们其实不难实现三种遍历方式，但通过栈来实现，感觉还是有点意思的。      其中在写中序遍历时发现了要是该树不是二叉树时有点错误，只好不断一遍遍检查思路，所以捣鼓了挺长时间的，真的有点艰辛，归根到底还是自己太菜了。 前期准备 之后需要遍历的树： 定义树： var trees = { v
请用python语言分别实现使用递归和迭代的方式进行遍历二叉树
05-16
递归方式遍历二叉树： ```python class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right # 先序遍历 def preorderTraversal(root: TreeNode) -> List[int]: if not root: return [] res = [] res.append(root.val) res += preorderTraversal(root.left) res += preorderTraversal(root.right) return res # 中序遍历 def inorderTraversal(root: TreeNode) -> List[int]: if not root: return [] res = [] res += inorderTraversal(root.left) res.append(root.val) res += inorderTraversal(root.right) return res # 后序遍历 def postorderTraversal(root: TreeNode) -> List[int]: if not root: return [] res = [] res += postorderTraversal(root.left) res += postorderTraversal(root.right) res.append(root.val) return res ``` 迭代方式遍历二叉树： ```python class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right # 先序遍历 def preorderTraversal(root: TreeNode) -> List[int]: if not root: return [] res = [] stack = [root] while stack: node = stack.pop() res.append(node.val) if node.right: stack.append(node.right) if node.left: stack.append(node.left) return res # 中序遍历 def inorderTraversal(root: TreeNode) -> List[int]: if not root: return [] res = [] stack = [] node = root while stack or node: while node: stack.append(node) node = node.left node = stack.pop() res.append(node.val) node = node.right return res # 后序遍历 def postorderTraversal(root: TreeNode) -> List[int]: if not root: return [] res = [] stack = [root] while stack: node = stack.pop() if node.left: stack.append(node.left) if node.right: stack.append(node.right) res.append(node.val) return res[::-1] ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值