后序遍历

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.恢复现场（类似读档） 递归遍历代码比较简单，先、中、后序遍历递归代码基本相似，总代码： 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

二叉树定义这里不再赘述。 我这里有个二叉树： var tree = { "id": 0, "name": "root", "left": { "id": 1, "name": "Simon", "left": { "id": 3, "name": "Carl", "left": { "id": 7, "name": "Lee", "left": { "id": 11, "name": "Fate" } }, "right": { "id": 8, "name": "Annie", "left": { "id": 12, "name": "Saber" } } }, "right": { "id": 4, "name": "Tony", "left": { "id": 9, "name": "Candy" } } }, "right": { "id": 2, "name": "right", "left": { "id": 5, "name": "Carl", }, "right": { "id": 6, "name": "Carl", "right": { "id": 10, "name": "Kai" } } } }; 1.使用前序遍历，并将所有name输出。 function getListWithDLR(node) { if(node){ console.log(node

import java . util . ArrayList ; import java . util . List ; import java . util . Stack ; public class PostOrder { //后序遍历，非递归 public static void postOrderNoR ( Node root ) { Stack < Node > stack = new Stack <>(); Node cur = root ; Node last = null ; //上一次被三次完整经过的结点 while (! stack . empty () || cur != null ) { while ( cur != null ) { stack . push ( cur ); cur = cur . left ; } Node top = stack . peek (); //取栈顶元素，不删除 if ( top . right == null || top . right == last ) { stack . pop (); //取栈顶元素，删除 System . out . println ( top . value ); last = top ; } else { cur = top . right ; } } } //后序递归遍历1

二叉树（Binary Tree）是n（n >= 0）个节点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根节点和两颗互不相交的，分别称为根节点的左子树和右子树的二叉树组成。 二叉嘛，也就是每个节点最多有两个分支。 图示： 二叉树具有五种基本形态： 1.空二叉树 2.只有一个根节点 3.根节点只有左子树 4.根节点只有右子树 5.根节点既有左子树又有右子树 特殊的二叉树： 1.斜树（只有左子树的称为左斜树，只有右子树的称为右斜树，两者统称为斜树） 2.满二叉树（所有的分支节点都存在左子树和右子树，并且所得树叶都在同一层上） 3.完全二叉树的特征： 1.叶子结点只能出现在最下两层 2.最下层的叶子一定集中在左部连续位置 3.倒数二层，若有叶子结点，一定都在右部连续位置 4.如果节点度为1（这里的度与离散数学中的度不一样，这里的度是指节点所拥有的子树数），则该节点只有左孩子，即不存在只有右子树的情况 5.同样节点数的二叉树，完全二叉树的深度最小 二叉树的性质： 性质1：在二叉树的第i层上至多有2^（i - 1）个节点（i >= 1） 性质2：深度为k的二叉树至多有2^k - 1个节点（k >= 1） 性质3：对任何一颗二叉树T，如果其终端节点数为n0，度为2的节点数为n2，则n0 = n2 + 1 性质4：具有n个节点的完全二叉树的深度为[log2n] + 1（[

此篇为学习完 《数据结构与算法之美》 后，在 LeetCode 刷题的汇总目录，方便大家查找（Ctrl+F ind ），一起刷题，一起PK交流！Updated on 2019.12.2 刷题可以按照 不同的专题 进行，便于加强某个知识点的理解。 我的 LeetCode 主页 我的 GitHub 主页 已解决 519/1185 - 简单 281 中等 208 困难 30 2019.7.24 - 2019.11.9，108天做了400道题 2019.11.9 - 2019.11.24， AC+100道，4个月共计500道题 参赛记录 LeetCode 2019 力扣杯全国秋季编程大赛 ​ 已解题目，部分太简单的没有列出 LeetCode 1. 两数之和（哈希） LeetCode 2. 两数相加（单链表反转） LeetCode 3. 无重复字符的最长子串（滑动窗口+哈希） LeetCode 4. 寻找两个有序数组的中位数（二分查找，难） LeetCode 7. 整数反转 LeetCode 8. 字符串转换整数 (atoi) LeetCode 9. 回文数 LeetCode 11. 盛最多水的容器（双指针） LeetCode 14. 最长公共前缀 LeetCode 15. 三数之和 LeetCode 16. 最接近的三数之和（固定左端+滑动窗口） LeetCode 17.