精华内容
下载资源
问答
  • 二叉树非递归遍历

    2018-10-23 11:38:21
    数据结构的代码实现,非递归算法,。
  • 今天小编就为大家分享一篇用Python实现二叉树、二叉树非递归遍历及绘制的例子,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 主要介绍了C++实现二叉树非递归遍历方法实例总结,是算法设计中比较经典的一个遍历算法,需要的朋友可以参考下
  • 二叉树非递归遍历C

    2013-09-18 15:14:41
    C语言实现二叉树非递归遍历,前序、中序、后序、层序遍历的具体实现
  • An inorder binary tree traversal can be implemented in a non-recursive way with a stack. For example, suppose that when a 6-node binary tree (with the keys numbered from 1 to 6) is traversed, the ...
  • 后序遍历先序遍历中序遍历先序DLR中序LDR后序LRD二叉树二叉树遍历 可得二叉树的如下几种次序的遍历 先左后右 先右后左 先序DLR DRL 中序LDR RDL 后序LRD RLD 一般情况采用先左后右的方法来遍历二叉树ABFDGICEHJ...
  • 这个是我自己写的关于二叉树非递归算法的遍历,其中二叉树是用的带三个指针的链表存贮实现的,大家可以参考一下
  • 二叉树 创建与递归遍历 前序遍历 分析 栈的特点为先进和后出 前序遍历的特点为左 根 右 所以需要先将含有左子树的根进行压栈处理 待左子树处理完弹出根节点对右子树进行压栈处理 结合树进行分析 编码 public ...

    在这里插入图片描述

    二叉树 创建与递归遍历

    前序遍历
    分析

    栈的特点为先进和后出

    前序遍历的特点为左 根 右

    所以需要先将含有左子树的根进行压栈处理 待左子树处理完弹出根节点对右子树进行压栈处理

    结合树进行分析

    在这里插入图片描述

    编码
    public static void proOrder(MyTreeNode tree){
    
            if(tree == null) return;
    
            Stack<MyTreeNode> stack = new Stack<>();
    
            MyTreeNode tempNode = tree;
    
            while (tempNode != null || !stack.empty()){
    			// 循环遍历左子树的值
                while (tempNode != null){
                    stack.push(tempNode);
                    tempNode = tempNode.getLeftNode();
                }
                MyTreeNode pop = stack.pop();
                System.out.println(pop.getNum());
    			// 判断当前根是否存在右子树
                if(pop.getRightNode() != null){
                    tempNode = pop.getRightNode();
                }
    
            }
    
        }
    
    中序遍历
    分析

    前序遍历的特点为 根 左 右

    所以需要先将根节点进行压栈 弹出 处理后再对左右子树进行压栈处理

    结合树进行分析

    在这里插入图片描述

    编码
        public static void inOrder(MyTreeNode tree){
    
            if(tree == null) return;
    
            Stack<MyTreeNode> stack = new Stack<>();
            stack.push(tree); // 根节点可以先压栈 进入循环体内就可以开始弹出元素
    
            while (!stack.empty()){
                MyTreeNode pop = stack.pop();
                System.out.println(pop.getNum());
    
                if(pop.getRightNode() != null){
                    stack.push(pop.getRightNode());
                }
    
                if(pop.getLeftNode() != null){
                    stack.push(pop.getLeftNode());
                }
            }
    
        }
    
    后序遍历
    分析

    后序遍历的特点为 左 右 根

    所以需要先将左节点压栈处理 然后是 右节点 最后是根

    结合树进行分析

    在这里插入图片描述

    广度遍历、层级遍历
    分析

    广度遍历基于队列一级一级往下迭代遍历 遵循队列先进先出的特点

    在这里插入图片描述

    编码
      public static void testQueue(MyTreeNode tree) {
            if (tree == null) return;
            LinkedList<MyTreeNode> queue = new LinkedList<>();
    
    
            queue.offer(tree);
            while (!queue.isEmpty()) {
    
                MyTreeNode pop = queue.pop();
                System.out.println(pop.getNum());
    
                if(pop.getLeftNode()!=null){
                    queue.offer(pop.getLeftNode());
                }
    
                if(pop.getRightNode()!=null){
                    queue.offer(pop.getRightNode());
                }
    
    
            }
        }
    

    https://blog.csdn.net/haoren1994/article/details/119277300

    至此 :二叉树的几种遍历已经全部完毕

    展开全文
  • 本篇文章是对二叉树非递归遍历进行了详细的分析介绍,需要的朋友参考下
  • 数据结构课程设计二叉树遍历论文,二叉树非递归遍历
  • C++版二叉树非递归遍历 1.二叉树前序遍历 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right...

    C++版二叉树非递归遍历

    一.二叉树前序遍历

    /**
     * Definition for a binary tree node.
     * struct TreeNode {
     *     int val;
     *     TreeNode *left;
     *     TreeNode *right;
     *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
     * };
     */
    class Solution {
    public:
        vector<int> preorderTraversal(TreeNode* root) {
            stack<TreeNode*>s;
            vector<int>s1;
            TreeNode* cur=root;
            TreeNode* top1;//记录栈定元素
           while(!s.empty()||cur)
           {
               while(cur)//如果左子树存在,用cur标记,把所有的左孩子入栈
               {
                   s1.push_back(cur->val);//把根结点的值放到vector<int>s1中
                   s.push(cur);//把根结点入栈
                   cur=cur->left;//寻找当前根结点的左孩子
               }
               top1=s.top();//拿到最后一个左孩子用top1标记
               s.pop();//因为最后一个左孩子在上一个循环内已经打印了,所以把栈顶元素直接出栈
               cur=top1->right;//进行找右孩子
           }
            return s1;
        }
    };
    

    二.二叉树中序遍历

    /**
     * Definition for a binary tree node.
     * struct TreeNode {
     *     int val;
     *     TreeNode *left;
     *     TreeNode *right;
     *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
     * };
     */
    class Solution {
    public:
        vector<int> inorderTraversal(TreeNode* root) {
            vector<int>ret;
            stack<TreeNode*> s;
            TreeNode* cur = root;
            TreeNode* topp;
            while(cur||!s.empty())
            {
                while(cur)
                {
                    s.push(cur);
                    cur=cur->left;
                }
                topp=s.top();
                s.pop();
                ret.push_back(topp->val);
                cur=topp->right;
            }
            return ret;
        }
    };
    

    三.二叉树后序遍历

    /**
     * Definition for a binary tree node.
     * struct TreeNode {
     *     int val;
     *     TreeNode *left;
     *     TreeNode *right;
     *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
     * };
     */
    class Solution {
    public:
        vector<int> postorderTraversal(TreeNode* root) {
            stack<TreeNode*>s;
    		vector<int>ret;
    		TreeNode* cur = root;
    		TreeNode* top1;//记录栈定元素
    		TreeNode* top2 = nullptr;//用来标记是否已经放到ret中
    		while (cur || !s.empty())
    		{
    			while (cur)//循环一直把左孩子入栈
    			{
    				s.push(cur);
    				cur = cur->left;
    			}
    			top1 = s.top();//当没有左孩子时,用top1取栈顶元素
    			if (top1->right == nullptr || top1->right == top2)//只有当该节点的右孩子为空或右孩子被top2标记,才能把当前根结点放到ret中
    			{
    				ret.push_back(top1->val);
    				s.pop();
    				top2 = top1;//用top2记录top1节点已经放到ret中
                    top1=nullptr;//没必要,但最好加上,防止内存泄漏问题
    			}
    			else
    			{
    				cur = top1->right;
    			}
    		}
    		return ret;
            
        }
    };
    
    展开全文
  • 数据结构非递归先序、中序、后序遍历二叉树,数据结构非递归先序、中序、后序遍历二叉树
  • 二叉树非递归遍历(c语言)

    千次阅读 2020-04-07 23:16:44
    一、在c语言中进行二叉树非递归遍历需要用到栈,而在c语言中没有直接调用栈的接口,所以在实现非递归遍历时需要先实现一个栈,需要用到出栈,入栈,栈顶元素,判断栈是否为空,这四个接口,别的可以不用实现。...

    在这里插入图片描述
    结果如下图:
    在这里插入图片描述
    #号代表NULL,此时没有节点
    一、在c语言中进行二叉树的非递归遍历需要用到栈,而在c语言中没有直接调用栈的接口,所以在实现非递归遍历时需要先实现一个栈,需要用到出栈入栈栈顶元素判断栈是否为空,这四个接口,别的可以不用实现。
    二、 实现栈的接口
    注意:这里栈的数组需要用到的类型时Node 类型的,所以先把二叉树节点Node定义出来才能才能使用Node这个类型

    typedef struct Node//定义树的一个节点
    {
    	struct Node *_left;
    	struct Node *_right;
    	BDataType _data;
    }Node;
    

    进行栈的接口实现

    typedef Node* SDataType;
    typedef struct stack//定义栈
    {
    	SDataType *_array;
    	int _count;//总容量大小
    	int _size;//当前元素大小
    }stack;
    void stackInit(stack *st)//栈的初始化
    {
    	st->_array = (SDataType*)malloc(sizeof(SDataType)*num);
    	st->_count = num;
    	st->_size = 0;
    }
    void stackInsert(stack *st, SDataType value)//入栈
    {
    	if (st->_size == st->_count)//空间已满,需要扩容
    	{
    		st->_array = (SDataType*)realloc(st->_array, sizeof(SDataType)*(2 * st->_count));
    		st->_count = 2 * st->_count;
    	}
    	st->_array[st->_size] = value;
    	st->_size++;
    }
    void stackDel(stack *st)//出栈
    {
    	if (st->_size == 0)
    	{
    		printf("栈以为空,不能出栈!!!\n");
    	}
    	st->_size--;
    }
     SDataType stackTop(stack *st)//获取栈顶元素
    {
    	 return st->_array[st->_size - 1];
    }
    int stackEmpty(stack *st)//判断栈是否为空
    {
    	if (st->_size == 0)
    	{
    		return 1;
    	}
    	return 0;
    }
    

    三、创建一棵树
    可以用前序遍历去创建一棵树
    这里的#号是代表NULL的,不太懂怎样建树的可以先把牛客上的一道题做完之后就会用各种方法去建树了,
    链接在这:https://www.nowcoder.com/practice/4b91205483694f449f94c179883c1fef?tpId=60&&tqId=29483&rp=1&ru=/activity/oj&qru=/ta/tsing-kaoyan/question-ranking

    Node *TreeCreat(BDataType *array, int *pos)//创建一棵树,后面会对这棵树进行各种排序
    {
    	if (array[*pos] != '#')
    	{
    		Node *root = (Node *)malloc(sizeof(Node));
    		root->_data = array[*pos];
    		(*pos)++;
    		root->_left = TreeCreat(array, pos);
    		(*pos)++;
    		root->_right = TreeCreat(array, pos);
    		return root;
    	}
    	else
    	{
    		return NULL;
    	}
    }
    

    四、非递归去实现三种遍历
    1、前序遍历
    先遍历当前节点的最左路径,再遍历最后访问节点的右子树

    void preOrder(Node *root)//前序遍历非递归
    {
    	printf("前序遍历#: ");
    	stack st;
    	stackInit(&st);
    	Node *cur = root;
    	Node *top;
    	while (cur || stackEmpty(&st) != 1)
    	{
    	   //从当前根的位置,一直遍历完最左路径
    		while (cur)
    		{
    			printf("%c ", cur->_data);
    			stackInsert(&st, cur);
    			cur = cur->_left;
    		}
    		//获取栈顶元素
    		top = stackTop(&st);
    		stackDel(&st);
    		//访问右子树
    		cur = top->_right;
    	}
    	printf("\n");
    }
    

    2、中序遍历
    当前节点先压栈不能访问,只有左子树访问完之后,才能访问最后压栈的节点以及他的右子树

    void MidOrder(Node *root)//中序遍历非递归
    {
    	printf("前序遍历#: ");
    	stack st;
    	stackInit(&st);
    	Node *cur = root;
    	Node *top;
    	while (cur || stackEmpty(&st) != 1)
    	{
    		while (cur)
    		{
    			stackInsert(&st, cur);
    			cur = cur->_left;
    		}
    		top = stackTop(&st);
    		stackDel(&st);
    		printf("%c ", top->_data);
    		cur = top->_right;
    	}
    	printf("\n");
    }
    

    3、后序遍历
    后序遍历相对于前两种有点麻烦,看不懂了可以私聊我

    void EndOrder(Node *root)//后序遍历非递归
    {
    	printf("前序遍历#: ");
    	stack st;
    	stackInit(&st);
    	Node *cur = root;
    	Node *top;
    	Node *prev = NULL;
    	while (cur || stackEmpty(&st) != 1)
    	{
    		while (cur)
    		{
    			stackInsert(&st, cur);
    			cur = cur->_left;
    		}
    		top = stackTop(&st);
    		if (top->_right == NULL || top->_right == prev)
    		{
    			printf("%c ", top->_data);
    			stackDel(&st);
    			prev = top;
    		}
    		else
    		{
    			cur = top->_right;
    		}
    	}
    	printf("\n");
    }
    

    代码如下

    #include<stdio.h>
    #include<windows.h>
    #pragma warning(disable:4996)
    //定义一个栈可以实现入栈出栈获取栈顶元素的操作
    #define num 10
    typedef char BDataType;
    typedef struct Node//定义树的一个节点
    {
    	struct Node *_left;
    	struct Node *_right;
    	BDataType _data;
    }Node;
    typedef Node* SDataType;
    typedef struct stack//定义栈
    {
    	SDataType *_array;
    	int _count;//总容量大小
    	int _size;//当前元素大小
    }stack;
    void stackInit(stack *st)//栈的初始化
    {
    	st->_array = (SDataType*)malloc(sizeof(SDataType)*num);
    	st->_count = num;
    	st->_size = 0;
    }
    void stackInsert(stack *st, SDataType value)//入栈
    {
    	if (st->_size == st->_count)//空间已满,需要扩容
    	{
    		st->_array = (SDataType*)realloc(st->_array, sizeof(SDataType)*(2 * st->_count));
    		st->_count = 2 * st->_count;
    	}
    	st->_array[st->_size] = value;
    	st->_size++;
    }
    void stackDel(stack *st)//出栈
    {
    	if (st->_size == 0)
    	{
    		printf("栈以为空,不能出栈!!!\n");
    	}
    	st->_size--;
    }
     SDataType stackTop(stack *st)//获取栈顶元素
    {
    	 return st->_array[st->_size - 1];
    }
    int stackEmpty(stack *st)//判断栈是否为空
    {
    	if (st->_size == 0)
    	{
    		return 1;
    	}
    	return 0;
    }
    //用栈来实现二叉树的非递归的三种遍历方法
    //先创建一个树
    Node *TreeCreat(BDataType *array, int *pos)//创建一棵树,后面会对这棵树进行各种排序
    {
    	if (array[*pos] != '#')
    	{
    		Node *root = (Node *)malloc(sizeof(Node));
    		root->_data = array[*pos];
    		(*pos)++;
    		root->_left = TreeCreat(array, pos);
    		(*pos)++;
    		root->_right = TreeCreat(array, pos);
    		return root;
    	}
    	else
    	{
    		return NULL;
    	}
    }
    //1、前序遍历
    void preOrder(Node *root)//前序遍历非递归
    {
    	printf("前序遍历#: ");
    	stack st;
    	stackInit(&st);
    	Node *cur = root;
    	Node *top;
    	while (cur || stackEmpty(&st) != 1)
    	{
    		while (cur)
    		{
    			printf("%c ", cur->_data);
    			stackInsert(&st, cur);
    			cur = cur->_left;
    		}
    		top = stackTop(&st);
    		stackDel(&st);
    		cur = top->_right;
    	}
    	printf("\n");
    }
    //2、中序遍历
    void MidOrder(Node *root)//中序遍历非递归
    {
    	printf("前序遍历#: ");
    	stack st;
    	stackInit(&st);
    	Node *cur = root;
    	Node *top;
    	while (cur || stackEmpty(&st) != 1)
    	{
    		while (cur)
    		{
    			stackInsert(&st, cur);
    			cur = cur->_left;
    		}
    		top = stackTop(&st);
    		stackDel(&st);
    		printf("%c ", top->_data);
    		cur = top->_right;
    	}
    	printf("\n");
    }
    //3、后序遍历
    void EndOrder(Node *root)//后序遍历非递归
    {
    	printf("前序遍历#: ");
    	stack st;
    	stackInit(&st);
    	Node *cur = root;
    	Node *top;
    	Node *prev = NULL;
    	while (cur || stackEmpty(&st) != 1)
    	{
    		while (cur)
    		{
    			stackInsert(&st, cur);
    			cur = cur->_left;
    		}
    		top = stackTop(&st);
    		if (top->_right == NULL || top->_right == prev)
    		{
    			printf("%c ", top->_data);
    			stackDel(&st);
    			prev = top;
    		}
    		else
    		{
    			cur = top->_right;
    		}
    	}
    	printf("\n");
    }
    int main()
    {
    	BDataType array[100];//定义一个char数组
    	scanf("%s", array);
    	int pos = 0;
    	Node *root = TreeCreat(array, &pos);
    	preOrder(root);//前序遍历
    	MidOrder(root);//中序遍历
    	EndOrder(root);//后序遍历
    	system("pause");
    	return 0;
    }
    
    
    
    
    展开全文
  • 二叉树递归与非递归遍历
  • 一种二叉树非递归遍历算法的C语言实现.pdf
  • 编写程序,用先序递归的方法建立二叉树,建立二叉树后,用中序非递归方法遍历二叉树,并输出遍历序列。
  • 二叉树非递归遍历

    2012-10-20 18:08:47
    二叉树非递归遍历,使用C++实现二叉树非递归遍历,对正在学习算法的同学应该挺有帮助的
  • 二叉树遍历,包括递归以及非递归的源代码,在vc6中可以直接运行,本人亲测!
  • 目录 1. 创建一颗二叉树 2.递归前序遍历二叉树 3.递归中序遍历二叉树 ...对于二叉树非递归 深度优先遍历,使用的都是栈 对于二叉树的层次遍历,使用的是队列 1. 创建一颗二叉树 依据前序遍...

    目录

     

    1. 创建一颗二叉树

    2.递归前序遍历二叉树

    3.递归中序遍历二叉树

    4.递归后序遍历二叉树

    5. 测试递归打印二叉树代码

    6. 非-递归前序遍历二叉树

    7. 非-递归实现中序遍历二叉树

    8. 非 - 递归实现后序遍历【较为复杂的方法】

    9. 非 - 递归实现后序遍历【简单的方法】

    10. 二叉树的层次遍历

    11. 最后:附全部代码:


    对于二叉树的非递归 深度优先遍历,使用的都是栈

    对于二叉树的层次遍历,使用的是队列

     

     

    1. 创建一颗二叉树

    依据前序遍历创建二叉树:,树结构如上图所示

    输入:  ABD##E##C##

    #include <stdio.h>
    #include <stdlib.h>
    
    
    // 二叉树的实现
    
    // 定义 二叉树的 结构体
    typedef struct node{
    	char data;
    	struct node *left;
    	struct node *right;
    }Node, *Tree;
    
    // 依据前序遍历创建二叉树
    // 根左右: ABD##E##C##
    
    Tree create_tree(){
    	Node *root = NULL;
    	char ch;
    	scanf("%c", &ch); // 输入 ABD##E##C##
    
    	if (ch != '#'){
    		root = (Node*)malloc(sizeof(Node));
    		root->data = ch;
    
    		root->left = create_tree(); // 递归创建
    		root->right = create_tree();
    	}
    	else{
    		root = NULL;
    	}
    
    	return root;
    }

     

    2.递归前序遍历二叉树

    // 递归前序遍历二叉树
    void preOrderRec(Tree root){
    	if (root != NULL){
    		printf(" %c - ", root->data);
    		preOrderRec(root->left);
    		preOrderRec(root->right);
    	}
    }

    3.递归中序遍历二叉树

    // 递归中序遍历二叉树
    void inOrderRec(Tree root){
    	if (root != NULL){
    		inOrderRec(root->left);
    		printf(" %c - ", root->data);
    		inOrderRec(root->right);
    	}
    }

    4.递归后序遍历二叉树

    void backOrderRec(Tree root){
    	if (root != NULL){
    		backOrderRec(root->left);
    		backOrderRec(root->right);
    		printf(" %c - ", root->data);
    		
    	}
    }

    5. 测试递归打印二叉树代码

    int main(){
    
    	printf("starting ------ \n");
    
    
    	Tree root = create_tree();
    	printf("递归前序遍历--- \n");
    	preOrderRec(root);
    	printf("\n");
    	printf("递归中序遍历--- \n");
    	inOrderRec(root);
    	printf("\n");
    	printf("递归后序遍历--- \n");
    	backOrderRec(root);
    	printf("\n");
    
    
    
    
    	return 0;
    }

    6. 非-递归前序遍历二叉树

    前序遍历顺序是:根-左-右

    先打印根节点的值,由于栈是先进后出,所以先将 右子树放进去,再将左子树放进去

    // 非-递归前序遍历二叉树
    void preOrderNRec(Tree root){
    	Tree stack[MAXSIZE], node;
    	int k = -1;
    
    	if (root == NULL){
    		printf("tree is empty-- \n");
    		return;
    	}
    	else{
    		k++;
    		// 仿照一个栈
    		stack[k] = root; // 将根节点入栈
    		while (k > -1){
    			//出栈
    			node = stack[k--];
    			printf(" %c - ", node->data);
    
    			// 先把右子树放进去,栈是先进去后出,所以下面的左子树先出
    			if (node->right != NULL){
    				stack[++k] = node->right;
    			}
    			if (node->left != NULL){
    				stack[++k] = node->left;
    			}
    
    		}
    
    	}
    }

    7. 非-递归实现中序遍历二叉树

    中序遍历的非递归方式实现思想是:

    1. 从根结点开始,遍历左孩子同时压栈,当遍历结束,说明当前遍历的结点没有左孩子,

    2. 从栈中取出来调用操作函数,然后访问该结点的右孩子,继续以上重复性的操作。

    // 非-递归实现中序遍历二叉树
    void inOrderNRec(Tree root){
    	Tree stack[MAXSIZE], node;
    	int top = 0;
    	// 判断树是否为空
    	if (root == NULL){
    		printf("tree is empty-- \n");
    		return;
    	}
    	node = root;
    
    	while (node != NULL || top > 0){
    
    		// 将所有的左子树节点入栈
    		while (node != NULL){
    			stack[++top] = node;
    			node = node->left;
    		}
    		//  如果右节点为空的话,执行下列语句
    		node = stack[top--];
    		printf(" %c - ", node->data);
    
    		// 扫描右节点
    		node = node->right;
    	}
    
    }

    8. 非 - 递归实现后序遍历【较为复杂的方法】

    void backOrderNRec(Tree root){
    
    	Node *p = root;
    	Node *stack[MAXSIZE];
    	int num = 0;
    	Node *have_visited = NULL;
    
    	while (NULL != p || num>0)
    	{
    		while (NULL != p)
    		{
    			stack[num++] = p;
    			p = p->left;
    		}
    		p = stack[num - 1];
    		if (NULL == p->right || have_visited == p->right)
    		{
    			printf(" %c - ", p->data);
    			num--;
    			have_visited = p;
    			p = NULL;
    		}
    		else
    		{
    			p = p->right;
    		}
    	}
    	
    }

    9. 非 - 递归实现后序遍历【简单的方法】

    非递归实现后序遍历还是很复杂的,变来变去,指来指去的

    但是,我发现一种简单的方法

    我们知道 后序遍历的顺序为: 

    后序:左->右->根

    那么可以把后序当作:根->右->左,最后再反转回来即可。

    由于我们是使用的栈,所以先保存根节点, 然后先放进去 左节点,再放 进去 右节点

    
    void backOrderNRecSimple(Tree root){
    	Tree stack[MAXSIZE], node;
    	int top = 0;
    	int count = 0;
    	char array[MAXSIZE]; // 使用一个数组来保存数据,方便最后数组的反转
    
    	if (root == NULL){
    		printf("tree is empty-- \n");
    		return;
    	}
    	else{
    		top++;
    		// 仿照一个栈
    		stack[top] = root; // 将根节点入栈
    		while (top > 0){
    			//出栈
    			node = stack[top--];
    			array[count++] = node->data; // 将其保存在一个数组当中
    
    			// 先把右子树放进去,栈是先进去后出,所以下面的左子树先出
    			if (node->left != NULL){
    				stack[++top] = node->left;  // 入栈
    			}
    			if (node->right != NULL){
    				stack[++top] = node->right;
    			}
    
    		}
    
    	}
    	// 反转数组,输出
    	for (int i = count-1; i >= 0; i--){
    		printf(" %c - ", array[i]);
    	}
    
    }

    附上java代码,更为简单:

    ArrayList<Integer> postOrder(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        if (root != null) {
            Stack<TreeNode> stack = new Stack<TreeNode>();
            stack.push(root);
            while (!stack.isEmpty()) {
                TreeNode node = stack.pop();
                list.add(node.val);
                if (node.left != null) {
                    stack.push(node.left);
                }
                if (node.right != null) {
                    stack.push(node.right);
                }
            }
            //反转
            Collections.reverse(list);
        }
        return list;
    }

     

    10. 二叉树的层次遍历

    层次遍历使用的是  队列来实现

    void Level_traversal(Tree root){
    
    	if (root == NULL){
    		printf("tree is empty-- \n");
    		return;
    	}
    
    	Tree stack[MAXSIZE], node;
    	node = root;
    	int front = 0;  // 使用 front, rear模拟队列
    	int rear = 0;
    
    	stack[rear++] = node;
    
    	while (front != rear){
    
    		node = stack[front++]; // 模拟队列,先获取front当前元素,然后在指向 front ++ 位元素
    		printf(" %c - ", node->data);
    		
    		// 左右子树入队列
    		if (node->left != NULL){
    			stack[rear++] = node->left;
    		}
    
    		if (node->right != NULL){
    			stack[rear++] = node->right;
    		}
    	}
    
    }

     

    11. 最后:附全部代码:

    #include <stdio.h>
    #include <stdlib.h>
    
    #define MAXSIZE 100
    
    
    // 二叉树的实现
    
    // 定义 二叉树的 结构体
    typedef struct node{
    	char data;
    	struct node *left;
    	struct node *right;
    }Node, *Tree;
    
    // 依据前序遍历创建二叉树
    // 根左右: ABD##E##C##
    
    Tree create_tree(){
    	Node *root = NULL;
    	char ch;
    	scanf("%c", &ch); // 输入 ABD##E##C##
    
    	if (ch != '#'){
    		root = (Node*)malloc(sizeof(Node));
    		root->data = ch;
    
    		root->left = create_tree(); // 递归创建
    		root->right = create_tree();
    	}
    	else{
    		root = NULL;
    	}
    
    	return root;
    }
    
    
    // 递归前序遍历二叉树
    void preOrderRec(Tree root){
    	if (root != NULL){
    		printf(" %c - ", root->data);
    		preOrderRec(root->left);
    		preOrderRec(root->right);
    	}
    }
    
    // 非-递归前序遍历二叉树
    void preOrderNRec(Tree root){
    	Tree stack[MAXSIZE], node;
    	int top = 0;
    
    	if (root == NULL){
    		printf("tree is empty-- \n");
    		return;
    	}
    	else{
    		top++;
    		// 仿照一个栈
    		stack[top] = root; // 将根节点入栈
    		while (top > 0){
    			//出栈
    			node = stack[top--];
    			printf(" %c - ", node->data);
    
    			// 先把右子树放进去,栈是先进去后出,所以下面的左子树先出
    			if (node->right != NULL){
    				stack[++top] = node->right;  // 入栈
    			}
    			if (node->left != NULL){
    				stack[++top] = node->left;
    			}
    
    		}
    
    	}
    }
    
    
    // 递归中序遍历二叉树
    void inOrderRec(Tree root){
    	if (root != NULL){
    		inOrderRec(root->left);
    		printf(" %c - ", root->data);
    		inOrderRec(root->right);
    	}
    }
    
    // 非-递归实现中序遍历二叉树
    void inOrderNRec(Tree root){
    	Tree stack[MAXSIZE], node;
    	int top = 0;
    	// 判断树是否为空
    	if (root == NULL){
    		printf("tree is empty-- \n");
    		return;
    	}
    	node = root;
    
    	while (node != NULL || top > 0){
    
    		// 将所有的左子树节点入栈
    		while (node != NULL){
    			stack[++top] = node;
    			node = node->left;
    		}
    		//  如果右节点为空的话,执行下列语句
    		node = stack[top--];
    		printf(" %c - ", node->data);
    
    		// 扫描右节点
    		node = node->right;
    	}
    
    }
    
    
    // 递归后序遍历二叉树
    void backOrderRec(Tree root){
    	if (root != NULL){
    		backOrderRec(root->left);
    		backOrderRec(root->right);
    		printf(" %c - ", root->data);
    		
    	}
    }
    
    // 非 - 递归实现后序遍历
    void backOrderNRec(Tree root){
    
    	Node *p = root;
    	Node *stack[MAXSIZE];
    	int num = 0;
    	Node *have_visited = NULL;
    
    	while (NULL != p || num>0)
    	{
    		while (NULL != p)
    		{
    			stack[num++] = p;
    			p = p->left;
    		}
    		p = stack[num - 1];
    		if (NULL == p->right || have_visited == p->right)
    		{
    			printf(" %c - ", p->data);
    			num--;
    			have_visited = p;
    			p = NULL;
    		}
    		else
    		{
    			p = p->right;
    		}
    	}
    	
    }
    
    void backOrderNRecSimple(Tree root){
    	Tree stack[MAXSIZE], node;
    	int top = 0;
    	int count = 0;
    	char array[MAXSIZE]; // 使用一个数组来保存数据,方便最后数组的反转
    
    	if (root == NULL){
    		printf("tree is empty-- \n");
    		return;
    	}
    	else{
    		top++;
    		// 仿照一个栈
    		stack[top] = root; // 将根节点入栈
    		while (top > 0){
    			//出栈
    			node = stack[top--];
    			array[count++] = node->data; // 将其保存在一个数组当中
    
    			// 先把右子树放进去,栈是先进去后出,所以下面的左子树先出
    			if (node->left != NULL){
    				stack[++top] = node->left;  // 入栈
    			}
    			if (node->right != NULL){
    				stack[++top] = node->right;
    			}
    
    		}
    
    	}
    	// 反转数组,输出
    	for (int i = count-1; i >= 0; i--){
    		printf(" %c - ", array[i]);
    	}
    
    }
    
    // 层次遍历,打印出二叉树的值
    void Level_traversal(Tree root){
    
    	if (root == NULL){
    		printf("tree is empty-- \n");
    		return;
    	}
    
    	Tree stack[MAXSIZE], node;
    	node = root;
    	int front = 0;  // 使用 front, rear模拟队列
    	int rear = 0;
    
    	stack[rear++] = node;
    
    	while (front != rear){
    
    		node = stack[front++]; // 模拟队列,先获取front当前元素,然后在指向 front ++ 位元素
    		printf(" %c - ", node->data);
    		
    		// 左右子树入队列
    		if (node->left != NULL){
    			stack[rear++] = node->left;
    		}
    
    		if (node->right != NULL){
    			stack[rear++] = node->right;
    		}
    	}
    
    }
    
    
    int main(){
    
    	printf("starting ------ \n");
    
    
    	Tree root = create_tree();
    	printf("递归前序遍历--- \n");
    	preOrderRec(root);
    	printf("\n");
    	printf("递归中序遍历--- \n");
    	inOrderRec(root);
    	printf("\n");
    	printf("递归后序遍历--- \n");
    	backOrderRec(root);
    	printf("\n");
    	printf("------------------\n");
    
    	printf("非递归实现前序遍历--- \n");
    	preOrderNRec(root);
    	printf("\n");
    
    	printf("非递归实现中序遍历--- \n");
    	inOrderNRec(root);
    	printf("\n");
    
    	printf("非递归实现后序遍历--- \n");
    	backOrderNRec(root);
    	printf("\n");
    
    	printf("非递归实现后序遍历  简单的方法 --- \n");
    	backOrderNRecSimple(root);
    	printf("\n");
    
    	printf("层次遍历 --- \n");
    	Level_traversal(root);
    	printf("\n");
    
    	
    
    	// ABD##E##C##
    
    
    	return 0;
    }
    

     


    项目推荐:

    2000多G的计算机各行业电子资源分享(持续更新)

    2020年微信小程序全栈项目之喵喵交友【附课件和源码】

    Spring Boot开发小而美的个人博客【附课件和源码】

    Java微服务实战296集大型视频-谷粒商城【附代码和课件】

    Java开发微服务畅购商城实战【全357集大项目】-附代码和课件

    最全最详细数据结构与算法视频-【附课件和源码】

    在这里插入图片描述


     

    展开全文
  • 遍历二叉树需要决定对根节点N、左子树L、右子树R的访问顺序(按照先遍历左子树在遍历右子树的原则),常见的遍历次序有先序(NLR)、中序(LNR)、后序(LRN)三种遍历算法,这也是最常见的二叉树遍历算法。...
  • JS二叉树非递归遍历

    2017-09-07 22:01:56
    二叉树的递归遍历很简单就可以实现,二叉树非递归遍历却想不出来?那你可以看看下面的例子。 一个二叉树的例子 var root = { val: 1, left: { val: 2, left: { val: 4, }, right:{ val:5 } }, right: { val: 3, ...
  • 1.建立完全二叉树 2.先序非递归遍历二叉树函数 & 先序递归遍历二叉树验证 3.中序非递归遍历二叉树函数 & 中序递归遍历二叉树验证 4.后序非递归遍历二叉树函数 & 后序递归遍历二叉树验证
  • C语言-数据结构-二叉树的递归遍历和非递归遍历

    千次阅读 多人点赞 2018-08-16 09:05:23
    看了大量网络相关的理论和程序,... 最值得研究的还是后序遍历非递归算法, 当时想了使用flag, 想到了多用一个栈, 想到了很多种方式,最后都以失败告终,经过网络查找, 感谢 https://www.cnblogs.com/rain-lei/p/3...
  • #include"stdio.h" #include"stdlib.h" #define OK 1 #define ERROR 0 #define OVERFLOW -1 typedef char TElemType;...建立二叉树那一段可以运行,到了二叉树遍历的时候程序无法运行自动关闭,麻烦各位了!
  • 二叉树非递归遍历非递归的后序遍历二叉树 //非递归的后续遍历二叉树 void HXprint(Tree *tree){ Stack s = initStack(); //初始化一个下面使用的栈 treeNode *p = tree; //新建一个遍历指针 treeNode *r=NULL;...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 62,857
精华内容 25,142
关键字:

二叉树的非递归遍历