JAVA按层级遍历二叉树

/**
 * @author cj 2017年7月14日下午1:14:31
 */
package com.yuanye.algorithm;

import java.util.LinkedList;
import java.util.List;

public class BinaryTree {
//    private static List<Node> currentLevelNodes=new ArrayList<>();
//    private static List<Node> nextLevelNodes=new ArrayList<>();
    private static List<Node> nodeList=new LinkedList<>();

    public static void main(String[] args) {
        Node rootNode=new Node();
        rootNode.setValue(88);
        generateTree(rootNode,5,0);
        printTree(rootNode);
    }
    public static void generateTree(Node parentNode,int depth,int currentDepth){
        if(currentDepth>depth-1)
            return;
        Node leftNode=new Node();
        leftNode.setValue(6000+currentDepth);
        Node rightNode=new Node();
        rightNode.setValue(9000+currentDepth);
        parentNode.setLeftNode(leftNode);
        parentNode.setRightNode(rightNode);
        generateTree(leftNode,depth,currentDepth+1);
        generateTree(rightNode,depth,currentDepth+1);
    }
    public static void printTree(Node rootNode){
        System.out.println(rootNode.getValue());
        Node leftNode=rootNode.getLeftNode();
        Node rightNode=rootNode.getRightNode();
        if(leftNode!=null){
            nodeList.add(leftNode);
        }
        if(rightNode!=null){
            nodeList.add(rightNode);
        }
//        if(currentLevelNodes.size()==0){
//            currentLevelNodes.addAll(nextLevelNodes);
//            nextLevelNodes.removeAll(nextLevelNodes);
//        }
//        if(currentLevelNodes.size()>0){
//            Node nextNode=currentLevelNodes.get(0);
//            currentLevelNodes.remove(0);
//            printTree(nextNode);
//        }
        if(nodeList.size()>0){
            Node nextNode=nodeList.get(0);
            nodeList.remove(0);
            printTree(nextNode);
        }
    }
}
class Node{
    private int value;
    private Node leftNode;
    private Node rightNode;

    public int getValue() {
        return value;
    }
    public void setValue(int value) {
        this.value = value;
    }
    public Node getLeftNode() {
        return leftNode;
    }
    public void setLeftNode(Node leftNode) {
        this.leftNode = leftNode;
    }
    public Node getRightNode() {
        return rightNode;
    }
    public void setRightNode(Node rightNode) {
        this.rightNode = rightNode;
    }
    @Override
    public String toString() {
        return "Node [value=" + value + ", leftNode=" + leftNode + ", rightNode=" + rightNode + "]";
    }
}
时间: 2024-11-01 19:38:46

JAVA按层级遍历二叉树的相关文章

数据结构Java版之遍历二叉树(六)

二叉树是我们在程序中用的最多的一种树(个人观点).最简单的一个二叉树是由一个根节点,两个子节点(一左一右成左右孩子节点)组成.二叉树是数组和链表的结合,即包含了数组的快速查找优点,又包含了链表的快速添加删除的优点.熟练掌握二叉树的遍历方法是很有必要的.下面来介绍一下基于二叉树的四种遍历方式. 下面我们以一个棵简单的二叉树为例来说明四种遍历: 创建树节点类: //树节点 class TreeNode { public char val; public TreeNode left; public T

java构造和遍历二叉树

[分析] 二叉树的结构:根节点.左子树.右子树.其中左子树的值必须小于根节点,右子树的值必须大于根节点.构造这种树结构,就是创建一个类,并提供一个方法,当给定一个值时,它能够自动创建节点并自动挂到二叉树的合适位置. 二叉树的遍历:分为先序遍历.中序遍历和后序遍历.先序遍历:根.左.右. 中需遍历:左.根.右. 后续遍历:左.右.根. 二叉树的应用:加密解密.文件压缩.快速查询.快速遍历等. 1.构造二叉树的节点对象,并提供插入方法. 1 private int data; //存放节点数据 2

JAVA递归、非递归遍历二叉树(转)

原文链接: JAVA递归.非递归遍历二叉树 import java.util.Stack; import java.util.HashMap; public class BinTree { private char date; private BinTree lchild; private BinTree rchild; public BinTree(char c) { date = c; } // 先序遍历递归 public static void preOrder(BinTree t) {

Java递归方法遍历二叉树的代码

将内容过程中经常用的内容做个记录,如下内容内容是关于Java递归方法遍历二叉树的内容. package com.wzs; public class TestBinaryTree { public static void main(String[] args) { Node<String> g = new Node<String>("G", null, null); Node<String> e = new Node<String>(&qu

leetcode(144,94,145,102)中迭代版的二叉树的前、中、后、层级遍历

//前序遍历class Solution{ public: vector<int> preorderTraversal(TreeNode *root){ vector<int> res; stack<TreeNode*> s; TreeNode* p = root; if(!p) return res; s.push(p); while(!s.empty()){ p = s.top(); s.pop(); res.push_back(p->val); if(p-&

java创建二叉树并递归遍历二叉树

二叉树类代码: package binarytree; import linkqueue.LinkQueue; public class BinaryTree { class Node { public Object data; public Node lchild; public Node rchild; public Node(Object data) { this.data = data; this.lchild = null; this.rchild = null; } } //根节点

非递归遍历二叉树Java实现

2018-10-03 20:16:53 非递归遍历二叉树是使用堆栈来进行保存,个人推荐使用双while结构,完全按照遍历顺序来进行堆栈的操作,当然在前序和后序的遍历过程中还有其他的压栈流程. 一.Binary Tree Preorder Traversal 问题描述: 问题求解: 先序遍历就是在第一次访问到节点的时候将其值进行打印,然后递归打印其左子树,最后递归打印其右子树. 解法一.双while public List<Integer> preorderTraversal(TreeNode

网易:层次遍历二叉树

题目描述 分层遍历二叉树 用java实现树结构,分层遍历二叉树.给定一棵二叉树,要求按分层遍历该二叉树,即从上到下按层次访问该二叉树(每一层单独输出一行),每一层要求访问的顺序为从左到右,再按照相同规则从下至上遍历一遍,树节点定义如下 class Node { int data; Node left; Node right; } 输入描述 图: __1__ / __2__ 3__ / \ 4 __5__ 6 7 8 上面的输入为:1, 2, 3, 4, 5, 0, 6, 0, 0, 7, 8注:

java递归方法建立搜索二叉树,具备查找关键字,插入新节点功能

二叉排序树的定义: 二叉排序树满足以下三个性质(BST性质): <1>若它的左子树非空,则左子树上所有节点的值均小于根节点的值 <2>若它的右子树非空,则右子树上所有节点的值均大于根节点的值 <3>左,右子树本身又各是一棵二叉排序树 根据二叉排序树的BST性质,可以说二叉排序树每个节点上的值(或称关键字)都是唯一的,并且二叉排序树以中序遍历输出的结果必然是一个有序的递增序列. 如下图所示: 用递归方法建立二叉排序树,减少了繁复的比较程序,效率较高.只需要知道每个节点的值