二叉树

树与二叉树的区别

1.树中节点的最大度数没有限制，而二叉树树节点的最大度数为2。

2.无序树的节点无左右之分，而二叉树的节点有左右之分，次序不能颠倒，也就是说二叉树是有序数。

 

满二叉树和完全二叉树

满二叉树：一棵深度为k，且有2的(k)次方－1个节点的二叉树 特点：每一层上的结点数都是最大结点数。

完全二叉树的定义：深度为k，有n个结点的二叉树当且仅当其每一个结点都与深度为k的满二叉树中编号从1至n的结点一一对应时，称为完全二叉树。 特点：叶子结点只可能在层次最大的两层上出现；对任一结点，若其右分支下子孙的最大层次为l，则其左分支下子孙的最大层次必为l 或l+1。

对比：满二叉树肯定是完全二叉树完全二叉树不一定是满二叉树。

 

二叉树的顺序存储

顺序存储充分利用了满二叉树的特性，一棵深度为i的二叉树最多有2的i次方减1个节点，因此只要定义一个长度为2的i次方减1的数组即可存储这棵二叉树。空出来的元素对应数组元素为空就可以了，但这样势必造成空间的浪费。

下面使用java实现一个顺序存储的二叉树：

/**
 * zuyanlong
 */
public class ArrayBinTree<T>
{
 //使用数组来记录该树的所有节点
 private Object[] datas;
 private int DEFAULT_DEEP = 8;
 //保存该树的深度
 private int deep;
 private int arraySize;
 //以默认的深度来创建二叉树
 public ArrayBinTree()
 {
  this.deep = DEFAULT_DEEP;
  this.arraySize = (int)Math.pow(2 , deep) - 1;
  datas = new Object[arraySize];
 }
 //以指定深度来创建二叉树
 public ArrayBinTree(int deep)
 {
  this.deep = deep;
  this.arraySize = (int)Math.pow(2 , deep) - 1;
  datas = new Object[arraySize];
 }
 //以指定深度,指定根节点创建二叉树
 public ArrayBinTree(int deep , T data)
 {
  this.deep = deep;
  this.arraySize = (int)Math.pow(2 , deep) - 1;
  datas = new Object[arraySize];
  datas[0] = data;
 }
 /**
  * 为指定节点添加子节点。
  * @param index 需要添加子节点的父节点的索引
  * @param data 新子节点的数据
  * @param left 是否为左节点
  */
 public void add(int index , T data , boolean left)
 {
  if (datas[index] == null)
  {
   throw new RuntimeException(index + "处节点为空，无法添加子节点");
  }
  if (2 * index + 1 >= arraySize)
  {
   throw new RuntimeException("树底层的数组已满，树越界异常");
  }
  //添加左子节点
  if (left)
  {
   datas[2 * index + 1] = data;
  }
  else
  {
   datas[2 * index + 2] = data;
  }
 }
 //判断二叉树是否为空。
 public boolean empty()
 {
  //根据根元素来判断二叉树是否为空
  return datas[0] == null;
 }
 //返回根节点。
 public T root()
 {
  return (T)datas[0] ;
 }
 //返回指定节点（非根节点）的父节点。
 public T parent(int index)
 {
  return (T)datas[(index - 1) / 2] ;
 }
 //返回指定节点（非叶子）的左子节点。当左子节点不存在时返回null
 public T left(int index)
 {
  if (2 * index + 1 >= arraySize)
  {
   throw new RuntimeException("该节点为叶子节点，无子节点");
  }
  return (T)datas[index * 2 + 1] ;
 }
 //返回指定节点（非叶子）的右子节点。当右子节点不存在时返回null
 public T right(int index)
 {
  if (2 * index + 1 >= arraySize)
  {
   throw new RuntimeException("该节点为叶子节点，无子节点");
  }
  return (T)datas[index * 2 + 2] ;
 }
 //返回该二叉树的深度。
 public int deep(int index)
 {
  return deep;
 }
 //返回指定节点的位置。
 public int pos(T data)
 {
  //该循环实际上就是按广度遍历来搜索每个节点
  for (int i = 0 ; i < arraySize ; i++)
  {
   if (datas[i].equals(data))
   {
    return i;
   }
  }
  return -1;
 }
 public String toString()
 {
  return java.util.Arrays.toString(datas);
 }
}

二叉树的二叉链表存储

二叉链表存储的思想就是让每个节点都记住他的左、右两个子节点。为每个子节点增加left、right两个指针，分别引用该节点的左、右两个子节点。

二叉链表存储java实现：

 

/**
*zuyanlong

 */
public class TwoLinkBinTree<E>
{
 public static class TreeNode
 {
  Object data;
  TreeNode left;
  TreeNode right;
  public TreeNode()
  {
  }
  public TreeNode(Object data)
  {
   this.data = data;
  }
  public TreeNode(Object data , TreeNode left
   , TreeNode right)
  {
   this.data = data;
   this.left = left;
   this.right = right;
  }
 }
 private TreeNode root;
 //以默认的构造器来创建二叉树
 public TwoLinkBinTree()
 {
  this.root = new TreeNode();
 }
 //以指定根元素来创建二叉树
 public TwoLinkBinTree(E data)
 {
  this.root = new TreeNode(data);
 }
 /**
  * 为指定节点添加子节点。
  * @param index 需要添加子节点的父节点的索引
  * @param data 新子节点的数据
  * @param isLeft 是否为左节点
  * @return 新增的节点
  */
 public TreeNode addNode(TreeNode parent , E data
  , boolean isLeft)
 {
  if (parent == null)
  {
   throw new RuntimeException(parent +
    "节点为null，无法添加子节点");
  }
  if (isLeft && parent.left != null)
  {
   throw new RuntimeException(parent +
    "节点已有左子节点，无法添加左子节点");
  }
  if (!isLeft && parent.right != null)
  {
   throw new RuntimeException(parent +
    "节点已有右子节点，无法添加右子节点");
  }
  TreeNode newNode = new TreeNode(data);
  if (isLeft)
  {
   //让父节点的left引用指向新节点
   parent.left = newNode;
  }
  else
  {
   //让父节点的left引用指向新节点
   parent.right = newNode;
  }
  return newNode;
 }
 //判断二叉树是否为空。
 public boolean empty()
 {
  //根据根元素来判断二叉树是否为空
  return root.data == null;
 }
 //返回根节点。
 public TreeNode root()
 {
  if (empty())
  {
   throw new RuntimeException("树为空，无法访问根节点");
  }
  return root;
 }
 //返回指定节点（非根节点）的父节点。
 public E parent(TreeNode node)
 {
  //对于二叉链表存储法，如果要访问指定节点的父节点必须遍历二叉树
  return null;
 }
 //返回指定节点（非叶子）的左子节点。当左子节点不存在时返回null
 public E leftChild(TreeNode parent)
 {
  if (parent == null)
  {
   throw new RuntimeException(parent +
    "节点为null，无法添加子节点");
  }
  return parent.left == null ? null : (E)parent.left.data;
 }
 //返回指定节点（非叶子）的右子节点。当右子节点不存在时返回null
 public E rightChild(TreeNode parent)
 {
  if (parent == null)
  {
   throw new RuntimeException(parent +
    "节点为null，无法添加子节点");
  }
  return parent.right == null ? null : (E)parent.right.data;
 }
 //返回该二叉树的深度。
 public int deep()
 {
  //获取该树的深度
  return deep(root);
 }
 //这是一个递归方法：每棵子树的深度为其所有子树的最大深度 + 1
 private int deep(TreeNode node)
 {
  if (node == null)
  {
   return 0;
  }
  //没有子树
  if (node.left == null
   && node.right == null)
  {
   return 1;
  }
  else
  {
   int leftDeep = deep(node.left);
   int rightDeep = deep(node.right);
   //记录其所有左、右子树中较大的深度
   int max = leftDeep > rightDeep ?
    leftDeep : rightDeep;
   //返回其左右子树中较大的深度 + 1
   return max + 1;
  }
 }
}