树 ：二叉树（构建，遍历：层次，前序、中序、后序）学习总结

step

第一步：

1，了解应用范围：

简介 
树形结构是一类非常重要的非线性结构，它可以很好地描述客观世界中广泛存在的具有分支关系或层次特性的对象，因此在计算机领域里有着广泛应用，如操作系统中的文件管理、编译程序中的语法结构和数据库系统信息组织形式等。本章将详细讨论这种数据结构，特别是二叉树结构。,

2，了解树结构图 

学习重点 
1.熟练掌握二叉树的结构特性，了解相应的证明方法。
2.熟悉二叉树的各种存储结构的特点及适用范围。
3.熟练掌握二叉树的三种遍历算法。
4.理解二叉树的线索化。
5.熟悉树的各种存储结构及其特点，掌握树和森林与二叉树的转换方法。
6.了解最优树的特性,掌握建立最优树及哈夫曼编码的方法.

树的存储结构采取链表（双向动态）、向量形式。

二叉树的（结点编号存储结构）（链式结构（除本身外，还有 left 和 right 指针域））

1，构建二叉树方法，只能为指定的对象添加子节点，使用递归或循环只能在某一条件下适合。

2，遍历使用递归，代码简洁，但很消耗栈内存，严重时会报StackOverFlowError错误。

层次遍历（就是广度遍历 bfs） ：

new list集合

初始化队列，

树offer进队列，

while（队列不为空）

list.add（peek出树）

poll出树

if 左子树不为空 ，offer进队列

if 右子树不为空 ，offer进队列

return list

递归遍历  ： node 参数不为空，

        算法： 深度搜索（DFS），广度搜索（BFS）

节点的深度/高度：节点层次的最大值。

节点的层次：   A          A的节点层次是1，D 节点的层次是3。

  /   \

    B           C

/

    D

节点的度数：节点有多少个子节点。

叶节点： 无子节点的节点称为叶节点。

package com.Binatrytree;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.List;
import java.util.Queue;

public class BTree<E> {
	
	private BTree left;
	private BTree right;
	private char data;
	private int key;
	static BTree root = null;
	private static int index = 0;
	private List<BTree<E>> nodeList = new ArrayList<BTree<E>>();
	
	public BTree(){}
	public BTree(char data){
		this.data = data;
		left = right = null;
	}
	/**
	 * 为指定节点添加子节点
	 * @param node
	 */
	public void addNode(BTree node){
		if(left == null){
			left = node;
		}
		else{
			right = node;
		}
	}
	/**
	 * 递归插入
	 * data （大于左节点，小于右节点）
	 * @param node
	 * @param data
	 * @return
	 */
	 public static BTree insert(BTree node, char data) {
	  if(node == null) 
	   node = new BTree(data);
	  else{
	   if(" ".equals(data)){
		   return node;
	   }
	   
	   if(node.data > data) 
	    node.left = insert(node.left,data);
	   else
	    node.right = insert(node.right,data);
	   
	  }
	  return node;
	 }
	/**
	 * 数组添加 
	 * @param bt
	 * @param tree
	 * @return
	 */
	public BTree add(BTree bt,char[] tree){
		if(index > tree.length){return bt;}
		if(tree[index] == ' '){return bt;}
		if(tree[index] == '#'){return bt;}
		bt = new BTree(tree[index]);
		index = index * 2+1; //
		bt.left = add(bt.left,tree);
		index++;
		bt.right = add(bt.right,tree);
		index = index / 2 - 1;
		return bt;
	}
	/**
	 * 递归前序遍历
	 * @param btree
	 */
	
	public static void recursiveTravel(BTree btree){
		if(btree == null) return;
		 System.out.println("          [ "+btree.data+"],");
         if(btree.left != null){
                 System.out.println("       /");
         }else{
                 System.out.println("              \\");
         }
		recursiveTravel(btree.left);
		recursiveTravel(btree.right);
		
	}
	  public static int level=0;
      /**
       * 集合层次遍历
       * @param bts
       */
      public static void findNodeByLevel(List<BTree> bts){
       if(bts==null||bts.size()==0){
        return ;
       }
       level++;
       ArrayList<BTree> temp = new ArrayList();
       for(BTree node:bts){
        System.out.println("第"+level+"层:"+node.data);
        if(node.left!=null){
         temp.add(node.left);
        }
        if(node.right!=null){
         temp.add(node.right);
        }
       }
       bts.removeAll(bts);
       findNodeByLevel(temp);
      }
      /**
       * 队列层次遍历
       * @return
       */
	public static List<BTree> BFS(){
		List<BTree> bts = new ArrayList<BTree>();
		Queue<BTree> q = new ArrayDeque<BTree>();
		if(root != null){
			q.offer(root);
		}
		while(!q.isEmpty()){
			bts.add(q.peek());
			BTree b = q.poll();
			if(b.left != null){
			   q.offer(b.left);
			} 
			if(b.right != null){
				q.offer(b.right);
			}
		}
		return bts;
	}
	public String toString(){
		StringBuilder sbl = new StringBuilder();
		sbl.append("[value = ").append(data).append("];");
		return sbl.toString();
	}
	public static void main(String[] args){
		char[] con = {'a','b','c','d','e','f',' ',' ','j',' ','#'};
		/*BTree root = new BTree('0');
		BTree a = new BTree('A');
		BTree b = new BTree('B');
		root.addNode(a);
		a.addNode(b);*/
		for(int i=0;i<con.length;i++){
			root = insert(root,con[i]);
		}
		root = new BTree().add(root,con);
		List<BTree> bts = new ArrayList<BTree>();
		bts.add(root);
		findNodeByLevel(bts);
		recursiveTravel(root);
		/*bts = BFS();
		for(BTree bt:bts){
			System.out.println("  "+bt.data);
		}*/
	}
	
	
	
}