1)有且仅有一个特定的称为根Root的结点。
2)当n>1时,其余结点可分为m(m>0)个互不相交的有限集,其中每个集合本身又是一个棵树,并称为根的子树。
2,树的表示方法:
最常见的是树形表示法和广义表表示法,下面是树形表示法,如图所示。
上图的广义表表示法为:(A(B(D,E),C(F,G)))
3,常见的术语:
1) 父节点,孩子节点,兄弟节点。以上图为例,A是B和C的父节点,B和C是A的孩子节点,B和C之间就是兄弟节点了。
2) 结点的度和树的度。结点的度即结点有几个分支,比如节点A有两个分支B和C,那么结点A的度就是2,树的度即为一棵树中结点的最大度数,所以树的度也是2。
3) 有序树和无序树。如果将树中结点的子树看成是从左至右依次有序且不能交换,则称该树为有序树,否则称为无序树。
4) 森林。在上图中,如果将根节点A拿掉,那么B和C子树合并就是森林了。
5) 二叉树。二叉树是一种特殊的树。它的每个结点至多只有两棵子树。
4,二叉树的常见性质:
性质1 在二叉树的第i层上至多有2i-1个结点(i>=1)
性质2 深度为k的二叉树至多有2k-1个结点(k>=1)
性质3 满二叉树,在一棵深度为k且有2k-1个结点。完全二叉树,若一棵深度为k的二叉树,其前k-1层是一个棵满二叉树,而最下面一层(即第k层)上的结点都集中在该层最左边的若干位置上。
满二叉树一定是完全二叉树,但是完全二叉树则不一定是满二叉树。
下面是满二叉树和完全二叉树图示。
5,二叉树的两种存储结构
1) 顺序存储
对于完全二叉树而言,可以使用顺序存储结构。但是对于一般的二叉树来说,使用存储结构会有两个缺点,一,如果不是完全二叉树,则必须将其转化为完全二叉树,二是增加了很多虚节点,浪费资源空间。
2) 链式存储
这是最常用的一种二叉树存储结构。每个结点设置三个域,即值域,左指针域和右指针域,用data表示值域,lchild和rchild分别表示指向左右子树的指针域。如图所示。
6,二叉树的常见操作
1) 插入节点
思路:首先找到要插入节点的父节点,然后确定插到父节点的左边还是右边,最后将节点插入。
2) 查找节点
思路:运用递归查找。
3) 计算树的深度
思路:分别递归左子树和右子树,取长度较大的那一个作为整个树的深度。
4) 遍历之先序遍历
思路:先访问根,然后遍历左子树,再遍历右子树
5) 遍历之中序遍历
思路:先遍历左子树,再访问根,最后遍历右子树
6) 遍历之后序遍历
思路:先遍历左子树,再遍历右子树,最后访问根
7) 遍历之层次遍历
思路:从上到小,从左到右遍历
namespace DS.BLL
{
/// <summary>
/// 描述:二叉树操作类
/// 作者:鲁宁
/// 时间:2013/9/5 11:36:43
/// </summary>
public class BinTreeBLL
{
//按层遍历的存储空间长度
public static int Length { get; set; }
/// <summary>
/// 生成根节点
/// </summary>
/// <returns></returns>
public static BinTree<string> CreateRoot()
{
BinTree<string> root = new BinTree<string>();
Console.WriteLine("请输入根节点,以便生成树");
root.Data = Console.ReadLine();
Console.WriteLine("根节点生成成功");
return root;
}
/// <summary>
/// 插入节点
/// </summary>
/// <param name="tree">待操作的二叉树</param>
/// <returns>插入节点后的二叉树</returns>
public static BinTree<string> Insert(BinTree<string> tree)
{
while (true)
{
//创建要插入的节点
BinTree<string> node = new BinTree<string>();
Console.WriteLine("请输入待插入节点的数据");
node.Data = Console.ReadLine();
//获取父节点数据
Console.WriteLine("请输入待查找的父节点数据");
var parentNodeData = Console.ReadLine();
//确定插入方向
Console.WriteLine("请确定要插入到父节点的:1 左侧, 2 右侧");
Direction direction = (Direction)Enum.Parse(typeof(Direction), Console.ReadLine());
//插入节点
tree = InsertNode(tree,node,parentNodeData,direction);
//todo:没有找到父节点没有提示???
if (tree == null)
{
Console.WriteLine("未找到父节点,请重新输入!");
continue;
}
Console.WriteLine("插入成功,是否继续? 1 继续,2 退出");
if (int.Parse(Console.ReadLine()) == 1) continue;
else break; //退出循环
}
return tree;
}
public static BinTree<T> InsertNode<T>(BinTree<T> tree, BinTree<T> node, T parentNodeData, Direction direction)
{
if (tree == null) return null;
//找到父节点
if (tree.Data.Equals(parentNodeData))
{
switch (direction)
{
case Direction.Left:
if (tree.Left != null) throw new Exception("左节点已存在,不能插入!");
else tree.Left = node;
break;
case Direction.Right:
if (tree.Right != null) throw new Exception("右节点已存在,不能插入!");
else tree.Right = node;
break;
}
}
//向左子树查找父节点(递归)
InsertNode(tree.Left,node,parentNodeData,direction);
//向右子树查找父节点(递归)
InsertNode(tree.Right,node,parentNodeData,direction);
return tree;
}
/// <summary>
/// 查找节点
/// </summary>
/// <typeparam name="T">节点数据类型</typeparam>
/// <param name="tree">二叉树</param>
/// <param name="data">要查找的节点数据</param>
/// <returns>要查找的节点</returns>
public static bool GetNode<T>(BinTree<T> tree, T data)
{
if (tree == null) return false;
//查找成功
if (tree.Data.Equals(data)) return true;
//递归查找
return GetNode(tree.Left,data); //这里有问题???
}
/// <summary>
/// 获取二叉树的深度
/// 思路:分别递归左子树和右子树,然后得出较大的一个即为二叉树的深度
/// </summary>
/// <typeparam name="T">二叉树的数据类型</typeparam>
/// <param name="tree">待操作的二叉树</param>
/// <returns>二叉树的深度</returns>
public static int GetLength<T>(BinTree<T> tree)
{
if (tree == null) return 0;
int leftLength, rightLength;
//递归左子树的深度
leftLength = GetLength(tree.Left);
//递归右子树的深度
rightLength = GetLength(tree.Right);
if (leftLength > rightLength) return leftLength + 1;
else return rightLength + 1;
}
/// <summary>
/// 先序遍历
/// 思路:输出根节点--->遍历左子树--->遍历右子树
/// </summary>
/// <typeparam name="T">二叉树的数据类型</typeparam>
/// <param name="tree">待操作的二叉树</param>
public static void Traversal_DLR<T>(BinTree<T> tree)
{
if (tree == null) return;
//输出节点的值
Console.Write(tree.Data+"\t");
//递归遍历左子树
Traversal_DLR(tree.Left);
//递归遍历右子树
Traversal_DLR(tree.Right);
}
/// <summary>
/// 中序遍历
/// 思路:遍历左子树--->输出根节点--->遍历右子树
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="tree"></param>
public static void Traversal_LDR<T>(BinTree<T> tree)
{
if (tree == null) return;
//遍历左子树
Traversal_LDR(tree.Left);
//输出节点的值
Console.Write(tree.Data + "\t");
//遍历右子树
Traversal_LDR(tree.Right);
}
/// <summary>
/// 后序遍历
/// 思路:遍历左子树--->遍历右子树--->输出根节点
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="tree"></param>
public static void Traversal_LRD<T>(BinTree<T> tree)
{
if (tree == null) return;
//遍历左子树
Traversal_LRD(tree.Left);
//遍历右子树
Traversal_LRD(tree.Right);
//输出节点的值
Console.Write(tree.Data + "\t");
}
/// <summary>
/// 按层遍历
/// 思路:从上到下,从左到右遍历节点
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="tree"></param>
public static void Traversal_Level<T>(BinTree<T> tree)
{
if (tree == null) return;
int head=0;
int tail=0;
//申请保存空间
BinTree<T>[] treeList=new BinTree<T>[Length];
//将当前二叉树保存到数组中
treeList[tail] = tree;
//计算tail的位置
tail = (tail + 1) % Length; //除留余数法
while (head != tail)
{
var tempNode=treeList[head];
//计算head的位置
head = (head + 1) % Length;
//输出节点的值
Console.Write(tempNode.Data+"\t");
//如果左子树不为空,则将左子树保存到数组的tail位置
if (tempNode.Left != null)
{
treeList[tail] = tempNode.Left;
//重新计算tail的位置
tail = (tail + 1) % Length;
}
//如果右子树不为空,则将右子树保存到数组的tail位置
if (tempNode.Right != null)
{
treeList[tail] = tempNode.Right;
//重新计算tail的位置
tail = (tail + 1) % Length;
}
}
}
/// <summary>
/// 清空
/// 思路:使用递归释放当前节点的数据值
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="tree"></param>
public static void Clear<T>(BinTree<T> tree)
{
if (tree == null) return;
//递归左子树
Clear(tree.Left);
//递归右子树
Clear(tree.Right);
//释放节点数据
tree = null;
}
}
/// <summary>
/// 二叉树(二叉链表)存储结构
/// </summary>
/// <typeparam name="T"></typeparam>
public class BinTree<T>
{
public T Data { get;set;} //数据域
public BinTree<T> Left { get; set; } //左孩子
public BinTree<T> Right { get; set; } //右孩子
}
/// <summary>
/// 插入方向(左节点还是右节点)
/// </summary>
public enum Direction
{
Left=1,
Right=2
}
}