树的子节点链表示法及其Java实现

父节点表示法的思想是让每个节点持有它的父节点的索引，这种方式是从子节点出发；反过来可以让父节点持有它的所有子节点。这种方式下，由于每个父节点需要记住多个子节点，因此必须采用“子节点链”表示法。如下图：

 

Java实现代码

package com.liuhao.DataStructures;

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

public class TreeChild<E> {

	private static class ChildNode {
		private int pos;// 记录当前节点位置
		private ChildNode next;

		public ChildNode(int pos, ChildNode next) {
			this.pos = pos;
			this.next = next;
		}
	}

	public static class Node<T> {
		T data;
		ChildNode first;// 记录第一个子节点

		public Node() {
		}

		public Node(T data) {
			this.data = data;
			this.first = null;
		}

		public String toString() {
			if (first != null) {
				return "TreeChild$Node[data=" + data + ", first=" + first.pos
						+ "]";
			}
			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;
		this.nodes = new Node[treeSize];
		nodes[0] = new Node<E>(data);
		nodeNums++;
	}

	// 为指定节点添加子节点
	public void addNode(E data, Node<E> node) {
		for (int i = 0; i < treeSize; i++) {
			if (nodes[i] == null) {
				nodes[i] = new Node<E>(data);
				// 若该节点没有第一个子节点，那么就新建子节点链
				if (node.first == null) {
					node.first = new ChildNode(i, null);
				} else {
					// 若有，则依次取该节点的子节点，直到叶子节点
					ChildNode next = node.first;
					while (next.next != null) {
						next = next.next;
					}
					// 在叶子节点处添加该子节点
					next.next = new ChildNode(i, null);
				}
				nodeNums++;
				return;
			}
		}
		throw new RuntimeException("该树已满，无法添加新节点");
	}

	// 判断是否为空
	public boolean isEmpty() {
		// 跟节点是否为空
		return nodes[0] == null;
	}

	// 获取根节点
	public Node<E> getRoot() {
		return nodes[0];
	}

	// 获取指定节点的所有子节点
	public List<Node<E>> getChildren(Node<E> node) {
		List<Node<E>> list = new ArrayList<Node<E>>();
		// 获取给定节点的第一子节点
		ChildNode next = node.first;
		// 沿着孩子链不断搜索下一个孩子节点
		while (next != null) {
			// 添加孩子链中的节点
			list.add(nodes[next.pos]);
			next = next.next;
		}
		return list;
	}

	// 返回指定节点的第index个子节点
	public Node<E> getChildByIndex(Node<E> node, int index) {
		// 获取该节点的第一个子节点
		ChildNode next = node.first;
		// 沿着孩子链一直搜寻
		for (int i = 0; next != null; i++) {
			if (index == i) {
				return nodes[next.pos];
			}
			next = next.next;
		}
		return null;
	}

	// 递归的方式返回某个节点的深度
	private int getDeep(Node<E> node) {
		if (node.first == null) {
			return 1;
		} else {
			int max = 0;
			ChildNode next = node.first;
			while (next != null) {
				// 获取以其子节点为根的子树的深度
				int tmp = this.getDeep(nodes[next.pos]);
				if (tmp > max) {
					max = tmp;
				}
				next = next.next;
			}

			return max + 1;
		}
	}

	public int getDeep() {
		return this.getDeep(getRoot());
	}

	// 返回包含指定节点的索引
	public int pos(Node<E> node) {
		for (int i = 0; i < treeSize; i++) {
			if (nodes[i] == node) {
				return i;
			}
		}
		return -1;
	}

}

从以上程序可以看出，定义树节点时增加了一个first域。该first域用于保存对该节点的子节点链的引用，通过这种方式即可记录数中节点之间的父子关系。

添加节点时只需找到指定节点的子节点链的最后节点，并让他指向新增的节点。

测试代码：

package com.liuhao.test;

import java.util.List;

import org.junit.Test;

import com.liuhao.DataStructures.TreeChild;
import com.liuhao.DataStructures.TreeChild.Node;

public class TreeChildTest {

	@Test
	public void test() {
		TreeChild<String> tree = new TreeChild<String>("root");
		Node<String> root = tree.getRoot();
		System.out.println("根节点：" + root);

		tree.addNode("节点1", root);
		tree.addNode("节点2", root);
		tree.addNode("节点3", root);
		System.out.println("添加子节点后的根节点：" + root);
		System.out.println("树的深度：" + tree.getDeep());

		List<Node<String>> nodes = tree.getChildren(root);
		System.out.println("根节点的第一个子节点：" + nodes.get(0));

		tree.addNode("节点4", nodes.get(0));
		System.out.println("根节点的第一个子节点：" + nodes.get(0));
		System.out.println("树的深度：" + tree.getDeep());

	}

}

显然，子节点链表示法中的每个节点都可以快速找到它的所有子节点，但相应的找父节点则比较麻烦。