中序遍历

二叉树层次遍历 //思路 特殊情况 ，根节点为null，深度为0，return 0 借助队列，队列储存每一层的所有节点， 先保存数组长度，用于控制依次遍历循环――遍历每一个节点保存值，该节点的所有子结点从队尾入队，访问过的节点从头出队 注意――需要先把width存下来，用于for循环的结束标志，因为for循环里面直接操作了queue，不能去都不敢动态获取 队列初始值为root，对每一层都要进行上述遍历――while循环控制，队列空代表叶节点这一层遍历完成，此时遍历结束，退出循环 每次循环开始前初始化一个curNodes储存该层所有节点，每次循环结束，将curNodes压入result var levelOrder = function(root) { if (root === null) return []; //空树 var result = [], queue = [root]; while (queue.length) { let width = queue.length; //需要先把width存下来，用于for循环，for循环里面直接操作了数组 let curNodes = []; for (let i = 0; i < width; i++) { let node = queue.shift(); curNodes.push(node.val); node.left ?

定义二叉树结点、栈、队列 typedef struct TNode { // 结点 int data ; struct TNode * lchild , * rchild ; } TNode , * BiTree ; typedef struct queen_node { // 循环队列 TNode * nodes [ 100 ] ; int front ; //指向队头元素的前一个（为了判别队空和判别队满） int size ; //指向队尾元素 int rear ; // 尾进头出 } queen_node , * Queen ; typedef struct stack_node { // 栈 头进头出。 TNode * nodes [ 100 ] ; int top ; // top=-1为空栈 int size ; } * Stack ; Stack init_Stack ( ) { // 初始化栈 Stack stack = ( Stack ) malloc ( sizeof ( stack_node ) ) ; stack -> top = - 1 ; stack -> size = 100 ; return stack ; } void push_stack ( Stack S , TNode * p ) { //入s栈 if ( S -> top < S ->

二叉树创建： 　　1.创建树的结点TreeNode，包含结点的编号no，结点的名字name，左子树left，右子树right， 　　 二叉树遍历： 　　1，先序遍历：先输出根节点，再递归左子树，然后递归右子树 　　2，中序遍历：先递归左子树，然后输入根节点，再递归右子树 　　3，后序遍历：先递归左子树，再递归右子树，然后输出根节点 实验： 　　创建如下的二叉树并遍历 　　 代码 package Tree; public class BinaryTreeDemo { public static void main(String[] args) { BinaryTree binaryTree = new BinaryTree(); //创建结点 TreeNode root = new TreeNode(1,"宋江"); TreeNode treeNode2 = new TreeNode(2,"林冲"); TreeNode treeNode3 = new TreeNode(3,"吴用"); TreeNode treeNode4 = new TreeNode(4,"关胜"); TreeNode treeNode5 = new TreeNode(5,"卢俊义"); //创建树结构 root.setLeft(treeNode2); root.setRight(treeNode3);

2019独角兽企业重金招聘Python工程师标准>>> /** * @title: 二叉树遍历,求深度 * @author : Jay Chang * @version : ver 1.0 * @date : 2009.7.25 */ import java.util.Scanner; /*二叉树的结点的定义*/ class BiTreeNode { private String nodeName; private int value; /*没有解决好lChild,rChild两个属性的封装，存在些问题，不知道为什么,有待改进*/ public BiTreeNode lChild; public BiTreeNode rChild; public BiTreeNode(){} /*创建结点对象的构造器*/ public BiTreeNode(String nodeName,int value) { this.nodeName=nodeName; this.value=value; this.lChild=null; this.rChild=null; } /*setName,getName,setValue,getValue,是对结点两个属性的封装 */ public void setName(String nodeName) { this.nodeName=nodeName; }

1. 前序遍历 （1）递归写法 public List<Integer> preorderTraversal(TreeNode root) { List<Integer> re = new ArrayList<Integer>(); pre(root,re); return re; } private void pre(TreeNode root,List<Integer> re){ if(null == root){ return; } re.add(root.val); pre(root.left,re); pre(root.right,re); } （2）非递归写法 public List<Integer> preorderTraversal(TreeNode root) { List<Integer> res = new ArrayList<Integer>(); Stack<TreeNode> stack = new Stack<TreeNode>(); if(null!= root){ stack.push(root); } while(!stack.isEmpty()){ TreeNode cur = stack.pop(); res.add(cur.val); if(null!= cur.right){ stack.push(cur.right); } if

对二叉树的遍历进行实现的算法： （1）定义二叉树的二叉链表存储结构。 （2）编写建立一棵二叉树算法。 （3）编写中序遍历二叉树算法。 （4）编写后序遍历二叉树算法。 （5）编写算法主程序。 （6）调试运行，记录结果。 编写头文件 Bitree.h #include<stdio.h> #include<stdlib.h> #include<malloc.h> #define OK 1 #define OVERFLOW -2 #define INFEASIBLE -1 #define TRUE 1 #define FALSE 0 #define ERROR 0 #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 typedef char TElemType; typedef int Status; //二叉树的二叉链表存储表示 typedef struct BiTNode { TElemType data; struct BiTNode * lchild,* rchild; } BiTNode,* BiTree; //创建二叉树 Status CreatBiTree(BiTree &T){ char ch; scanf("%c",&ch); if (ch == '#') T=NULL; else { if (!(T=(BiTree

二叉树是树的特殊一种，具有如下特点：1、每个结点最多有两颗子树，结点的度最大为2。2、左子树和右子树是有顺序的，次序不能颠倒。3、即使某结点只有一个子树，也要区分左右子树。 # include < bits / stdc ++. h > # include <queue> # include <iostream> # include <stdio.h> # include <algorithm> # include <string> # define n 6 # define m 2 * n - 1 # define maxval 1 # define maxsize 1024 typedef struct node { char data ; struct node * lc , * rc ; } bitree ; bitree * creatree ( ) { char ch ; bitree * Q [ maxsize ] ; int ffront , rrear ; //表示队头和队尾，建立一个队列储存两个孩子还没有储存完的结点 bitree * root , * s ; //根结点指针和中间变量 root = NULL ; ffront = 1 ; rrear = 0 ; printf ( "请输入二叉树的各结点，@表示虚结点，#表示结束：\n" ) ; scanf (

这篇博文主要是研究二叉树遍历的递归与非递归算法，有兴趣的小伙伴可以了解下！ 二叉树的递归遍历（深度优先遍历） 先来张图，看看各结点遍历时的情况： 二叉树深度优先遍历总结（ 分别为第一次，第二次，第三次进入某个结点 ）： 先序遍历：先访问根结点，然后先序遍历左子树，最后先序遍历右子树； 根->左->右 中序遍历：先中序遍历左子树，然后访问根结点，最后中序遍历右子树； 左->根->右 后续遍历：先后序遍历左子树，然后后序遍历右子树，最后访问根结点； 左->右->根 递归遍历内部有系统栈，其作用： 1.保护现场（类似存档） 2.恢复现场（类似读档） 递归遍历代码比较简单，先、中、后序遍历递归代码基本相似，总代码： void r(BTNode *p) { if (p != NULL) { //第一次进入-先序 r(p->lchild); //第二次进入-中序 r(p->rchild); //第三次进入-后序 } } 先序遍历递归函数： void r(BTNode *p) { if (p != NULL) { visit(p); r(p->lChild); r(p->rChild); } } 二叉树的非递归遍历（深度优先遍历） 须知：需要自定制辅助栈 1.先序遍历非递归: 1).利用辅助栈将根节点入栈，出栈操作，访问该节点，将其右、左孩子分别入栈（每次访问节点后，对其左、右孩子需要做一个检测

class Node: def __init__(self, val): self.value = val self.lchild = None self.rchild = None class Tree: def __init__(self): self.root = None def add(self, val): node = Node(val) if self.root is None: self.root = node return queue = [self.root] while queue != []: cur_node = queue.pop(0) if cur_node.lchild is None: cur_node.lchild = node return else: queue.append(cur_node.lchild) if cur_node.rchild is None: cur_node.rchild = node return else: queue.append(cur_node.rchild) # 层次遍历 def breadth_travel(self): if self.root is None: return else: queue = [self.root] while queue != []: cur_node = queue

class node(object): def init (self,data=None,left=None,right=None): self.data=data self.left=left self.right=right #深度 def depth(tree): if tree==None: return 0 left,right=depth(tree.left),depth(tree.right) return max(left,right)+1 #前序遍历 def pre_order(tree): if tree==None: return print tree.data pre_order(tree.left) pre_order(tree.right) #中序遍历 def mid_order(tree): if tree==None: return mid_order(tree.left) print tree.data mid_order(tree.right) #后序遍历 def post_order(tree): if tree==None: return post_order(tree.left) post_order(tree.right) print tree.data #层次遍历 def level_order(tree): if tree==None