和郭峰争论遍历二叉树后

此代码乃本人亲手制作，特点是绝对清纯，用到了大学时的递归遍历二叉树的知识，热爱计算机的同学可以看一看，给点意见。

Node.java

 

class Node
{
	private String name;

	private Node leftChild;

	private Node rightChild;

	public Node(String name)
	{
		this.name = name;
	}

	public void output()
	{
		System.out.print(name + "-->");
	}

	public Node getLeft()
	{
		return leftChild;
	}

	public void setLeft(Node leftChild)
	{
		this.leftChild = leftChild;
	}

	public Node getRight()
	{
		return rightChild;
	}

	public void setRight(Node rightChild)
	{
		this.rightChild = rightChild;
	}

	public String getName()
	{
		return name;
	}
}

 

BinaryTree.java

class BinaryTree
{
	private Node root;

	private static Node pp;

	public Node getRoot()
	{
		return root;
	}

	private boolean iterateCompare(Node p, String name)
	{
		// 插入节点前先遍历一下二叉树查看有没有该父节点
		if (p.getLeft() != null && iterateCompare(p.getLeft(), name))
		{
			return true;
		}
		if (p.getName().equals(name))
		{
			BinaryTree.pp = p;
			return true;
		}
		if (p.getRight() != null && iterateCompare(p.getRight(), name))
		{
			return true;
		}
		return false;
	}

	// 中序遍历输出
	public void inOrderIterateOutput(Node p)
	{
		if (p.getLeft() != null)
		{
			inOrderIterateOutput(p.getLeft());
		}
		p.output();
		if (p.getRight() != null)
		{
			inOrderIterateOutput(p.getRight());
		}
	}

	// 先序遍历输出

	public void preOrderIterateOutput(Node p)
	{
		p.output();
		if (p.getLeft() != null)
		{
			preOrderIterateOutput(p.getLeft());
		}
		if (p.getRight() != null)
		{
			preOrderIterateOutput(p.getRight());
		}
	}

	// 后序遍历输出

	public void postOrderIterateOutput(Node p)
	{
		if (p.getLeft() != null)
		{
			postOrderIterateOutput(p.getLeft());
		}

		if (p.getRight() != null)
		{
			postOrderIterateOutput(p.getRight());
		}
		p.output();
	}

	public void initialize()
	{
		root = new Node("root");
	}

	public boolean addNode(String parent, String flag, String name)
	{
		if (!(flag.equals("L") || flag.equals("R")))
		{
			return false;
		}
		if (iterateCompare(root, parent))
		{// 找到有该节点
			if (flag.equals("L") && BinaryTree.pp.getLeft() == null)
			{
				BinaryTree.pp.setLeft(new Node(name));
				return true;
			}
			else if (flag.equals("R") && BinaryTree.pp.getRight() == null)
			{
				BinaryTree.pp.setRight(new Node(name));
				return true;
			}
			else
			{
				return false;
			}
		}
		else
		{
			return false;
		}
	}
}

 

 Test.java

class Test
{
	public static void main(String[] args)
	{
		BinaryTree bt = new BinaryTree();
		bt.initialize();
		if (bt.addNode("root", "L", "A"))
		{
			System.out.println("添加root--L-->A成功");
		}
		if (bt.addNode("root", "R", "B"))
		{
			System.out.println("添加root--R-->B成功");
		}
		if (bt.addNode("A", "L", "C"))
		{
			System.out.println("添加A--L-->C成功");
		}
		if (bt.addNode("B", "L", "D"))
		{
			System.out.println("添加B--L-->D成功");
		}
		if (bt.addNode("B", "R", "E"))
		{
			System.out.println("添加B--R-->E成功");
		}
		System.out.println("中序遍历");
		bt.inOrderIterateOutput(bt.getRoot());
		System.out.println("\n先序遍历");
		bt.preOrderIterateOutput(bt.getRoot());
		System.out.println("\n后序遍历");
		bt.postOrderIterateOutput(bt.getRoot());
	}
}

 

输出结果：

添加root--L-->A成功

添加root--R-->B成功

添加A--L-->C成功

添加B--L-->D成功

添加B--R-->E成功

中序遍历

C-->A-->root-->D-->B-->E-->

先序遍历

root-->A-->C-->B-->D-->E-->

后序遍历

C-->A-->D-->E-->B-->root-->