手写二叉树-先序构造(泛型)-层序遍历（Java版）

如题

• 先序构造
  • 数据类型使用了泛型,在后续的更改中,更换数据类型只需要少许的变更代码
• 层序遍历
  • 利用Node类的level属性
• 所有属性的权限全为public ,为了方便先这么写吧,建议还是用private来写.
• 还有个问题,值得注意, 就是先序构造的时候注意传入的root节点是形参, 无论通过"."还是"get"方法得到的属性都是形参;
  • 因此, 要在函数中添加返回体--返回相应修改后的字段,进行覆盖.
    

Node.java

package com.szs;
/**
 * @description 描述二叉树的每个节点的类
 * @author Administrator
 *
 * @param <T> 设置泛型
 */
public class Node<T>{
	//数据data 和 左右儿子 ,level: 层级数
	public Node lChild;
	public Node rChild;
	public T data;
	public int level;
	//两种构造器
	public Node(){
		data = null;
		lChild=null;
		rChild=null;
	}
	
	public Node(T x){
		data = x;
		lChild=new Node();
		rChild=new Node();
	}	
}

BinaryTree.java

package com.szs;

import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Scanner;

/**
 * @description 描述二叉树的每种操作方法的类,创建/
 * @author Administrator
 *
 * @param <T> 设置泛型
 */
public class BinaryTree<T> {
	//二叉树的根节点
	public Node<T> root;
	
	//两种构造器
	//创建一棵以数据元素为根节点的二叉树
	public BinaryTree(T x) {
		this.root = new Node<T>(x);
	}
	//创建一空的二叉树,但需要初始化根节点,相当于C语言中的分配内存空间
	public BinaryTree() {
		//this.root = null;   //错误写法
		this.root = new Node<T>();
	}
	
	/**为先序序列的构建提供数据*/
	public LinkedList<Integer> array;

	//先序构造一棵二叉树, 迭代构造
	@SuppressWarnings("unchecked")
	public <T>  Node<T> preOrderBuild(Node<T> rootNode){
		if(rootNode==null){
			return null;
		}
		
		/*从队首取出一个数据,然后删除*/
		int value = (Integer) array.get(0);
		array.removeFirst();
		
		if(value!=-1){
			//构建当前根节点 , 注意这里的泛型
			rootNode = (Node<T>) new Node<Integer>(value);

			//迭代构建左右子树
			rootNode.lChild = preOrderBuild(rootNode.lChild);
			rootNode.rChild = preOrderBuild(rootNode.rChild);
		}
		return rootNode;
	}
	 
	//层次遍历该树,迭代输出,非递归
	public <T> void levelRetrieve(){
		//建立列表
		List<Node> list = new LinkedList<Node>();
		
		if(this.root!=null){
			this.root.level=0;
			list.add(this.root);
		}
		
		int i=0;
		while(i<list.size()){
			int level = list.get(i).getLevel();
			Node node = list.get(i);
			
			if(node.lChild!=null){
				node.lChild.level = level+1;
				list.add(node.lChild);
			}
			if(node.rChild!=null){
				node.rChild.level = level+1;
				list.add(node.rChild);
			}
			//顺序遍历
			i++;
		}

		//层级输出
		System.out.println("---------层级输出-----------");
		for(int j=0;j<list.size();j++){
			if(list.get(j).data!=null){
				System.out.print(list.get(j).data);
			}
			
			if(j<list.size()-1 && list.get(j).level==list.get(j+1).level){
				System.out.print("\t");
			}else{
				System.out.print("\n");
			}
		}
	}
}

TestBinaryTree.java 主测试二叉树的类

package com.szs;

import java.util.LinkedList;
import java.util.Scanner;

public class TestBinaryTree {
	public static void main(String[] args) {
		
		//构造
		BinaryTree<Integer> binaryTree = new BinaryTree<Integer>(null); 
		
		//先序创建二叉树 , 如下提供了三组简单数据
		//  1 2 -1 -1 3 4 -1 -1 -1
		//  1 2 -1 -1 3 -1 -1
        // 1 2 -1 -1 -1
		init(binaryTree);
		binaryTree.root = binaryTree.preOrderBuild(binaryTree.root);

		//层序
		binaryTree.levelRetrieve();
	}
	/**
	 * 初始化构造二叉树数据的数组
	 * @param binaryTree
	 */
	public static void init(BinaryTree<Integer> binaryTree){
		System.out.println("请输入该二叉树先序构造的数组序列(以单个空格隔开):   ");
		Scanner scanner = new Scanner(System.in);
		String str = scanner.nextLine();
		String[] arrStrings=str.trim().split(" ");
		LinkedList<Integer> intArr = new LinkedList<Integer>();
		for(int i=0;i<arrStrings.length;i++){
			intArr.add( Integer.parseInt( arrStrings[i]));
		}
		binaryTree.array=intArr;
	}
}

先序构造测试及相关输出

请输入该二叉树先序构造的数组序列(以单个空格隔开):   
1 2 -1 -1 3 4 -1 -1 -1
---------层级输出-----------
1
2	3
		4