《java实现树和二叉树》

父节点表示树

  树中除根结点外每个结点都有一个父节点，要记录树中结点与结点直接的关系，只需要给每一个结点增加一个parent的父节点索引，根节点的parent索引为-1，如此将所有的结点存储于结点数组中，结点数组就是相当于一颗树。新增一个树结点只需要存入数据和parent索引，查找某个结点的所有子节点，只需要遍历所有结点的parent索引，相等即用List存储。
  如何遍历父节点表示树的深度(难点)？遍历所有的结点数组array，得到结点的parent索引后p，看array[p]是否为空，或者p == -1，那么该次深度遍历结果结束，进行下一个结点自下而上计算深度，遍历出最大深度即是树的深度。

import java.util.ArrayList;
import java.util.List;

public class TreeParent<E>
{
   
	public static class Node<T>
	{
   
		T data;
		// 记录其父节点的位置
		int parent;
		public Node()
		{
   
		}
		public Node(T data)
		{
   
			this.data = data;
		}
		public Node(T data , int parent)
		{
   
			this.data = data;
			this.parent = parent;
		}
		public String toString()
		{
   
			return "TreeParent$Node[data=" + data
				+ ", parent=" + parent + "]";
		}
	}
	private final int DEFAULT_TREE_SIZE = 100;
	private int treeSize = 0;
	// 使用一个Node[]数组来记录该树里的所有节点
	private Node<E>[] nodes;
	// 记录节点数
	private int nodeNums;
	// 以指定根节点创建树
	@SuppressWarnings("unchecked")
	public TreeParent(E data)
	{
   
		treeSize = DEFAULT_TREE_SIZE;
		nodes = new Node[treeSize];
		nodes[0] = new Node<E>(data , -1);
		nodeNums++;
	}
	// 以指定根节点、指定treeSize创建树
	@SuppressWarnings("unchecked")
	public TreeParent(E data ,int treeSize)
	{
   
		this.treeSize = treeSize;
		nodes = new Node[treeSize];
		nodes[0] = new Node<E>(data , -1);
		nodeNums++;
	}
	// 为指定节点添加子节点
	public void addNode(E data , Node parent)
	{
   
		for (int i = 0 ; i < treeSize ; i++)
		{
   
			// 找到数组中第一个为null的元素，该元素保存新节点
			if (nodes[i] == null)
			{
   
				//创建新节点，并用指定的数组元素保存它
				nodes[i] = new Node<E>(data , pos(parent));;
				nodeNums++;
				return;
			}
		}
		throw new RuntimeException("该树已满，无法添加新节点");
	}
	// 判断树是否为空。
	public boolean empty()
	{
   
		// 根节点是否为null
		return nodes[0] == null;
	}
	// 返回根节点
	public Node<E> root()
	{
   
		// 返回根节点
		return nodes[0];
	}
	// 返回指定节点（非根节点）的父节点。
	public Node<E> parent(Node node)
	{
   
		// 每个节点的parent记录了其父节点的位置
		return nodes[node.parent];
	}
	// 返回指定节点（非叶子节点）的所有子节点。
	public List<Node<E>> children(Node parent)
	{
   
		List<Node<E>> list = new ArrayList<Node<E>>();
		for (int i = 0 ; i < treeSize  ; i++)
		{
   
			// 如果当前节点的父节点的位置等于parent节点的位置
			if (nodes[i] != null &&
				nodes[i].parent == pos(parent))
			{
   
				list.add(nodes[i]);
			}
		}
		return list;
	}
	// 返回该树的深度。
	public int deep()
	{
   
		// 用于记录节点的最大深度
		int max = 0;
		for(int i = 0 ; i < treeSize && nodes[i] != null
			; i++)
		{
   
			// 初始化本节点的深度
			int def = 1;
			// m记录当前节点的父节点的位置
			int m = nodes[i].parent;
			// 如果其父节点存在
			while(m != -1 && nodes[m] != null)
			{
   
				// 向上继续搜索父节点
				m = nodes[m].parent;
				def++;
			}
			if(max < def)
			{
   
				max = def;
			}
		}
		// 返回最大深度
		return max;
	}
	// 返回包含指定值的节点。
	public int pos(Node node)
	{
   
		for (int i = 0 ; i < treeSize ; i++)
		{
   
			// 找到指定节点
			if (nodes[i] == node)
			{
   
				return i;
			}
		}
		return -1;
	}
	public static void main(String[] args)
	{
   
		TreeParent<String> tp = new TreeParent<String>("root");
		TreeParent.Node root = tp.root();
		System.out.println(root);
		tp.addNode("节点1" , root);
		System.out.println("此树的深度:" + tp.deep());
		tp.addNode("节点2" , root);
		// 获取根节点的所有子节点
		List<TreeParent.Node<String>> nodes = tp.children(root);
		System.out.println("根节点的第一个子节点：" + nodes.get(0));
		// 为根节点的第一个子节点新增一个子节点
		tp.addNode("节点3" , nodes.get(0));
		System.out.println("此树的深度:" + tp.deep());
	}
}

运行结果：
              

子节点表示树(未掌握)

  父节点表示法思想是让每个节点都“记住”它父节点的索引，而子节点表示法，每个节点要记住多个子节点，则需要采用“子节点链”表示法。
需要注意：

1. TreeChild需要有两个内部类，SonNode与Node，其中SonNode是链表，只存储当前结点的index
2. TreeChild中底层还是使用Node[]数组，Node中还有变量data存储数值
3. TreeChild中添加一个结点时，add()函数要传入该结点值与结点的父节点，添加时要遍历所有的Node[]数组，如果有空，则新建Node存储于该位置，接下来需要看parent是否有子节点链，有则遍历子节点链到最后，维护该结点与父节点的关系。
4. 递归求深度(难)：当每个结点的子树用链式存储，递归求树的深度比较复杂，每棵子树的深度为其所有子树的最大深度 + 1

import java.util.*;

public class TreeChild<E>
{
   
	private static class SonNode
	{
   
		// 记录当前节点的位置
		private int pos;
		private SonNode next;
		public SonNode(int pos , SonNode next)
		{
   
			this.pos = pos;
			this.next = next;
		}
	}
	public static class Node<T>
	{
   
		T data;
		// 记录第一个子节点
		SonNode first;
		public Node(T data)
		{
   
			this.data = data;
			this.first = null;
		}
		public String toString()
		{
   
			if (first != null)
			{
   
				return "TreeChild$Node[data=" + data
					+ ", first=" + first.pos + "]";
			}
			else
			{
   
				return "TreeChild$Node[data=" + data + ", first=-1]";
			}
		}
	}
	private final int DEFAULT_TREE_SIZE = 100;
	private int treeSize = 0;
	// 使用一个Node[]数组来记录该树里的所有节点
	private Node<E>[] nodes;
	// 记录节点数
	private int nodeNums;
	// 以指定根节点创建树
	@SuppressWarnings("unchecked")
	public TreeChild(E data)
	{
   
		treeSize = DEFAULT_TREE_SIZE;
		nodes = new Node[treeSize];
		nodes[0] = new Node<E>(data);
		nodeNums++;
	}
	// 以指定根节点、指定treeSize创建树
	@SuppressWarnings("unchecked")
	public TreeChild(E data ,int treeSize)
	{
   
		this.treeSize = treeSize;
		nodes = new Node[treeSize];
		nodes[0] = new Node<E>(data);
		nodeNums++;
	}
	// 为指定节点添加子节点
	public void addNode(E data , Node parent)
	{
   
		for (int i = 0 ; i < treeSize ; i++)
		{
   
			// 找到数组中第一个为null的元素，该元素保存新节点
			if (nodes[i] == null)
			{
   
				// 创建新节点，并用指定数组元素来保存它
				nodes[i] = new Node<E>(data);
				if (parent.first == null)
				{
   
					parent.first = new SonNode(i , null);
				}
				else
				{
   
					SonNode next = parent.first;
					while (next.next != null)
					{
   
						next = next.next;
					}
					next.next = new SonNode(i , null);
				}
				nodeNums++;
				return;
			}
		}
		throw new RuntimeException("该树已满，无法添加新节点");
	}
	// 判断树是否为空。
	public boolean empty()
	{
   
		// 根节点是否为null
		return nodes[0] == null;
	}
	// 返回根节点
	public Node<E> root()
	{
   
		// 返回根节点
		return nodes[0];
	}
	// 返回指定节点（非叶子节点）的所有子节点。
	public List<Node<E>> children(Node parent)
	{
   
		List<Node<E>> list = new ArrayList<Node<E>>();
		// 获取parent节点的第一个子节点
		SonNode next = parent.first;
		// 沿着孩子链不断搜索下一个孩子节点
		while (next != null)
		{
   
			// 添加孩子链中的节点
			list.add(nodes[next.pos]);
			next = next.next;
		}
		return list;
	}
	// 返回指定节点（非叶子节点）的第index个子节点。
	public Node<E> child(Node parent , int index)
	{
   
		// 获取parent节点的第一个子节点
		SonNode next = parent.first;
		// 沿着孩子链不断搜索下一个孩子节点
		for (int i = 0 ; next != null  ; i++)
		{
   
			if (index == i)
			{
   
				return nodes[next.pos];
			}
			next = next.next;
		}
		return null;
	}
	// 返回该树的深度。
	public int deep()
	{
   
		// 获取该树的深度
		return deep(root());
	}
	// 这是一个递归方法：每棵子树的深度为其所有子树的最大深度 + 1
	private int deep(Node node)
	{
   
		if (node.first == null)
		{
   
			return 1;
		}
		else
		{
   
			// 记录其所有子树的最大深度
			int max = 0;
			SonNode next = node.first;
			// 沿着孩子链不断搜索下一个孩子节点
			while (next != null)
			{
   
				// 获取以其子节点为根的子树的深度
				int tmp = deep(nodes[next.pos]);
				if (tmp > max)
				{
   
					max = tmp;
				}
				next = next.next;
			}
			// 最后返回其所有子树的最大深度 + 1
			return max + 1;
		}
	}
	// 返回包含指定值的节点。
	public int pos(Node node)
	{
   
		for (int i = 0 ; i < treeSize ; i++)
		{
   
			// 找到指定节点
			if (nodes[i] == node)
			{
   
				return i;
			}
		}
		return -1;
	}
	public static void main(String[] args)
	{
   
		TreeChild<String> tp = new TreeChild<String>("root");
		TreeChild.Node root = tp.root();
		System.out.println("根节点：" + root);
		tp.addNode("节点1" , root);
		tp.addNode("节点2" , root);
		tp.addNode("节点3" , root);
		System.out.println("添加子节点后的根节点：" + root);
		System.out.println("此树的深度:" + tp.deep());
		// 获取根节点的所有子节点
		List<TreeChild.Node<String>> nodes = tp.children(root);
		System.out.println("根节点的第一个子节点：" + nodes.get(0));
		// 为根节点的第一个子节点新增一个子节点
		tp.addNode("节点4" , nodes.get(0));
		System.out.println("根节点的第一个子节点：" + nodes.get(0));
		System.out.println("此树的深度:" + tp.deep());
	}
}

运行结果：
            

顺序存储二叉树

  顺序存储二叉树是最简单实现的二叉树，思想是将树中不同的节点存入数组的固定的位置。比如，根节点永远使用数组的第一个元素来保存，第二层的第2个节点，永远使用数组的第3个元素来保存:第三层最右边的节点，永远使用数组的第7个元素来保存，一依此类推。但是还是要初始化顺序存储二叉树的数组大小，每次添加结点传入参数父节点的index，以及该结点是父节点的左结点还是右结点，决定了存储在Object[2index +1]还是在Object[2index +2]中。

public class ArrayBinTree<T>
{
   
	// 使用数组来记录该树的所有节点
	private Object[] datas;
	private int DEFAULT_DEEP = 8;
	// 保存该树的深度
	private int deep;