前序遍历

#include <iostream> #include <stack> #include <queue> using namespace std; struct BitreeNode { int data; struct BitreeNode *lchild, *rchild; }; void InitTreeNode(BitreeNode &t, int data, BitreeNode *lchild, BitreeNode *rchild) { t.data = data; t.lchild = lchild; t.rchild = rchild; } //前序 void PreOrder(BitreeNode *t) { if (t != nullptr) { cout << t->data << " "; PreOrder(t->lchild); PreOrder(t->rchild); } } //中序 void Inorder(BitreeNode *t) { if (t != nullptr) { Inorder(t->lchild); cout << t->data << " "; Inorder(t->rchild); } } //后序 void PostOrder(BitreeNode *t) { if (t != nullptr) { PostOrder

　　二叉树 是一种特殊的树，它具有以下 特点 ： 左子树 与 右子树 ，次序不能颠倒。 　　满二叉树 作为一种特殊的二叉树，它是指：所有的分支节点都存在左子树与右子树，并且所有的叶子节点都在同一层上。其 特点 有： 2 h 1 h h 为树的深度。 　　　 h h ，除第 h h 层外，其它各层 ( 1 ～ h 1 ) h h 层所有的结点都连续集中在最左边，这就是 完全二叉树 。其具有以下 特点 ： 　　 二、二叉树的相关性质 i i 层上，至多有 2 i 1 ( i ≥ 1 ) (i≥1) 。 h h 的二叉树上最多有 2 h 1 （ k ≥ 1 ) （k≥1) 。 n 0 n0 ，度数为 2 2 的节点个数为 n 2 n2 ，则有: n 0 = n 2 + 1 n0=n2+1 。 n n 个的结点的完全二叉树的深度为 log 2 n + 1 n n 个节点的完全二叉树的节点按层次序编号，对任一层的节点 i ， （ 1 ≥ i ≥ n ） i，（1≥i≥n） 有： i = 1 i=1 ，则节点是二叉树的根，无双亲，如果 i > 1 i>1 ，则其双亲节点为 i / 2 2 i > n 2i>n 那么节点i没有左孩子，否则其左孩子为 2 i 2i 。 2 i + 1 > n 2i+1>n 那么节点没有右孩子，否则右孩子为 2 i + 1 2i+1 。 三、二叉树的数据结构

二叉树层次遍历 //思路 特殊情况 ，根节点为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 ?

二叉树创建： 　　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);

/* 给定一个二叉树，返回它的 前序 遍历。 示例: 输入: [1,null,2,3] 1 \ 2 / 3 输出: [1,2,3] 进阶: 递归算法很简单，你可以通过迭代算法完成吗？ 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/binary-tree-preorder-traversal 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 */ 方法一：常规递归方式,用C语言实现(根左右) 代码实现： /** * Note: The returned array must be malloced, assume caller calls free(). */ int length = 0 ; int* ret_val = NULL ; void add_ele(int val) { length++; ret_val = (int*)realloc(ret_val,sizeof(int)*length); /*追加动态空间*/ ret_val[length-1] = val; } void __preOrder(struct TreeNode* node) { if(node==NULL) { return; } add_ele ( node->val ); __preOrder ( node->left

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

描述 给出一棵二叉树，返回其节点值的前序遍历。 首个数据为根节点，后面接着是其左儿子和右儿子节点值，"#"表示不存在该子节点。 节点数量不超过20 您在真实的面试中是否遇到过这个题？ 样例 样例 1: 输入：{1,2,3} 输出：[1,2,3] 解释： 1 / 2 3 它将被序列化为{1,2,3} 前序遍历 样例 2: 输入：{1,#,2,3} 输出：[1,2,3] 解释： 1 2 / 3 它将被序列化为{1,#,2,3} 前序遍历 /** * Definition of TreeNode: * public class TreeNode { * public int val; * public TreeNode left, right; * public TreeNode(int val) { * this.val = val; * this.left = this.right = null; * } * } */ public class Solution { /** * @param root: A Tree * @return: Preorder in ArrayList which contains node values. */ public List<Integer> preorderTraversal(TreeNode root) { // write your

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

二叉树（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（[