日撸Java三百行 day22(二叉树的存储)

1. 二叉树的存储

这里的二叉树存储是使用的两个数组来存储，一个char数组来存储value，一个int数组来存储对应在二叉树中的序号。

大致步骤:

1) 通过getNumNodes得知二叉树中节点个数，建立两个存储的数组；

2) 建立两个队列，一个Object类队列，一个Int类，将该类中创建的树入Object队，Int队列记录编号；

3) Object队列出队节点并转换类型赋值给temptree，Int队列出队序号赋值给tempIndex

4) 若该位置节点存在，将该节点value和编号放入对应数组中，再利用层次遍历的思想检查左右孩子，更新队列信息，然后继续下一次出队。

public void toDataArrays() {
	// Initialize arrays.
	int tempLength = getNumNodes();

	valuesArray = new char[tempLength];
	indicesArray = new int[tempLength];
	int i = 0;

	// Traverse and convert at the same time.
	CircleObjectQueue tempQueue = new CircleObjectQueue();
	tempQueue.enqueue(this);
	CircleIntQueue tempIntQueue = new CircleIntQueue();
	tempIntQueue.enqueue(0);

	BinaryCharTree tempTree = (BinaryCharTree) tempQueue.dequeue();
	int tempIndex = tempIntQueue.dequeue();
	while (tempTree != null) {
		valuesArray[i] = tempTree.value;
		indicesArray[i] = tempIndex;
		i++;

		if (tempTree.leftChild != null) {
			tempQueue.enqueue(tempTree.leftChild);
			tempIntQueue.enqueue(tempIndex * 2 + 1);
		} // Of if

		if (tempTree.rightChild != null) {
			tempQueue.enqueue(tempTree.rightChild);
			tempIntQueue.enqueue(tempIndex * 2 + 2);
		} // Of if

		tempTree = (BinaryCharTree) tempQueue.dequeue();
		tempIndex = tempIntQueue.dequeue();
	} // Of while
}// Of toDataArrays

2. 总代码

package datastructure.tree;

import java.util.Arrays;
import datastructure.queue.*;

/**
 * Binary tree with char type elements.
 * 
 * @author Yunhua Hu yunhuahu0528@163.com.
 */

public class BinaryCharTree {
	/**
	 * The value in char.
	 */
	char value;

	/**
	 * The left child.
	 */
	BinaryCharTree leftChild;

	/**
	 * The right child.
	 * 
	 */
	BinaryCharTree rightChild;

	/**
	 *********************
	 * The first constructor
	 *
	 * @param paraName
	 *            The value.
	 *********************
	 */
	public BinaryCharTree(char paraName) {
		value = paraName;
		leftChild = null;
		rightChild = null;
	}// Of the constructor

	/**
	 *********************
	 * Manually construct a tree. Only for testing.
	 *********************
	 */
	public static BinaryCharTree manualConstructTree() {
		// step 1. Construct a tree with only one node.
		BinaryCharTree resultTree = new BinaryCharTree('a');

		// Step 2. construct all nodes. The first node is the root.
		// BinaryCharTreeNode tempTreeA = resultTree.root;
		BinaryCharTree tempTreeB = new BinaryCharTree('b');
		BinaryCharTree tempTreeC = new BinaryCharTree('c');
		BinaryCharTree tempTreeD = new BinaryCharTree('d');
		BinaryCharTree tempTreeE = new BinaryCharTree('e');
		BinaryCharTree tempTreeF = new BinaryCharTree('f');
		BinaryCharTree tempTreeG = new BinaryCharTree('g');

		// step 3. Link al nodes.
		resultTree.leftChild = tempTreeB;
		resultTree.rightChild = tempTreeC;
		tempTreeB.rightChild = tempTreeD;
		tempTreeC.leftChild = tempTreeE;
		tempTreeD.leftChild = tempTreeF;
		tempTreeD.rightChild = tempTreeG;

		return resultTree;
	}// Of manualConstructTree

	/**
	 *********************
	 * Pre-order visit.
	 *********************
	 */
	public void preOrderVisit() {
		System.out.print("" + value + " ");

		if (leftChild != null) {
			leftChild.preOrderVisit();
		} // Of if

		if (rightChild != null) {
			rightChild.preOrderVisit();
		} // Of if
	}// Of preOrderVisit

	/**
	 *********************
	 * In-Order visit.
	 *********************
	 */
	public void inOrderVisit() {
		if (leftChild != null) {
			leftChild.inOrderVisit();
		} // Of if

		System.out.print("" + value + " ");

		if (rightChild != null) {
			rightChild.inOrderVisit();
		} // Of if
	}// Of inOrderVisit

	/**
	 *********************
	 * Post-Order visit.
	 *********************
	 */
	public void postOrderVisit() {
		if (leftChild != null) {
			leftChild.postOrderVisit();
		} // Of if

		if (rightChild != null) {
			rightChild.postOrderVisit();
		} // Of if

		System.out.print("" + value + " ");
	}// Of postOrderVisit

	/**
	 *********************
	 * Get the depth of the binary tree.
	 *
	 * @return The depth. It is 1 if there is only node, i.e., the root.
	 *********************
	 */
	public int getDepth() {
		// It is a leaf.
		if ((leftChild == null) && (rightChild == null)) {
			return 1;
		} // Of if

		int tempLeftDepth = 0;
		if (leftChild != null) {
			tempLeftDepth = leftChild.getDepth();
		} // Of if

		int tempRightDepth = 0;
		if (rightChild != null) {
			tempRightDepth = rightChild.getDepth();
		} // Of if

		if (tempLeftDepth >= tempRightDepth) {
			return tempLeftDepth + 1;
		} else {
			return tempRightDepth + 1;
		} // of if
	} // Of getDepth

	/**
	 *********************
	 * Get the number of nodes.
	 *
	 * @return The number of nodes.
	 *********************
	 */
	public int getNumNodes() {
		// It is a leaf.
		if ((leftChild == null) && (rightChild == null)) {
			return 1;
		} // Of if

		// The number of nodes of the left child.
		int tempLeftNodes = 0;
		if (leftChild != null) {
			tempLeftNodes = leftChild.getNumNodes();
		} // Of if

		// The number of nodes of the right child.
		int tempRightNodes = 0;
		if (rightChild != null) {
			tempRightNodes = rightChild.getNumNodes();
		} // Of if

		// The total number of the nodes.
		return tempLeftNodes + tempRightNodes + 1;
	} // Of getNumNodes

	/**
	 * The values of nodes according to breadth first traversal.
	 */
	char[] valuesArray;

	/**
	 * The indices in the complete binary tree.
	 */
	int[] indicesArray;

	/**
	 ********************
	 * Convert the tree to data arrays, including a char array and an int array. The
	 * results are stored in two member variables.
	 * 
	 * @see #valuesArray
	 * @see #indicesArray
	 *********************
	 */
	public void toDataArrays() {
		// Initialize arrays.
		int tempLength = getNumNodes();

		valuesArray = new char[tempLength];
		indicesArray = new int[tempLength];
		int i = 0;

		// Traverse and convert at the same time.
		CircleObjectQueue tempQueue = new CircleObjectQueue();
		tempQueue.enqueue(this);
		CircleIntQueue tempIntQueue = new CircleIntQueue();
		tempIntQueue.enqueue(0);

		BinaryCharTree tempTree = (BinaryCharTree) tempQueue.dequeue();
		int tempIndex = tempIntQueue.dequeue();
		while (tempTree != null) {
			valuesArray[i] = tempTree.value;
			indicesArray[i] = tempIndex;
			i++;

			if (tempTree.leftChild != null) {
				tempQueue.enqueue(tempTree.leftChild);
				tempIntQueue.enqueue(tempIndex * 2 + 1);
			} // Of if

			if (tempTree.rightChild != null) {
				tempQueue.enqueue(tempTree.rightChild);
				tempIntQueue.enqueue(tempIndex * 2 + 2);
			} // Of if

			tempTree = (BinaryCharTree) tempQueue.dequeue();
			tempIndex = tempIntQueue.dequeue();
		} // Of while
	}// Of toDataArrays

	/**
	 *********************
	 * The entrance of the program.
	 * 
	 * @param args
	 *            Not used now.
	 *********************
	 */
	public static void main(String args[]) {
		BinaryCharTree tempTree = manualConstructTree();
		System.out.println("\r\nPreorder visit:");
		tempTree.preOrderVisit();
		System.out.println("\r\nIn-order visit:");
		tempTree.inOrderVisit();
		System.out.println("\r\nPost-order visit:");
		tempTree.postOrderVisit();

		System.out.println("\r\n\r\nThe depth is: " + tempTree.getDepth());
		System.out.println("The number of nodes is: " + tempTree.getNumNodes());

		tempTree.toDataArrays();
		System.out.println("The values are: " + Arrays.toString(tempTree.valuesArray));
		System.out.println("The indices are: " + Arrays.toString(tempTree.indicesArray));
	}// Of main

}// Of BinaryCharTree

输出:

问题:

tempQueue.enqueue(this); 

 这行代码大概理解在在这的作用，但是具体的地层逻辑还是有点迷。

在214行加了个输出看看

System.out.println("The current Queue: " + tempQueue.toString());

输出:

 还是不太能明白。

day23补:

看了day23老师的对Object的讲解，这个This应该是树的地址，队中是该类树节点的地址。