以下哪些是树?三个都不是
结点的度:结点拥有的子树数称为结点的度。度为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);
}
}