精华内容
下载资源
问答
  • 多叉树遍历

    2020-06-22 21:28:17
    429. N叉的层序遍历 给定一个 N 叉,返回其节点值的层序遍历。 (即从左到右,逐层遍历)。 返回其层序遍历: [ [1], [3,2,4], [5,6] ] 说明: 的深度不会超过 1000。 的节点总数不会超过 5000。 class ...

    429. N叉树的层序遍历

    给定一个 N 叉树,返回其节点值的层序遍历。 (即从左到右,逐层遍历)。
    img
    返回其层序遍历:

    [
         [1],
         [3,2,4],
         [5,6]
    ]
    

    说明:

    1. 树的深度不会超过 1000
    2. 树的节点总数不会超过 5000
    class Solution {
    public:
        vector<vector<int>> levelOrder(Node* root) {
            //特判
            if(root == nullptr) return {};
            vector<vector<int>> res;
            queue<Node*> qu;
            qu.push(root);
            while(!qu.empty()){
                vector<int> temp;
                //每一层的个数
                int size = qu.size();
                for(int i = 0; i < size; i++){
                    Node* node = qu.front();
                    temp.push_back(qu.front()->val);
                    //遍历队头的孩子节点,如果不为空,加入队列
                    for (auto node : qu.front()->children) {
                        if (node){
                            qu.push(node);
                        }
                    }
                    qu.pop();
                }
                res.push_back(temp);
            }
            return res;
        }
    };
    /*
    // Definition for a Node.
    class Node {
    public:
        int val;
        vector<Node*> children;
    
        Node() {}
    
        Node(int _val) {
            val = _val;
        }
    
        Node(int _val, vector<Node*> _children) {
            val = _val;
            children = _children;
        }
    };
    */
    

    589. N叉树的前序遍历

    难度简单83

    给定一个 N 叉树,返回其节点值的前序遍历

    例如,给定一个 3叉树 :

    img

    返回其前序遍历: [1,3,5,6,2,4]

    1.递归解法

    class Solution {
        vector<int> res;
    public:
        vector<int> preorder(Node* root) {
            if(!root)   return{};
            res.push_back(root->val);
            for(auto p : root->children){
                preorder(p);
            }
            return res;
        }
    };
    

    2.迭代解法

    class Solution {
    public:
        vector<int> preorder(Node* root) {
            if(!root)   return{};	//特判
            
            vector<int> res;
            stack<Node*> st;
            
            st.push(root);
            Node* p;
            
            while(!st.empty()){
                p = st.top();
                st.pop();
                res.push_back(p->val);
                int size = p->children.size();
                for(int i = size-1; i>=0; i--){
                    st.push(p->children[i]);
                }
            }
            return res;
        }
    };
    

    590. N叉树的后序遍历

    给定一个 N 叉树,返回其节点值的后序遍历

    例如,给定一个 3叉树 :

    img

    返回其后序遍历: [5,6,3,2,4,1].

    分析:多叉树的后序遍历,仍然是左->右->根的顺序,只不过这里的左右是从左到右的顺序。N叉树的前序遍历类似, 但子树的入栈顺序为从左到右,最后将数组反转一下

    class Solution {
    public:
        vector<int> postorder(Node* root) {
            vector<int> v;
    
            if(!root) return v;
           
            stack<Node*> s;
            s.push(root);
    
            while(!s.empty()){
                Node* node = s.top();
                v.push_back(node->val);
                s.pop();
    
                //从左到右入栈
                for(int i = 0 ; i < node->children.size(); ++i){
                    if(node->children.at(i)) //非空结点才入栈
                        s.push(node->children.at(i));
                }
            }
    
            //将v反转
            reverse(v.begin(), v.end());
    
            return v;       
        }
    };
    

    另外因为多叉树有多个分叉,因此就没有中序遍历的概念了。

    展开全文
  • 二叉树的顺序存储结构 二叉树的顺序存储结构就是用一维数组存储二叉树中的各个结点,并且结点...(2)中序遍历(LDR),首先遍历左子树,然后访问根结点,最后遍历右子。简记左-根-右。 (3)后序遍历(LRD),...

    二叉树的顺序存储结构

    二叉树的顺序存储结构就是用一维数组存储二叉树中的各个结点,并且结点的存储位置能体现结点之间的逻辑关系。

     

    二叉树的遍历

    二叉树的遍历有三种方式,如下:

    (1)先序遍历(DLR),首先访问根结点,然后遍历左子树,最后遍历右子树。简记根-左-右。

    (2)中序遍历(LDR),首先遍历左子树,然后访问根结点,最后遍历右子树。简记左-根-右。

    (3)后序遍历(LRD),首先遍历左子树,然后遍历右子树,最后访问根结点。简记左-右-根。

    假设dom结构如下:

      <div id="tree">
    
        <div>
    
          <div>
            <div></div>
            <div></div>
          </div>
    
          <div>
            <div></div>
            <div></div>
          </div>
    
        </div>
    
        <div>
    
          <div>
            <div></div>
            <div></div>
          </div>
    
          <div>
            <div></div>
            <div></div>
          </div>
    
        </div>
    
      </div>

    遍历方式:

      var arr = [];
      // 递归先序遍历
      function recurDLR(node) {
        if (!node) {
          return;
        }
        arr.push(node);
        recurDLR(node.firstElementChild);
        recurDLR(node.lastElementChild);
      }
      // 递归中序遍历
      function recurLDR(node) {
        if (!node) {
          return;
        }
        recurLDR(node.firstElementChild);
        arr.push(node);
        recurLDR(node.lastElementChild);
      }
      // 递归后序遍历
      function recurLRD(node) {
        if (!node) {
          return;
        }
        recurLRD(node.firstElementChild);
        recurLRD(node.lastElementChild);
        arr.push(node);   
      }

     

    多叉树结构遍历

      // 递归先序遍历 先遍历子节点 再遍历根节点
      function recurDLR(node) {
        if (!node) {
          return;
        }
        arr.push(node);
        for (let i = 0; i < node.children.length; i++) {
          if (node.children[i].nodeName.toLowerCase() === 'div') {
            recurDLR(node.children[i]);
          }      
        }   
      } 
      // 递归后序遍历 先遍历根节点 再遍历子节点
      function recurLRD(node) {
        if (!node) {
          return;
        }
        for (let i = 0; i < node.children.length; i++) {
          if (node.children[i].nodeName.toLowerCase() === 'div') {
            recurLRD(node.children[i]);
          }
        }
        arr.push(node);
      }
    
      // 层序遍历 从根节点一层一层向下遍历
      // 原理就是利用数组的后进先出 存储dom节点
      function recurLDR(node) {
        var stack = [];
        stack.push(node);
        var del = stack.shift();
        while (del) {    
          for (let i = 0; i < del.children.length; i++) {
            if (del.children[i].nodeName.toLowerCase() === 'div') {
              stack.push(del.children[i]);
            }
          }
          arr.push(del);
          del = stack.shift();
        }        
      }

     

    转载于:https://www.cnblogs.com/gr07/p/7880173.html

    展开全文
  • java 多叉树遍历

    2009-09-06 11:11:43
    接上一篇,昨天一朋友问我java中怎么实现多叉树遍历,想了半天都没想出来,写了二叉的遍历之后,发现多叉也一样的,而且java提供的容器类很方便,比c语言里处理指针方便多了。 我手工构造了一颗多叉树。然...
    [img]http://dl.iteye.com/upload/attachment/143356/ad82215c-4093-336c-9ecd-6eb5ff181fd1.jpg[/img]
    
    接上一篇,昨天一朋友问我java中怎么实现多叉树的遍历,想了半天都没想出来,写了二叉的遍历之后,发现多叉也一样的,而且java提供的容器类很方便,比c语言里处理指针方便多了。
    我手工构造了一颗多叉树。然后再递归遍历。类似于中序遍历吧。
    树的节点类:

    package TestTwo;

    import java.util.ArrayList;
    import java.util.List;

    //多叉树的节点
    public class ManyTreeNode {

    //节点的内容
    private NodeBean data ;
    //节点列表
    private List<ManyTreeNode> childList;

    //构造函数
    public ManyTreeNode(){
    data = new NodeBean();
    childList = new ArrayList<ManyTreeNode>();
    }

    //构造函数 可以指定key的值
    public ManyTreeNode(int key){
    data = new NodeBean();
    data.setKey(key);
    childList = new ArrayList<ManyTreeNode>();
    }

    }

    多叉树类:

    package TestTwo;

    //多叉树
    public class ManyNodeTree {

    //树根
    private ManyTreeNode root;

    //构造函数
    public ManyNodeTree(){
    root = new ManyTreeNode();
    root.getData().setNodeName("root");
    }

    //构造函数
    public ManyNodeTree(int key){
    root = new ManyTreeNode();
    root.getData().setKey(key);
    root.getData().setNodeName("root");
    }


    //遍历多叉树
    public String iteratorTree(ManyTreeNode treeNode){

    StringBuilder sb = new StringBuilder();

    if (treeNode != null) {

    if ("root".equals(treeNode.getData().getNodeName())) {
    sb.append(treeNode.getData().getKey() + ",");
    }

    for (ManyTreeNode index : treeNode.getChildList()) {

    sb.append(index.getData().getKey() + ",");

    if (index.getChildList() != null && index.getChildList().size() > 0 ) {

    sb.append(iteratorTree(index));

    }
    }
    }

    return sb.toString();
    }


    //构造多叉树
    public static ManyNodeTree createTree(){

    //用构造函数指定根节点的值
    ManyNodeTree tree = new ManyNodeTree(60);

    //第一层的节点
    ManyTreeNode node1 = new ManyTreeNode(40);
    ManyTreeNode node2 = new ManyTreeNode(50);
    ManyTreeNode node3 = new ManyTreeNode(30);

    tree.getRoot().getChildList().add(0, node1);
    tree.getRoot().getChildList().add(1, node2);
    tree.getRoot().getChildList().add(2, node3);

    //第二层的节点
    ManyTreeNode node21 = new ManyTreeNode(85);
    ManyTreeNode node22 = new ManyTreeNode(70);
    ManyTreeNode node23 = new ManyTreeNode(15);
    ManyTreeNode node24 = new ManyTreeNode(102);
    ManyTreeNode node25 = new ManyTreeNode(83);
    ManyTreeNode node26 = new ManyTreeNode(9);

    tree.getRoot().getChildList().get(0).getChildList().add(0,node21);
    tree.getRoot().getChildList().get(0).getChildList().add(1,node22);
    tree.getRoot().getChildList().get(0).getChildList().add(2,node23);

    tree.getRoot().getChildList().get(1).getChildList().add(0,node24);
    tree.getRoot().getChildList().get(1).getChildList().add(1,node25);

    tree.getRoot().getChildList().get(2).getChildList().add(0,node26);

    //第二层的节点
    ManyTreeNode node31 = new ManyTreeNode(15);
    ManyTreeNode node32 = new ManyTreeNode(20);
    ManyTreeNode node33 = new ManyTreeNode(100);
    ManyTreeNode node44 = new ManyTreeNode(60);

    tree.getRoot().getChildList().get(0).getChildList().get(0).getChildList().add(0,node31);
    tree.getRoot().getChildList().get(0).getChildList().get(0).getChildList().add(1,node32);
    tree.getRoot().getChildList().get(0).getChildList().get(0).getChildList().add(2,node33);

    tree.getRoot().getChildList().get(0).getChildList().get(2).getChildList().add(0,node44);

    return tree;

    }

    /**
    * @param args
    */
    public static void main(String[] args) {
    ManyNodeTree testTree = ManyNodeTree.createTree();
    String result = testTree.iteratorTree(testTree.getRoot());
    System.out.println(result);
    }

    }

    NodeBean类

    public class NodeBean {

    private int key;
    private String nodeName;

    public String getNodeName() {
    return nodeName;
    }

    public void setNodeName(String nodeName) {
    this.nodeName = nodeName;
    }

    public int getKey() {
    return key;
    }

    public void setKey(int key) {
    this.key = key;
    }
    }

    省略了get,set方法。
    图传上去不怎么清楚。
    遍历的结果:60,40,85,15,20,100,70,15,60,50,102,83,30,9,
    展开全文
  • 递归解法 所有的前序、中序、后序解法都是一个模板,不同仅仅在于list.add(item) 的位置,是在前面,中间,还是后面。 /* // Definition for a Node. class Node { public int val; public List children; public...

    N-ary Tree Preorder Traversal

    Given the root of an n-ary tree, return the preorder traversal of its nodes’ values.

    Nary-Tree input serialization is represented in their level order traversal. Each group of children is separated by the null value (See examples)

    Example 1:
    在这里插入图片描述

    Input: root = [1,null,3,2,4,null,5,6]
    Output: [1,3,5,6,2,4]
    

    Example 2:
    在这里插入图片描述

    Input: root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
    Output: [1,2,3,6,7,11,14,4,8,12,5,9,13,10]
    

    Constraints:

    The number of nodes in the tree is in the range [0, 104].
    0 <= Node.val <= 104
    The height of the n-ary tree is less than or equal to 1000.
     
    

    Follow up: Recursive solution is trivial, could you do it iteratively?

    递归解法

    所有树的前序、中序、后序解法都是一个模板,不同仅仅在于list.add(item) 的位置,是在前面,中间,还是后面。

    /*
    // Definition for a Node.
    class Node {
        public int val;
        public List<Node> children;
    
        public Node() {}
    
        public Node(int _val) {
            val = _val;
        }
    
        public Node(int _val, List<Node> _children) {
            val = _val;
            children = _children;
        }
    };
    */
    
    class Solution {
        public List<Integer> preorder(Node root) {
            List<Integer> list = new ArrayList<Integer>();
            helper(root, list);
            return list;
        }
        
        private void helper(Node root, List<Integer> list) {
            if (root == null) return;
            
            list.add(root.val);
            for (Node node: root.children) {
                helper(node, list);
            }
        }
    }
    
    展开全文
  • 树---多叉树遍历

    千次阅读 2014-11-03 23:35:52
    import java.util.LinkedList; import java.util.Queue; import java.util.Stack;...//多个孩子进行层次遍历 public class manyTrees { public static void main(String[] args) { sk_node b = new sk_no
  • 对于二叉树,树的遍历通常有四种:先序遍历、中序遍历、后序遍历、广度优先遍历。(前三种亦统称深度优先遍历)对于多叉树,树的遍历通常有两种:深度优先遍历、广度优先遍历。 在学习前面三种深度优先遍历之前,...
  • 和前序遍历类似这次我们不引入多叉树的概念(因为你不能判断你在哪个中间不像二叉树,所以不引入多叉树的的中序遍历) 首先定义树的结构 struct TreeNode { int val ; TreeNode *left; TreeNode *right ; ...
  • java 多叉树遍历

    千次阅读 2010-03-23 14:54:00
    java 多叉树的遍历 写了二叉的遍历之后,发现多叉也一样的,而且java提供的容器类很方便,手工构造了一颗多叉树。然后再递归遍历。类似于中序遍历吧。 树的节点类: Java代码 复制代码" onclick="function onclick()...
  • java多叉树遍历

    千次阅读 2010-05-07 20:25:00
    而且java提供的容器类很方便,手工构造了一颗...类似于中序遍历吧。 树的节点类: Java代码 package TestTwo; import java.util.ArrayList; import java.util.List; //多叉树的节点 public class ManyTreeNode { /
  • 最后输出所有结果中字典序最小的 比如说第二组数据 以 0 为根时结果为 bacd 以 1 为根时结果为 cadb 以 2 为根时结果为 badc 以 3 为根时结果为 bacd 所以字典序最小的是 bacd 题解 对于多叉树中序遍历采用DFS,将...
  • 整个文件系统的模型是一个层次结构,就像是一颗多叉树。从最顶层的文件夹依次以树干、树枝的形式进行查找,就可以搜索到最底部的文件目录。 目录层次结构中的每个文件都可以通过在目录层次结构的顶部(根目录)给出...
  • 数据结构 第五章 二叉树 向量和列表无法兼顾查找(静态操作)和插入移动(动态操作),结构可以兼顾
  • javascript实现数据结构: 和二叉树,二叉树的遍历和基本操作 树型结构是一类非常重要的非线性结构。直观地,树型结构是以分支关系定义的层次结构。 在计算机领域中也有着广泛的应用,例如在编译程序中,用来...
  • 首先将根节点入队列,然后检测队列是否为空,如果不为空,将队列出队列,访问出队列的节点,然后将该节点的子节点指针入队列,依次循环下去,直至队列为空,终止循环,从而完成整个多叉树的层次优先遍历
  • 遍历多叉树

    千次阅读 2018-09-29 10:37:33
    ...  beg4 关注 2018.03.22 15:14* 字数 334 阅读 172评论 0喜欢 1 ...随便画一个,写代码遍历它 OK,的结构这么描述 public class TreeNode { private String name; private TreeNo...
  • 二叉树遍历2.1 深度优先遍历先序遍历后序遍历中序遍历 1. 多叉树遍历 图形演示 1.1 深度优先遍历 深度优先遍历:从根节点开始先沿着树的一个枝遍历到叶子节点,再遍历其他的枝。深度优先遍历又分为先序遍历和后序...
  • 遍历

    2013-12-25 15:12:00
    对于二叉树,树的遍历通常有四种:先序遍历、中序遍历、后序遍历、广度优先遍历。(前三种亦统称深度优先遍历)对于多叉树,树的遍历通常有两种:深度优先遍历、广度优先遍历。 二叉树的遍历 深度优先遍历 以下...
  • 遍历 Tranversal

    2013-07-08 13:11:50
    对于二叉树,树的遍历通常有四种:先序遍历、中序遍历、后序遍历、广度优先遍历。(前三种亦统称深度优先遍历)对于多叉树,树的遍历通常有两种:深度优先遍历、广度优先遍历。 深度优先遍历 以下均是...
  • 多叉树(左兄弟右孩子二叉树)的树形显示 下载地址 https://download.csdn.net/download/li_haoren/10336965perorder.txt inorder.txt 分别是对本质的二叉树的前序和中序遍历保存的文件...
  • 多叉树的基本操作(C++实现)

    千次阅读 2020-11-12 00:40:17
    文章目录前言创建多叉树展示多叉树销毁一颗多叉树前序遍历(递归&非递归)递归写法非递归写法后序遍历(递归&非递归)递归写法非递归写法层次遍历计算多叉树的高度计算多叉树叶子节点的个数打印输出根节点到所有...
  • 多叉树

    2021-04-12 20:20:09
    一,多叉树遍历 二叉树https://blog.csdn.net/nameofcsdn/article/details/114459069 1,DFS遍历 力扣429. N叉树的层序遍历 题目: 给定一个 N 叉树,返回其节点值的层序遍历。 (即从左到右,逐层遍历)。 例如...
  • 多叉树 二叉树 每个节点最多拥有两个子节点 每个节点最多有一个父节点 只有一个根节点 遍历 前序遍历 中序遍历 后序遍历 层次遍历 搜索二叉树 左边比根小 右边比根大 查找时间 最优 Ologn ~ On 不太稳定 平衡...
  • 关于遍历,前序,中序,后序,各有3种方法。 递归;迭代;莫里斯 这里进行总结: ①递归总结: 递归只需注意一点,函数调用是小括号不是中括号,preorder(root)√ preorder[root]× 前序 class Solution: def ...
  • 二叉树的中序遍历](https://leetcode-cn.com/problems/binary-tree-inorder-traversal/)[144. 二叉树的前序遍历](https://leetcode-cn.com/problems/binary-tree-preorder-traversal/)145.二叉树的后序遍历589.N叉...
  • 二,多叉树的前,中,后序递归,迭代,层次遍历方法 BFS,DFS
  • 6. N叉遍历

    2021-08-06 13:36:48
    word 很大,你忍一下。可以先让洗衣机工作后再来阅读文章~ ... 中序遍历 : [[左子树], 根, [右子]] 后序遍历 : [[左子树], [右子], 根] 层序遍历 : 按照从上到下,从左到右的顺序,逐层遍历各个节点。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,677
精华内容 670
关键字:

多叉树中序遍历