以下哪些是树？三个都不是
结点的度：结点拥有的子树数称为结点的度。度为0的结点称为叶子结点或终端结点，度不为0的结点称为非终端结点或分支结点。除根结点以外，分支结点也称为内部结点。树的度是树内各结点的度的最大值。
层次与深度：
有序与无序树：
森林：
存储方式
简单的顺序存储不能满足树的实现
结合顺序存储和链式存储来实现
三种表示方法
1双亲表示法
在每个结点中，附设一个指示器指示其双亲结点到链表中的位置。
这种结构，找父节点容易，但找子树不方便；数据结构为算法做准备，这样做的算法复杂
2孩子表示法
方案1：指向孩子的指针 放在数组里；找孩子好找，找父不好找，数组的大小不好确定，多了浪费空间
方案2：每个节点有个数据域，表明有几个子节点，A有2个，就给两个指针，避免浪费空间
3.最终方案：把每个结点的孩子结点排列起来，以单链表作为存储结构，则n个结点有n个孩子链表，如果是叶子结点则此单链表为空，然后n个头指针又组成一个线性表，采用顺序存储结构，存放在一个一维数组中
A的孩子是1,2 ；B的孩子是3；C的孩子是4,5 找父和找子很容易
ABC之间的关系也可以看出来，B的下标是1 ，说明B是A的子
3孩子兄弟表示法
任意一棵树，它的结点的第一个孩子如果存在就是唯一的，它的右兄弟如果存在也是唯一的。因此，我们设置两个指针，分别指向该结点的第一个孩子和此结点的右兄弟
找孩子简单，找父不好找
二叉树
猜100以内的整数，注意猜的次数不能超过7个，回答者只回答大了还是小了
特殊二叉树
斜树
所有的结点都只有左子树的二叉树叫左斜树。所有结点都是只有右子树的二叉树叫右斜树。这两者统称为斜树；线性表结构其实可以理解为树的一种树表达形式
满二叉树
完全二叉树
不管有没有10 节点，但这个位置要留着。
二叉树的性质
性质1：在二叉树的第i层上至多有2i-1个结点（i>=1）。性质2：深度为k的二叉树至多有2k-1个结点（k>=1）。
性质3：对任何一颗二叉树T，如果其终端结点数为n0,度为2的 结点 数为n2，则n0 = n2+1.
性质4：具有n个结点的完全二叉树深度为[log2n]+1 ([x]表示不 大于 x的最大整数)。
性质5：如果对一颗有n个结点的完全二叉树（其深度为[log2n]+1） 的结点按层序编号（从第1层到第[log2n]+1层，每层从左到 右），对任意一个结点i(1<=i<=n)有：
1）.如果i=1,则结点i是二叉树的根，无双亲；如果i>1,则其双亲是结 点[i/2]
2）.如果2i>n,则结点i无左孩子（结点i为叶子结点）；否则其左孩 子是结点2i。
3）.如果2i+1>n,则结点i无右孩子；否则其右孩子是结点2i+1。
性质3证明：设n为总结点数，n1为度为1的结点数，n2为度为2的结点数,n0为终端结点数
分支线总数=n-1 每个节点都有父线，但根节点没有
分支线总数=n1+2n2 有n1个度为1的节点， 即孩子线为1*n， n2个度为2，即孩子线为 n2*2,，加起来就是总线
二叉树的顺序存储结构
普通树不能用顺序存储，但二叉树可以。。。
完全二叉树
一般二叉树
二叉链表
二叉树的遍历
1.前序遍历
规则是若二叉树为空，则空操作返回，否则先访问跟结点，然后前序遍历根节点左子树，再前序遍历右子树，每个节点都是先遍历左，再右
void ProOrderTraverse(Tree T){
if(T == null){return;
}
printf(“%c”,T-data); //打印根节点
ProOrderTraverse(T->lchild); //左子树放入递归
ProOrderTraverse(T->rchild);//右子树
}
2.中序遍历
规则是若树为空，则空操作返回，否则从根结点开始（注意并不是先访问根结点），中序遍历根结点的左子树，然后是访问根结点，最后中序遍历右子树
void ProOrderTraverse(Tree T){
if(T == null){
return;
}
ProOrderTraverse(T->lchild);
printf(“%c”,T-data);
ProOrderTraverse(T->rchild);
}
3.后序遍历
规则是若树为空，则空操作返回，否则从左到右先叶子后结点的方式遍历访问左右子树，最后是访问根结点
void ProOrderTraverse(Tree T){
if(T == null){
return;
}
ProOrderTraverse(T->lchild);
ProOrderTraverse(T->rchild);
printf(“%c”,T-data);
}
用JAVA写二叉树
public class BinaryTree {
Node root;
//得到树的深度
public Integer getHeight(){
return getHeight(root);
}
private Integer getHeight(Node node){
if(node==null)
return 0;
else{
int left=getHeight(node.getLeftChildTree());
int right=getHeight(node.getRightChildTree());
return left>right?left+1:right+1;//左子树 右子树最深的，再加上父节点本身深度1
}
}
//得到节点数量
public Integer getSize(){
return getSize(root);
};
private Integer getSize(Node node){
if(node==null)
return 0;
else{
int leftSize=getSize(node.getLeftChildTree());
int rightSize=getSize(node.getRightChildTree());
return leftSize+rightSize+1;
}
}
//前序遍历,迭代
public void preOrder(Node node){
if(node==null)
return;
else{
System.out.println("preOrder"+node.getData());
preOrder(node.getLeftChildTree());
preOrder(node.getRightChildTree());
}
}
//中序遍历,迭代
public void midOrder(Node node){
if(node==null)
return;
else{
midOrder(node.getLeftChildTree());
System.out.println("midOrder"+node.getData());
midOrder(node.getRightChildTree());
}
}
//后序遍历,迭代
public void proOrder(Node node){
if(node==null)
return;
else{
proOrder(node.getLeftChildTree());
proOrder(node.getRightChildTree());
System.out.println("proOrder"+node.getData());
}
}
//前序遍历，非迭代,利用栈，要遍历一个节点，就先把它压入，再弹出，输出数据，把此节点的右节点压入，再把左节点压入
public void nonRecOrder(Node node){
if(node==null)
return;
Stack<Node>stack=new Stack<>();
stack.push(root);
while(!stack.isEmpty()){
Node pop = stack.pop();
System.out.println("nonRecOrder:"+pop.getData());
if(pop.getRightChildTree()!=null)//不要把空节点push栈
stack.push(pop.getRightChildTree());
if(pop.getLeftChildTree()!=null)
stack.push(pop.getLeftChildTree());
}
}
/**
* A
* B C
* D E F
*/
public BinaryTree(){
root=new Node("A");
Node nodeB=new Node("B");
Node nodeC=new Node("C");
Node nodeD=new Node("D");
Node nodeE=new Node("E");
Node nodeF=new Node("F");
nodeB.setLeftChildTree(nodeD);
nodeB.setRightChildTree(nodeE);
nodeC.setRightChildTree(nodeF);
root.setLeftChildTree(nodeB);
root.setRightChildTree(nodeC);
}
public class Node<T>{
private Integer index;
private Node leftChildTree;
private Node rightChildTree;
private T data;
public Integer getIndex() {
return index;
}
public void setIndex(Integer index) {
this.index = index;
}
public Node getLeftChildTree() {
return leftChildTree;
}
public void setLeftChildTree(Node leftChildTree) {
this.leftChildTree = leftChildTree;
}
public Node getRightChildTree() {
return rightChildTree;
}
public void setRightChildTree(Node rightChildTree) {
this.rightChildTree = rightChildTree;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
public Node(T data){
this.data=data;
leftChildTree=null;
rightChildTree=null;
}
}
public static void main(String[] args) {
BinaryTree tree=new BinaryTree();
System.out.println("treeHeight"+tree.getHeight());
System.out.println("treeSize"+tree.getSize());
tree.preOrder(tree.root);
tree.midOrder(tree.root);
tree.proOrder(tree.root);
tree.nonRecOrder(tree.root);
}
}