由数组进行层次建树

package seven;
import java.util.ArrayList;
import java.util.Iterator;
/*
 * 需求分析:
 * 先是有一个表示树的数组,利用这个数组结合队列生成一棵层次的树
 * 这个数组a保存树的数据特点,a[0]存放的是这个数组存放的有效位置,其他位置都是无效的
 * 从a[1]开始存放树的每一个节点
 * 结合队列是建立两个队列,一个队列存放数组下标,一个队列存放下标所对应的节点
 * 
 * 这里存在一个问题未解决
 * Node<String>[] qa2=new Node<String>[10];
 * queue<Node<String>> q2=new queue<Node<String>>(qa2);
 * 这里想用泛型对象数组来解决,可是不知道为什么不给创建,所以我没有用泛型
 */
public class LevelTree
{
	public static void main(String[] args)
	{
		String[] a=ArrayTree();
		System.out.println("数组存树的样子");
		showarray(a);
		System.out.println("层次建立树");
		
		//建立两个队列,一个队列存放数组下标,一个队列存放下标所对应的节点
		Integer[] qa1=new Integer[10];
		queue<Integer> q1=new queue<Integer>(qa1);
//		Node<String>[] qa2=new Node<String>[10];
//		queue<Node<String>> q2=new queue<Node<String>>(qa2);
		Node[] qa2=new Node[10];
		queue<Node> q2=new queue<Node>(qa2);
		Treelist tree=maketree(q1, q2, a);
		System.out.println("先序遍历的样子");
		tree.firstshow(tree.root);
	
	}
	public static Treelist maketree(queue<Integer> q1,queue<Node> q2,String[] a)
	{
		//新建一棵树
		Treelist tree=new Treelist();
		tree.root=new Node(a[1]);
		q1.enqueue(1);
		q2.enqueue(tree.root);
		//当作是一个节点指针
		Node node;
		
		for(int x=1;x<=Integer.valueOf(a[0])/2;)
		{
			//将q1的数字放到array1中
			ArrayList<Integer> array1=new ArrayList<Integer>();
			while(!q1.isempty())
			{
				array1.add(q1.outqueue());
			}
			//将下一层的数字给q1
			for(Integer k:array1)
			{
				//这里的谁先进去要注意点
				q1.enqueue(k*2+1);q1.enqueue(k*2);
//				array3.add(k*2+1);array3.add(k*2);
			}
			//保存要进入q2的节点
			ArrayList<Node> array2=new ArrayList<Node>();
			while(!q2.isempty())
			{
				node=q2.outqueue();
				Integer int1=q1.outqueue();
				Integer int2=q1.outqueue();
				Node temp1;
				Node temp2;
				if(a[int1]!=null)
				{
					temp1=new Node(a[int1]); //先出来的是数字大的那个					
					node.rchild=temp1;
					array2.add(temp1);
				}
				if(a[int2]!=null)
				{
					temp2=new Node(a[int2]); //先出来的是数字大的那个					
					node.lchild=temp2;
					array2.add(temp2);
				}
				/*
				 * 因为我的第一个数字队列,是数字大的先出队列,
				 * 所以这里的节点队列也要对应节点大的先出队列,
				 * 所以就先是将节点大的先进队列
				 */
			}
			//将节点给回q1
			for(Integer k:array1)
			{
				q1.enqueue(k*2+1);q1.enqueue(k*2);
			}
			//将下一层节点给q2
			for(Node k:array2)
			{
				q2.enqueue(k);
			}
			x=x+array1.size()*2;
		}
		return tree;

	}
	public static String[] ArrayTree()
	{
		String[] a=new String[50];
		a[0]="15";a[1]="A";a[2]="B";a[3]="C";a[4]="D";a[5]="E";a[6]="F";a[7]="G";
		a[8]="K";a[9]=null;a[10]="H";a[11]=null;a[12]=null;a[13]="I";a[14]=null;a[15]="J";
//		a[0]="15";a[1]="A";a[2]="B";a[3]="C";a[4]="D";a[5]=null;a[6]="F";a[7]="G";
//		a[8]="K";a[9]=null;a[10]=null;a[11]=null;a[12]=null;a[13]="I";a[14]=null;a[15]="J";
		return a;
	}
	public static void showarray(String[] a)
	{
		for(int x=1;x<=Integer.valueOf(a[0]);x++)
		{
			System.out.print(a[x]+"  ");
		}
		System.out.println();
	}
}

//这是队列类
class queue<T>
{
	public T[] tarray;	 //缓冲区
	public int head;
	public int tail;
	public queue(T[] t)
	{
		this.tarray = t;
	}
	//进栈
	public boolean enqueue(T t)
	{
		if((tail+1)%tarray.length!=head)
		{
			tarray[tail%tarray.length]=t;
			tail=(tail+1)%tarray.length;
			return true;
		}
		return false;
	}
	public T outqueue()
	{
		T t=null;
		if(tail!=head)
		{
			t=tarray[head%tarray.length];
			head=(head+1)%tarray.length;
		}
		return t;
	}
	public boolean isempty()
	{
		return tail==head;
	}
}

//下面是节点类和链表树类
class Treelist<T>
{
	public Node<T> root;
	//先序遍历
	public void firstshow(Node node)
	{
		if(node!=null)
		{
			System.out.print(node.data+" ");				
			firstshow(node.lchild);
			firstshow(node.rchild);
		}
	}
	
}
class Node<T>
{
	public T data;
	public Node<T> rchild;
	public Node<T> lchild;
	public Node(T data)
	{
		this.data=data;
	}
}
/*
 * 刚刚开始的错误思想,记录一下		
Node node;
q1.enqueue(1);
Treelist tree=new Treelist();
tree.root=new Node(a[1]);
q2.enqueue(tree.root);
ArrayList<Integer> array1=new ArrayList<Integer>();
ArrayList<Integer> array3=new ArrayList<Integer>();
ArrayList<Node> array2=new ArrayList<Node>();
for(int x=1;x<=Integer.valueOf(a[0])/2;)
{
	while(!q1.isempty())
	{
		array1.add(q1.outqueue());
	}
	while(!q2.isempty())
	{
		array2.add(q2.outqueue());
	}
	
	//count来标记树已经创建到那个节点了
	int count=array1.size()*2;
	x+=count;
	Iterator iterator1=array1.iterator();
	while(iterator1.hasNext())
	{
		Integer temp=(Integer)iterator1.next();
		q1.enqueue(temp*2+1);q1.enqueue(temp*2);
		array3.add(temp*2+1);array3.add(temp*2);
	}
	Iterator iterator2=array2.iterator();
	while(iterator2.hasNext())
	{
		Node temp=(Node)iterator2.next();
		q2.enqueue(temp);
	}
	
	while(!q2.isempty())
	{
		node=q2.outqueue();
		Integer number1=q1.outqueue();
		Integer number2=q1.outqueue();
		Node nodetemp1=new Node(a[number1]);
		node.rchild=nodetemp1;
		Node nodetemp2=new Node(a[number2]);
		node.lchild=nodetemp2;	
	}
	for(Integer i:array3)
	{
		q1.enqueue(i);
	}
}
tree.show(tree.root);
*/