高级数据结构-树论二叉树

**# 高级数据结构-树论基础

概念

几个重要的术语

1.结点：树里面的元素
2.父子关系：结点之间相连的边
3.子树：当结点大于1时，其余结点分为的互不相交的集合称为子树
4.度：一个结点拥有子树的数量称为结点的度
5.叶子：度为0的结点
6.孩子：结点的子树的根称为孩子结点
7.双亲：和孩子结点对应
8.兄弟：同一个双亲结点
9.森林：由N个互不相交的树构成森林
10.结点的高度：结点到叶子结点的最长路径
11.结点的深度：根结点到该结点的边个数
12.结点的层数：结点的深度加1
13.树的高度：根结点的高度

二叉树：

平衡二叉树，二叉查找树，红黑树，完全二叉树（堆排序），满二叉树

许多经典的算法和数据结构都是通过二叉树发展来的

Binary Tree：一种特殊的树形结构，每个结点至多有两棵子树
在二叉树的第N层上至多有2^（N-1）个结点，N层二叉树最多有 2^N-1个结点个数
满二叉树：除叶子结点外，其他结点都有左右两个子节点。
完全二叉树：除最后一层外，其他的结点个数必须达到最大，并且最后一层结点都连续靠左排列

思考：为什么要分满二叉树和完全二叉树？

在用数组进行树的操作时，如下图，巧妙利用数组的下标，完全二叉树不存在存储为空的情况

二叉树的遍历

四种遍历方式：
重要口诀：根结点输出（遇到根结点就输出）
前序遍历：根 左 右 ABCDEFGHK
中序遍历：左 根 右 BDCAEHGKF
后序遍历：左 右 根 DCBHKGFEA
层次遍历：一层一层的进行遍历 ABECFDGHK

代码实现遍历

package Tree;

import java.util.LinkedList;

//二叉树数据结构的定义
class MyTreeNode{  //链式结构
	private char data ;
	private MyTreeNode left;
	private MyTreeNode right;
	public MyTreeNode(char data, MyTreeNode left, MyTreeNode right) {
		super();
		this.setData(data);
		this.setLeft(left);
		this.setRight(right);
	}
	public char getData() {
		return data;
	}
	public void setData(char data) {
		this.data = data;
	}
	public MyTreeNode getLeft() {
		return left;
	}
	public void setLeft(MyTreeNode left) {
		this.left = left;
	}
	public MyTreeNode getRight() {
		return right;
	}
	public void setRight(MyTreeNode right) {
		this.right = right;
	}
	
}
public class BinaryTree {
	
	public static void print(MyTreeNode node){//打印
		System.out.print(node.getData());
	}
	public void pre(MyTreeNode root) {  //前序遍历： 根(输出) 左 右   因为每个结点访问了两次时间复杂度O(2*n)=>O(n)
		print(root);
		if(root.getLeft()!=null){
			pre(root.getLeft());//认为该左子结点为新树的根结点
		}
		if (root.getRight()!=null){
			pre(root.getRight());//认为该右子结点为新树的根结点
		}
	}
	public void mid(MyTreeNode root) {  //中序遍历： 左 根(输出) 右
		if(root.getLeft()!=null){
			mid(root.getLeft());//认为该左子结点为新树的根结点
		}
		print(root);
		if (root.getRight()!=null){
			mid(root.getRight());//认为该右子结点为新树的根结点
		}
	}
	public void next(MyTreeNode root) {  //后序遍历： 左 右 根(输出)
		if(root.getLeft()!=null){
			next(root.getLeft());//认为该左子结点为新树的根结点
		}
		if (root.getRight()!=null){
			next(root.getRight());//认为该右子结点为新树的根结点
		}
		print(root);
	}
    public static void levelPrint(MyTreeNode root){
        if(root == null)
        {
            return ;
        }
        LinkedList<MyTreeNode> queue = new LinkedList<MyTreeNode>();
        LinkedList<Character> arr = new LinkedList<>();
        MyTreeNode node = null;
        queue.offer(root);//将根节点入队
        while(!queue.isEmpty())
        {
            node = queue.poll();  //出队队头元素并访问
            arr.add(node.getData());
            //System.out.println(node.val);
            if(node.getLeft() != null)//如果当前节点的左节点不为空入队
            {
                queue.offer(node.getLeft());
            }
            if(node.getRight() != null)//如果当前节点的右节点不为空，把右节点入队
            {
                queue.offer(node.getRight());
            }
            if (node!=null){
            	print(node);
            }
        }

        
    }


	public static void main(String[] args) {//从叶子结点开始创建一个树
		MyTreeNode D = new MyTreeNode('D', null, null);
		MyTreeNode H = new MyTreeNode('H', null, null);
		MyTreeNode K = new MyTreeNode('K', null, null);
		MyTreeNode C = new MyTreeNode('C', D, null);
		MyTreeNode G = new MyTreeNode('G', H, K);
		MyTreeNode F = new MyTreeNode('F', G, null);
		MyTreeNode B = new MyTreeNode('B', null, C);
		MyTreeNode E = new MyTreeNode('E', null, F);
		MyTreeNode A = new MyTreeNode('A', B, E);
		BinaryTree binaryTree = new BinaryTree();
		System.out.println("前序遍历");
		binaryTree.pre(A);
		System.out.println();
		System.out.println("中序遍历");
		binaryTree.mid(A);
		System.out.println();
		System.out.println("后序遍历");
		binaryTree.next(A);
		System.out.println();
		System.out.println("层次遍历");
		levelPrint(A);
	}
	

}
> 前序遍历 
> ABCDEFGHK 
> 中序遍历 
> BDCAEHGKF 
> 后序遍历 
> DCBHKGFEA
> 层次遍历
> ABECFDGHK