算法练习之二叉树

照书打了一遍代码。

结点

public class BinaryNode<T> {
	public T data;
	public BinaryNode<T> left,right;
	public BinaryNode(T data,BinaryNode<T> left,BinaryNode<T> right){
		this.data=data;
		this.left=left;
		this.right=right;
	}
	public BinaryNode(T data){this(data,null,null);}
	public BinaryNode(){this(null,null,null);}
}

接口

public interface BinaryTTree<T> {
	boolean isEmpty();
	int count();
	int height();
	void preOrder();
	void inOrder();
	void postOrder();
	void levelOrder();
	BinaryNode<T> search(T key);
	BinaryNode<T> getParent(BinaryNode<T> node);
	void insertRoot(T x);
	BinaryNode<T> insertChild(BinaryNode<T> p,T x,boolean leftchild);
	void removeChild(BinaryNode<T> p,boolean leftChild);
	void removeall();
}

树类 时间有点紧，没打完所有的代码，就打了相对重要的

public class BinaryTree<T> implements BinaryTTree<T> {
	public BinaryNode<T> root;
	public BinaryTree(){
		this.root=null;
	}
	@Override
	public int count() {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public BinaryNode<T> getParent(BinaryNode<T> node) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public int height() {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public void inOrder() {
		// TODO Auto-generated method stub
		System.out.print("中根遍历：");
		inOrder(root);
		System.out.println();
	}

	private void inOrder(BinaryNode<T> p) {
		// TODO Auto-generated method stub
		if(p!=null){
			inOrder(p.left);
			System.out.print(p.data.toString()+"");
			inOrder(p.right);
		}
	}
	@Override
	public BinaryNode<T> insertChild(BinaryNode<T> p, T x, boolean leftchild) {
		// TODO Auto-generated method stub
		if(p==null||x==null){
			return null;
		}
		if(leftchild){
			p.left=new  BinaryNode<T>(x,p.left,null);
			return p.right;
		}
		p.right=new BinaryNode<T>(x,null,p.right);
		return p.right;
	}
	@Override
	public void insertRoot(T x) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public boolean isEmpty() {
		// TODO Auto-generated method stub
		return this.root==null;
	}

	@Override
	public void levelOrder() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void postOrder() {
		// TODO Auto-generated method stub
		System.out.print("后根遍历：");
		postOrder(root);
		System.out.println();
	}

	private void postOrder(BinaryNode<T> p) {
		// TODO Auto-generated method stub
		
		if(p!=null){
			postOrder(p.left);
			postOrder(p.right);
			System.out.print(p.data.toString()+"");
		}
	}
	@Override
	public void preOrder() {
		// TODO Auto-generated method stub
		System.out.print("先根遍历：");
		preOrder(root);
		System.out.println();
	}

	private void preOrder(BinaryNode<T> p) {
		// TODO Auto-generated method stub
		
		if(p!=null){
			System.out.print(p.data.toString()+"");
			preOrder(p.left);
			preOrder(p.right);
		}
	}
	@Override
	public void removeChild(BinaryNode<T> p, boolean leftChild) {
		// TODO Auto-generated method stub
		if(p!=null){
			if(leftChild)
				p.left=null;
			else 
				p.right=null;
		}
	}

	@Override
	public void removeall() {
		// TODO Auto-generated method stub
		this.root=null;
	}

	@Override
	public BinaryNode<T> search(T key) {
		// TODO Auto-generated method stub
		return null;
	}
	
}

主要是遍历，用的是递归。、

未完成，明天继续写

第二天，这回是上午写了，不过晚上玩了会电脑 ，然后看别人玩电脑 ，，哈哈，反正 就是玩到了现在。

下面的代码是一个缩进输出二叉树的，我发现这种递归遍历的用递归输出还是比较好，，

public String tostring(BinaryNode<T> p, String tab) {
		// TODO Auto-generated method stub
		if (p == null)
			return "";
		return tab + p.data.toString() + "\n" + tostring(p.left, tab + "\t")
				+ tostring(p.right, tab+"\t");
	}

简单吧。。。今天上午想了两个小时也没想出来 如何输出一个树，是真正的一颗树。。不是缩进。。感觉智商不够用了。。now 10点半，，come on让我们来研究一下。

我打算用非递归的方法遍历，不想看书不想百度，就自己想==。

一棵树要是按层次遍历的话

应该是一层一层的，别说这是废话。。想像一下那个遍历过程。

肯定得与遍历的上层结点有关系。因为完整的一层需要在上层不断切换结点。

所以一定要有一个临时变量来存着上层结点（重点哦~）

	public String tostring(BinaryNode<T> p) {
		String temp="";
		if(p.left!=null)
		temp+=p.left.data.toString();
		if(p.right!=null)
		temp+=p.right.data.toString();
		return temp;
	}

这是最里边的循环。

然后我们想一下外层的。

我想加一个循环，这样就能进入下一层了。。但是有一个问题，有左右两个结点，怎么进，用循环写的话如何分。

这样一想就又用到了递归。可是递归又不能只递归一层啊。。

恩。。像这种不知道循环多次，循环的步骤又不相同的，看来只能用递归了。至于如何分左右。。

像这种只能是根左右，左根根左右，右根根左右，感觉好难啊。。估计这写出来递归就算学会了。

	public String tostring(BinaryNode<T> p,int d) {
		String temp = "\t";
		temp += p.data.toString();
		temp += "\n";
		if (p.left != null&&d!=0) {
			d--;
			temp += tostring(p.left, d);
			temp += "\t";
			if (p.right != null) {
				temp += tostring(p.right,d);
			}
		}
		return temp;
	}

半天研究出来一个递归，可控制层数，感觉有希望。哈喇

上午想了一下，觉得做层次遍历不如直接做字符处理来的简单。

思路是这样的，普通的二叉树打印出来 是缩进 的。

\t的数量代表着这行的层数，这样只要把相同\t数量的结点重新排列一下就好了

说的简单。下面真正实现一下试试

啦啦啦，看见没，就是格式 还差一点问题，意思 有 了。想看代码 么哈

其实这个方法是不对的。但是思路是对的哈，更简单的方法是用另一种辅助数据结构，叫做队列，它有两个作用，一是将遍历控制在一层，这和上面的想法不谋而合，二是将遍历存储下来。这个的确是一个最有用的功能了。用队列很简单的，不懂的话看看图的那个算法，一个思想。